


import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
 import jax

 from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel

class   A__ (   unittest.TestCase     ):







    """simple docstring"""

    def __init__(	self      , __snake_case      , __snake_case=1_3      , __snake_case=3_0      , __snake_case=2      , __snake_case=3      , __snake_case=True      , __snake_case=True      , __snake_case=3_2      , __snake_case=5      , __snake_case=4      , __snake_case=3_7      , __snake_case="gelu"      , __snake_case=0.1      , __snake_case=0.1      , __snake_case=1_0      , __snake_case=0.02      , ):
         snake_case					=    parent
         snake_case					=    batch_size
         snake_case					=    image_size
         snake_case					=    patch_size
         snake_case					=    num_channels
         snake_case					=    is_training
         snake_case					=    use_labels
         snake_case					=    hidden_size
         snake_case					=    num_hidden_layers
         snake_case					=    num_attention_heads
         snake_case					=    intermediate_size
         snake_case					=    hidden_act
         snake_case					=    hidden_dropout_prob
         snake_case					=    attention_probs_dropout_prob
         snake_case					=    type_sequence_label_size
         snake_case					=    initializer_range

         # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
         snake_case					=    (image_size // patch_size) ** 2
         snake_case					=    num_patches + 1
    def 		a_      (	self   ):
         snake_case					=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

         snake_case					=    ViTConfig(
             image_size=self.image_size      , patch_size=self.patch_size      , num_channels=self.num_channels      , hidden_size=self.hidden_size      , num_hidden_layers=self.num_hidden_layers      , num_attention_heads=self.num_attention_heads      , intermediate_size=self.intermediate_size      , hidden_act=self.hidden_act      , hidden_dropout_prob=self.hidden_dropout_prob      , attention_probs_dropout_prob=self.attention_probs_dropout_prob      , is_decoder=__snake_case      , initializer_range=self.initializer_range      , )

         return config, pixel_values
    def 		a_      (	self      , __snake_case      , __snake_case   ):
         snake_case					=    FlaxViTModel(config=__snake_case   )
         snake_case					=    model(__snake_case   )
         # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
         snake_case					=    (self.image_size, self.image_size)
         snake_case					=    (self.patch_size, self.patch_size)
         snake_case					=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
         self.parent.assertEqual(result.last_hidden_state.shape      , (self.batch_size, num_patches + 1, self.hidden_size)   )
    def 		a_      (	self      , __snake_case      , __snake_case   ):
         snake_case					=    self.type_sequence_label_size
         snake_case					=    FlaxViTForImageClassification(config=__snake_case   )
         snake_case					=    model(__snake_case   )
         self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.type_sequence_label_size)   )

         # test greyscale images
         snake_case					=    1
         snake_case					=    FlaxViTForImageClassification(__snake_case   )

         snake_case					=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
         snake_case					=    model(__snake_case   )




    def 		a_      (	self   ):
         snake_case					=    self.prepare_config_and_inputs()
         (
             (
             snake_case
         )			,  (
             snake_case
         )			,  
         )					=    config_and_inputs
         snake_case					=    {'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_flax
class   A__ (   snake_case__	, unittest.TestCase     ):







    """simple docstring"""

    __magic_name__        =		(FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()
    def 		a_      (	self   ):
         snake_case					=    FlaxViTModelTester(self   )
         snake_case					=    ConfigTester(self      , config_class=__snake_case      , has_text_modality=__snake_case      , hidden_size=3_7   )
    def 		a_      (	self   ):
         self.config_tester.run_common_tests()
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__snake_case   )
    def 		a_      (	self   ):
         snake_case			,  snake_case					=    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              snake_case					=    model_class(__snake_case   )
              snake_case					=    inspect.signature(model.__call__   )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              snake_case					=    [*signature.parameters.keys()]

              snake_case					=    ['''pixel_values''']
              self.assertListEqual(arg_names[:1]      , __snake_case   )
    def 		a_      (	self   ):
         snake_case			,  snake_case					=    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              with self.subTest(model_class.__name__   ):
                   snake_case					=    self._prepare_for_class(__snake_case      , __snake_case   )
                   snake_case					=    model_class(__snake_case   )

                   @jax.jit
                   def model_jitted(__snake_case      , **__snake_case   ):
                        return model(pixel_values=__snake_case      , **__snake_case   )

                   with self.subTest('''JIT Enabled'''   ):
                        snake_case					=    model_jitted(**__snake_case   ).to_tuple()

                   with self.subTest('''JIT Disabled'''   ):
                        with jax.disable_jit():
                             snake_case					=    model_jitted(**__snake_case   ).to_tuple()

                   self.assertEqual(len(__snake_case   )      , len(__snake_case   )   )
                   for jitted_output, output in zip(__snake_case      , __snake_case   ):
                        self.assertEqual(jitted_output.shape      , output.shape   )




    @slow
    def 		a_      (	self   ):
         for model_class_name in self.all_model_classes:
              snake_case					=    model_class_name.from_pretrained('''google/vit-base-patch16-224'''   )
              snake_case					=    model(np.ones((1, 3, 2_2_4, 2_2_4)   )   )
              self.assertIsNotNone(__snake_case   )








import math

class   A__ :







    """simple docstring"""

    def 		a_      (	self      , __snake_case      , __snake_case   ):
         snake_case					=    0.0
         snake_case					=    0.0
         for i in range(len(__snake_case   )   ):
              da += math.pow((sample[i] - weights[0][i])      , 2   )
              da += math.pow((sample[i] - weights[1][i])      , 2   )
              return 0 if da > da else 1
         return 0




    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case      , __snake_case   ):
         for i in range(len(__snake_case   )   ):
              weights[j][i] += alpha * (sample[i] - weights[j][i])
         return weights






def       UpperCAmelCase__						():



     """simple docstring"""






     snake_case					=    [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

     # weight initialization ( n, C )
     snake_case					=    [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

     # training
     snake_case					=    SelfOrganizingMap()
     snake_case					=    3
     snake_case					=    0.5

     for _ in range(UpperCamelCase_    ):
          for j in range(len(UpperCamelCase_    )    ):
               # training sample
               snake_case					=    training_samples[j]

               # Compute the winning vector
               snake_case					=    self_organizing_map.get_winner(UpperCamelCase_							,UpperCamelCase_    )

               # Update the winning vector
               snake_case					=    self_organizing_map.update(UpperCamelCase_							,UpperCamelCase_							,UpperCamelCase_							,UpperCamelCase_    )

    # classify test sample
     snake_case					=    [0, 0, 0, 1]
     snake_case					=    self_organizing_map.get_winner(UpperCamelCase_							,UpperCamelCase_    )

     # results
     print(F'''Clusters that the test sample belongs to : {winner}'''    )
     print(F'''Weights that have been trained : {weights}'''    )


# running the main() function
if __name__ == "__main__":
 main()




