

'''simple docstring'''






import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor




class a_    :







   def __init__(self					,   __a					,   __a = 1_3					,   __a = 6_4					,   __a = 2					,   __a = 3					,   __a = 3					,   __a = True					,   __a = True					,   __a = 1_2_8					,   __a=[1_6, 3_2, 6_4, 1_2_8]					,   __a = 7					,   __a = 4					,   __a = 3_7					,   __a = "gelu"					,   __a = 0.1					,   __a = 0.1					,   __a = 1_0					,   __a = 0.02					,   __a = 2					,   __a = 1					,   __a = 1_2_8					,   __a = [2, 2, 2, 2]					,   __a = 2					,   __a = 2					,   )			->      str:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= parent
      __snake_case				:      Optional[int]     							= batch_size
      __snake_case				:      Optional[Any]     							= image_size
      __snake_case				:      Optional[int]     							= patch_size
      __snake_case				:      Optional[Any]     							= num_channels
      __snake_case				:      Optional[Any]     							= is_training
      __snake_case				:      Tuple     							= use_labels
      __snake_case				:      Optional[int]     							= hidden_size
      __snake_case				:      Any     							= num_hidden_layers
      __snake_case				:      List[str]     							= num_attention_heads
      __snake_case				:      Tuple     							= intermediate_size
      __snake_case				:      List[str]     							= hidden_act
      __snake_case				:      Dict     							= hidden_dropout_prob
      __snake_case				:      Any     							= attention_probs_dropout_prob
      __snake_case				:      Dict     							= type_sequence_label_size
      __snake_case				:      str     							= initializer_range
      __snake_case				:      int     							= encoder_stride
      __snake_case				:      List[str]     							= num_attention_outputs
      __snake_case				:      Optional[Any]     							= embed_dim
      __snake_case				:      Optional[Any]     							= embed_dim + 1
      __snake_case				:      List[str]     							= resolution
      __snake_case				:      Optional[int]     							= depths
      __snake_case				:      List[Any]     							= hidden_sizes
      __snake_case				:      List[str]     							= dim
      __snake_case				:      Union[str, Any]     							= mlp_expansion_ratio







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      __snake_case				:      List[str]     							= None
      if self.use_labels:
         __snake_case				:      Optional[int]     							= ids_tensor([self.batch_size]					,   self.type_sequence_label_size)

      __snake_case				:      Tuple     							= self.get_config()

      return config, pixel_values, labels







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      return EfficientFormerConfig(
          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=__a					,   initializer_range=self.initializer_range					,   encoder_stride=self.encoder_stride					,   resolution=self.resolution					,   depths=self.depths					,   hidden_sizes=self.hidden_sizes					,   dim=self.dim					,   mlp_expansion_ratio=self.mlp_expansion_ratio					,   )







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Optional[int]:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= TFEfficientFormerModel(config=__a)
      __snake_case				:      int     							= model(__a					,   training=__a)
      self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size))







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Tuple:
      """simple docstring"""






      __snake_case				:      Dict     							= self.type_sequence_label_size
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)
      __snake_case				:      Optional[int]     							= model(__a					,   labels=__a					,   training=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      __snake_case				:      List[Any]     							= 1
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)

      __snake_case				:      List[str]     							= floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
      __snake_case				:      str     							= model(__a					,   labels=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= self.prepare_config_and_inputs()
      __snake_case				:      Union[str, Any]     							= config_and_inputs
      __snake_case				:      Optional[int]     							= {'pixel_values': pixel_values}
      return config, inputs_dict




@require_tf
class a_    (    UpperCamelCase_		,      UpperCamelCase_		,      unittest.TestCase							):
   _snake_case        =							(
       (
           TFEfficientFormerModel,
           TFEfficientFormerForImageClassificationWithTeacher,
           TFEfficientFormerForImageClassification,
       )
       if is_tf_available()
       else ()
   )
   _snake_case        =							(
       {
           """feature-extraction""": TFEfficientFormerModel,
           """image-classification""": (
               TFEfficientFormerForImageClassification,
               TFEfficientFormerForImageClassificationWithTeacher,
           ),
       }
       if is_tf_available()
       else {}
   )

   _snake_case        =							False

   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False







   def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
      """simple docstring"""






      __snake_case				:      Dict     							= TFEfficientFormerModelTester(self)
      __snake_case				:      List[Any]     							= ConfigTester(
          self					,   config_class=__a					,   has_text_modality=__a					,   hidden_size=3_7)







   def     SCREAMING_SNAKE_CASE__					(self)			->      str:
      """simple docstring"""






      self.config_tester.run_common_tests()







   @unittest.skip(reason='EfficientFormer does not use inputs_embeds')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      pass







   @unittest.skip(reason='EfficientFormer does not support input and output embeddings')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      pass







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






      __snake_case				:      str     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[int]     							= model_class(__a)
         __snake_case				:      Union[str, Any]     							= inspect.signature(model.call)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __snake_case				:      Optional[int]     							= [*signature.parameters.keys()]

         __snake_case				:      Dict     							= ['pixel_values']
         self.assertListEqual(arg_names[:1]					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[int]:
      """simple docstring"""






      def check_hidden_states_output(__a					,   __a					,   __a):
         __snake_case				:      str     							= model_class(__a)

         __snake_case				:      List[Any]     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      str     							= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         __snake_case				:      Optional[Any]     							= getattr(
             self.model_tester					,   'expected_num_hidden_layers'					,   self.model_tester.num_hidden_layers + 1)
         self.assertEqual(len(__a)					,   __a)

         if hasattr(self.model_tester					,   'encoder_seq_length'):
            __snake_case				:      List[Any]     							= self.model_tester.encoder_seq_length
            if hasattr(self.model_tester					,   'chunk_length') and self.model_tester.chunk_length > 1:
               __snake_case				:      str     							= seq_length * self.model_tester.chunk_length
         else:
            __snake_case				:      Optional[int]     							= self.model_tester.seq_length

         self.assertListEqual(
             list(hidden_states[-1].shape[-2:])					,   [seq_length, self.model_tester.hidden_size]					,   )

         if config.is_encoder_decoder:
            __snake_case				:      List[Any]     							= outputs.decoder_hidden_states

            self.asseretIsInstance(__a					,   (list, tuple))
            self.assertEqual(len(__a)					,   __a)
            __snake_case				:      List[str]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
            __snake_case				:      Tuple     							= getattr(self.model_tester					,   'decoder_seq_length'					,   __a)

            self.assertListEqual(
                list(hidden_states[-1].shape[-2:])					,   [decoder_seq_length, self.model_tester.hidden_size]					,   )

      __snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      List[str]     							= True
         check_hidden_states_output(__a					,   __a					,   __a)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __snake_case				:      str     							= True

         check_hidden_states_output(__a					,   __a					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a=False)			->      int:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= super()._prepare_for_class(__a					,   __a					,   return_labels=__a)

      if return_labels:
         if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
            del inputs_dict["labels"]

      return inputs_dict







   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__a)







   @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case				:      int     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__a)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __snake_case				:      Any     							= TFEfficientFormerModel.from_pretrained(__a)
         self.assertIsNotNone(__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()
      __snake_case				:      Tuple     							= True

      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
      __snake_case				:      List[Any]     							= getattr(self.model_tester					,   'encoder_seq_length'					,   __a)
      __snake_case				:      Tuple     							= getattr(self.model_tester					,   'key_length'					,   __a)
      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'chunk_length'					,   __a)

      if chunk_length is not None and hasattr(self.model_tester					,   'num_hashes'):
         __snake_case				:      str     							= encoder_seq_length * self.model_tester.num_hashes

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[Any]     							= True
         __snake_case				:      Dict     							= False
         __snake_case				:      Optional[int]     							= True
         __snake_case				:      Dict     							= model_class(__a)

         __snake_case				:      Tuple     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      Union[str, Any]     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   self.model_tester.num_attention_outputs)

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __snake_case				:      Dict     							= True
         __snake_case				:      str     							= model_class(__a)
         __snake_case				:      str     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)

         __snake_case				:      Tuple     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   self.model_tester.num_attention_outputs)

         if chunk_length is not None:
            self.assertListEqual(
                list(attentions[0].shape[-4:])					,   [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]					,   )
         else:
            self.assertListEqual(
                list(attentions[0].shape[-3:])					,   [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,   )







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case				:      Dict     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         # Prepare our model
         __snake_case				:      Tuple     							= model_class(__a)
         # These are maximally general inputs for the model, with multiple None dimensions
         # Hopefully this will catch any conditionals that fail for flexible shapes
         __snake_case				:      Optional[Any]     							= {
             key: tf.keras.Input(shape=val.shape[1:]					,   dtype=val.dtype					,   name=__a)
             for key, val in model.input_signature.items()
             if key in model.dummy_inputs
         }
         __snake_case				:      Tuple     							= model(__a)
         self.assertTrue(outputs_dict is not None)




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   __snake_case				:      Tuple     							= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
   return image





@require_tf
@require_vision
class a_    (    unittest.TestCase							):







   @cached_property
   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      return (
          EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300')
          if is_vision_available()
          else None
      )







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300')
      __snake_case				:      Optional[int]     							= self.default_image_processor
      __snake_case				:      List[Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      List[str]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      str     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      Any     							= tf.constant([-0.0_555, 0.4_825, -0.0_852])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
          'snap-research/efficientformer-l1-300')
      __snake_case				:      List[Any]     							= self.default_image_processor
      __snake_case				:      Union[str, Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      Optional[int]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      Optional[int]     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      List[str]     							= tf.constant([-0.1_312, 0.4_353, -1.0_499])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))







'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A    	=   {
    '''configuration_distilbert''': [
        '''DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''DistilBertConfig''',
        '''DistilBertOnnxConfig''',
    ],
    '''tokenization_distilbert''': ['''DistilBertTokenizer'''],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   ['''DistilBertTokenizerFast''']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''DistilBertForMaskedLM''',
          '''DistilBertForMultipleChoice''',
          '''DistilBertForQuestionAnswering''',
          '''DistilBertForSequenceClassification''',
          '''DistilBertForTokenClassification''',
          '''DistilBertModel''',
          '''DistilBertPreTrainedModel''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFDistilBertForMaskedLM''',
          '''TFDistilBertForMultipleChoice''',
          '''TFDistilBertForQuestionAnswering''',
          '''TFDistilBertForSequenceClassification''',
          '''TFDistilBertForTokenClassification''',
          '''TFDistilBertMainLayer''',
          '''TFDistilBertModel''',
          '''TFDistilBertPreTrainedModel''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   [
          '''FlaxDistilBertForMaskedLM''',
          '''FlaxDistilBertForMultipleChoice''',
          '''FlaxDistilBertForQuestionAnswering''',
          '''FlaxDistilBertForSequenceClassification''',
          '''FlaxDistilBertForTokenClassification''',
          '''FlaxDistilBertModel''',
          '''FlaxDistilBertPreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_distilbert import (
          DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
          DistilBertConfig,
          DistilBertOnnxConfig,
      )
      from .tokenization_distilbert import DistilBertTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_distilbert_fast import DistilBertTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_distilbert import (
                DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                DistilBertForMaskedLM,
                DistilBertForMultipleChoice,
                DistilBertForQuestionAnswering,
                DistilBertForSequenceClassification,
                DistilBertForTokenClassification,
                DistilBertModel,
                DistilBertPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_distilbert import (
                TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFDistilBertForMaskedLM,
                TFDistilBertForMultipleChoice,
                TFDistilBertForQuestionAnswering,
                TFDistilBertForSequenceClassification,
                TFDistilBertForTokenClassification,
                TFDistilBertMainLayer,
                TFDistilBertModel,
                TFDistilBertPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_distilbert import (
                FlaxDistilBertForMaskedLM,
                FlaxDistilBertForMultipleChoice,
                FlaxDistilBertForQuestionAnswering,
                FlaxDistilBertForSequenceClassification,
                FlaxDistilBertForTokenClassification,
                FlaxDistilBertModel,
                FlaxDistilBertPreTrainedModel,
            )

else:
      import sys

      __A    	=   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)