





"""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 		__snake_case :





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase = 13 ,						__lowerCamelCase = 64 ,						__lowerCamelCase = 2 ,						__lowerCamelCase = 3 ,						__lowerCamelCase = 3 ,						__lowerCamelCase = True ,						__lowerCamelCase = True ,						__lowerCamelCase = 128 ,						__lowerCamelCase=[16, 32, 64, 128] ,						__lowerCamelCase = 7 ,						__lowerCamelCase = 4 ,						__lowerCamelCase = 37 ,						__lowerCamelCase = "gelu" ,						__lowerCamelCase = 0.1 ,						__lowerCamelCase = 0.1 ,						__lowerCamelCase = 10 ,						__lowerCamelCase = 0.0_2 ,						__lowerCamelCase = 2 ,						__lowerCamelCase = 1 ,						__lowerCamelCase = 128 ,						__lowerCamelCase = [2, 2, 2, 2] ,						__lowerCamelCase = 2 ,						__lowerCamelCase = 2 ,						):



     '''simple docstring'''




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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Optional[int]									=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

     __A   :						Any									=					None
     if self.use_labels:
         __A   :						Optional[Any]									=					ids_tensor([self.batch_size] ,						self.type_sequence_label_size  )

     __A   :						Any									=					self.get_config()

     return config, pixel_values, labels

 def  UpperCamelCase__(   self  ):



     '''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=__lowerCamelCase ,						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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




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

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						str									=					self.type_sequence_label_size
     __A   :						Union[str, Any]									=					TFEfficientFormerForImageClassification(__lowerCamelCase  )
     __A   :						List[str]									=					model(__lowerCamelCase ,						labels=__lowerCamelCase ,						training=__lowerCamelCase  )
     self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.type_sequence_label_size)  )

     # test greyscale images
     __A   :						int									=					1
     __A   :						Tuple									=					TFEfficientFormerForImageClassification(__lowerCamelCase  )

     __A   :						Optional[Any]									=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
     __A   :						Union[str, Any]									=					model(__lowerCamelCase ,						labels=__lowerCamelCase  )
     self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.type_sequence_label_size)  )







 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[Any]									=					self.prepare_config_and_inputs()
     __A			,	__A			,	__A   :						Dict									=					config_and_inputs
     __A   :						Tuple									=					{'''pixel_values''': pixel_values}
     return config, inputs_dict






@require_tf
class 		__snake_case (		SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							unittest.TestCase					):





 """simple docstring"""


 _lowerCamelCase				=					(
     (
         TFEfficientFormerModel,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerForImageClassification,
     )
     if is_tf_available()
     else ()
 )
 _lowerCamelCase				=					(
     {
         """feature-extraction""": TFEfficientFormerModel,
         """image-classification""": (
             TFEfficientFormerForImageClassification,
             TFEfficientFormerForImageClassificationWithTeacher,
         ),
     }
     if is_tf_available()
     else {}
 )

 _lowerCamelCase				=					False

 _lowerCamelCase				=					False
 _lowerCamelCase				=					False
 _lowerCamelCase				=					False
 _lowerCamelCase				=					False

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						str									=					TFEfficientFormerModelTester(self  )
     __A   :						List[str]									=					ConfigTester(
         self ,						config_class=__lowerCamelCase ,						has_text_modality=__lowerCamelCase ,						hidden_size=37  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     self.config_tester.run_common_tests()

 @unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''  )
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     pass

 @unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''  )
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     pass

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A			,	__A   :						Optional[Any]									=					self.model_tester.prepare_config_and_inputs_for_common()

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

         __A   :						List[str]									=					['''pixel_values''']
         self.assertListEqual(arg_names[:1] ,						__lowerCamelCase  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     def check_hidden_states_output(__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase  ):
         __A   :						int									=					model_class(__lowerCamelCase  )

         __A   :						Dict									=					model(**self._prepare_for_class(__lowerCamelCase ,						__lowerCamelCase  ) ,						training=__lowerCamelCase  )
         __A   :						List[Any]									=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         __A   :						int									=					getattr(
             self.model_tester ,						'''expected_num_hidden_layers''' ,						self.model_tester.num_hidden_layers + 1  )
         self.assertEqual(len(__lowerCamelCase  ) ,						__lowerCamelCase  )

         if hasattr(self.model_tester ,						'''encoder_seq_length'''  ):
             __A   :						Dict									=					self.model_tester.encoder_seq_length
             if hasattr(self.model_tester ,						'''chunk_length'''  ) and self.model_tester.chunk_length > 1:
                 __A   :						str									=					seq_length * self.model_tester.chunk_length
         else:
             __A   :						List[Any]									=					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:
             __A   :						Union[str, Any]									=					outputs.decoder_hidden_states

             self.asseretIsInstance(__lowerCamelCase ,						(list, tuple)  )
             self.assertEqual(len(__lowerCamelCase  ) ,						__lowerCamelCase  )
             __A   :						int									=					getattr(self.model_tester ,						'''seq_length''' ,						__lowerCamelCase  )
             __A   :						Optional[int]									=					getattr(self.model_tester ,						'''decoder_seq_length''' ,						__lowerCamelCase  )

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

     __A			,	__A   :						Dict									=					self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         __A   :						Any									=					True
         check_hidden_states_output(__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase  )

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

         check_hidden_states_output(__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase  )

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase=False  ):



     '''simple docstring'''




     __A   :						List[str]									=					super()._prepare_for_class(__lowerCamelCase ,						__lowerCamelCase ,						return_labels=__lowerCamelCase  )

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

     return inputs_dict

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[str]									=					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowerCamelCase  )

 @unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''  )
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[str]									=					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCamelCase  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Tuple									=					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase  )

 @slow
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __A   :						Tuple									=					TFEfficientFormerModel.from_pretrained(__lowerCamelCase  )
         self.assertIsNotNone(__lowerCamelCase  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A			,	__A   :						List[str]									=					self.model_tester.prepare_config_and_inputs_for_common()
     __A   :						Tuple									=					True

     __A   :						Tuple									=					getattr(self.model_tester ,						'''seq_length''' ,						__lowerCamelCase  )
     __A   :						int									=					getattr(self.model_tester ,						'''encoder_seq_length''' ,						__lowerCamelCase  )
     __A   :						Any									=					getattr(self.model_tester ,						'''key_length''' ,						__lowerCamelCase  )
     __A   :						Optional[int]									=					getattr(self.model_tester ,						'''chunk_length''' ,						__lowerCamelCase  )

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

     for model_class in self.all_model_classes:
         __A   :						Any									=					True
         __A   :						Optional[Any]									=					False
         __A   :						List[Any]									=					True
         __A   :						List[str]									=					model_class(__lowerCamelCase  )

         __A   :						Tuple									=					model(**self._prepare_for_class(__lowerCamelCase ,						__lowerCamelCase  ) ,						training=__lowerCamelCase  )
         __A   :						List[str]									=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__lowerCamelCase  ) ,						self.model_tester.num_attention_outputs  )

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __A   :						Optional[Any]									=					True
         __A   :						List[str]									=					model_class(__lowerCamelCase  )
         __A   :						Union[str, Any]									=					model(**self._prepare_for_class(__lowerCamelCase ,						__lowerCamelCase  ) ,						training=__lowerCamelCase  )

         __A   :						Tuple									=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__lowerCamelCase  ) ,						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  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A			,	__A   :						Optional[Any]									=					self.model_tester.prepare_config_and_inputs_for_common()

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







def 		__lowercase					(       )       ->Any:



    '''simple docstring'''







    __A   :						Optional[int]									=					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
    return image






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





 """simple docstring"""


 @cached_property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




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

 @slow
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Tuple									=					TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''  )
     __A   :						Optional[int]									=					self.default_image_processor
     __A   :						str									=					prepare_img()
     __A   :						Union[str, Any]									=					image_processor(images=__lowerCamelCase ,						return_tensors='''tf'''  )
     # forward pass
     __A   :						Dict									=					model(**__lowerCamelCase ,						training=__lowerCamelCase  )
     # verify the logits
     __A   :						Union[str, Any]									=					tf.TensorShape((1, 1000)  )
     self.assertEqual(outputs.logits.shape ,						__lowerCamelCase  )
     __A   :						Tuple									=					tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]  )
     self.assertTrue(np.allclose(outputs.logits[0, :3] ,						__lowerCamelCase ,						atol=1e-4  )  )







 @slow
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




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











"""simple docstring"""



from typing import TYPE_CHECKING

from ....utils import _LazyModule


a_			=      {"""tokenization_tapex""": ["""TapexTokenizer"""]}


if TYPE_CHECKING:
       from .tokenization_tapex import TapexTokenizer


else:
       import sys

       a_			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure)




