


'''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 						__SCREAMING_SNAKE_CASE					:






     def __init__(			self     ,							__UpperCamelCase     ,							__UpperCamelCase = 13     ,							__UpperCamelCase = 64     ,							__UpperCamelCase = 2     ,							__UpperCamelCase = 3     ,							__UpperCamelCase = 3     ,							__UpperCamelCase = True     ,							__UpperCamelCase = True     ,							__UpperCamelCase = 128     ,							__UpperCamelCase=[16, 32, 64, 128]     ,							__UpperCamelCase = 7     ,							__UpperCamelCase = 4     ,							__UpperCamelCase = 37     ,							__UpperCamelCase = "gelu"     ,							__UpperCamelCase = 0.1     ,							__UpperCamelCase = 0.1     ,							__UpperCamelCase = 10     ,							__UpperCamelCase = 0.02     ,							__UpperCamelCase = 2     ,							__UpperCamelCase = 1     ,							__UpperCamelCase = 128     ,							__UpperCamelCase = [2, 2, 2, 2]     ,							__UpperCamelCase = 2     ,							__UpperCamelCase = 2     ,							)       ->    Optional[int]:
          _a						=		parent
          _a						=		batch_size
          _a						=		image_size
          _a						=		patch_size
          _a						=		num_channels
          _a						=		is_training
          _a						=		use_labels
          _a						=		hidden_size
          _a						=		num_hidden_layers
          _a						=		num_attention_heads
          _a						=		intermediate_size
          _a						=		hidden_act
          _a						=		hidden_dropout_prob
          _a						=		attention_probs_dropout_prob
          _a						=		type_sequence_label_size
          _a						=		initializer_range
          _a						=		encoder_stride
          _a						=		num_attention_outputs
          _a						=		embed_dim
          _a						=		embed_dim + 1
          _a						=		resolution
          _a						=		depths
          _a						=		hidden_sizes
          _a						=		dim
          _a						=		mlp_expansion_ratio






     def  a_					(			self		)       ->    List[Any]:
          _a						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

          _a						=		None
          if self.use_labels:
               _a						=		ids_tensor([self.batch_size]     ,							self.type_sequence_label_size		)

          _a						=		self.get_config()

          return config, pixel_values, labels






     def  a_					(			self		)       ->    Dict:
          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=__UpperCamelCase     ,							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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    Union[str, Any]:
          _a						=		TFEfficientFormerModel(config=__UpperCamelCase		)
          _a						=		model(__UpperCamelCase     ,							training=__UpperCamelCase		)
          self.parent.assertEqual(result.last_hidden_state.shape     ,							(self.batch_size, self.seq_length, self.hidden_size)		)






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    Dict:
          _a						=		self.type_sequence_label_size
          _a						=		TFEfficientFormerForImageClassification(__UpperCamelCase		)
          _a						=		model(__UpperCamelCase     ,							labels=__UpperCamelCase     ,							training=__UpperCamelCase		)
          self.parent.assertEqual(result.logits.shape     ,							(self.batch_size, self.type_sequence_label_size)		)

          # test greyscale images
          _a						=		1
          _a						=		TFEfficientFormerForImageClassification(__UpperCamelCase		)

          _a						=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
          _a						=		model(__UpperCamelCase     ,							labels=__UpperCamelCase		)
          self.parent.assertEqual(result.logits.shape     ,							(self.batch_size, self.type_sequence_label_size)		)






     def  a_					(			self		)       ->    int:
          _a						=		self.prepare_config_and_inputs()
          _a			,			_a			,			_a						=		config_and_inputs
          _a						=		{"pixel_values": pixel_values}
          return config, inputs_dict







@require_tf
class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ,			lowerCamelCase__ ,			unittest.TestCase ):
     UpperCAmelCase 					=				(
         (
             TFEfficientFormerModel,
             TFEfficientFormerForImageClassificationWithTeacher,
             TFEfficientFormerForImageClassification,
         )
         if is_tf_available()
         else ()
     )
     UpperCAmelCase 					=				(
         {
             '''feature-extraction''': TFEfficientFormerModel,
             '''image-classification''': (
                 TFEfficientFormerForImageClassification,
                 TFEfficientFormerForImageClassificationWithTeacher,
             ),
         }
         if is_tf_available()
         else {}
     )

     UpperCAmelCase 					=				False

     UpperCAmelCase 					=				False
     UpperCAmelCase 					=				False
     UpperCAmelCase 					=				False
     UpperCAmelCase 					=				False






     def  a_					(			self		)       ->    str:
          _a						=		TFEfficientFormerModelTester(self		)
          _a						=		ConfigTester(
              self     ,							config_class=__UpperCamelCase     ,							has_text_modality=__UpperCamelCase     ,							hidden_size=37		)






     def  a_					(			self		)       ->    List[Any]:
          self.config_tester.run_common_tests()






     @unittest.skip(reason="EfficientFormer does not use inputs_embeds"		)
     def  a_					(			self		)       ->    Optional[int]:
          pass






     @unittest.skip(reason="EfficientFormer does not support input and output embeddings"		)
     def  a_					(			self		)       ->    str:
          pass






     def  a_					(			self		)       ->    List[str]:
          _a			,			_a						=		self.model_tester.prepare_config_and_inputs_for_common()

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

               _a						=		["pixel_values"]
               self.assertListEqual(arg_names[:1]     ,							__UpperCamelCase		)






     def  a_					(			self		)       ->    Any:
          def check_hidden_states_output(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		):
               _a						=		model_class(__UpperCamelCase		)

               _a						=		model(**self._prepare_for_class(__UpperCamelCase     ,							__UpperCamelCase		)     ,							training=__UpperCamelCase		)
               _a						=		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

               _a						=		getattr(
                   self.model_tester     ,							"expected_num_hidden_layers"     ,							self.model_tester.num_hidden_layers + 1		)
               self.assertEqual(len(__UpperCamelCase		)     ,							__UpperCamelCase		)

               if hasattr(self.model_tester     ,							"encoder_seq_length"		):
                    _a						=		self.model_tester.encoder_seq_length
                    if hasattr(self.model_tester     ,							"chunk_length"		) and self.model_tester.chunk_length > 1:
                         _a						=		seq_length * self.model_tester.chunk_length
               else:
                    _a						=		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						=		outputs.decoder_hidden_states

                    self.asseretIsInstance(__UpperCamelCase     ,							(list, tuple)		)
                    self.assertEqual(len(__UpperCamelCase		)     ,							__UpperCamelCase		)
                    _a						=		getattr(self.model_tester     ,							"seq_length"     ,							__UpperCamelCase		)
                    _a						=		getattr(self.model_tester     ,							"decoder_seq_length"     ,							__UpperCamelCase		)

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

          _a			,			_a						=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               _a						=		True
               check_hidden_states_output(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               _a						=		True

               check_hidden_states_output(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase=False		)       ->    Optional[int]:
          _a						=		super()._prepare_for_class(__UpperCamelCase     ,							__UpperCamelCase     ,							return_labels=__UpperCamelCase		)

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

          return inputs_dict






     def  a_					(			self		)       ->    Union[str, Any]:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__UpperCamelCase		)






     @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"		)
     def  a_					(			self		)       ->    Tuple:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase		)






     def  a_					(			self		)       ->    str:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase		)






     @slow
     def  a_					(			self		)       ->    Optional[Any]:
          for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _a						=		TFEfficientFormerModel.from_pretrained(__UpperCamelCase		)
               self.assertIsNotNone(__UpperCamelCase		)






     def  a_					(			self		)       ->    Optional[Any]:
          _a			,			_a						=		self.model_tester.prepare_config_and_inputs_for_common()
          _a						=		True

          _a						=		getattr(self.model_tester     ,							"seq_length"     ,							__UpperCamelCase		)
          _a						=		getattr(self.model_tester     ,							"encoder_seq_length"     ,							__UpperCamelCase		)
          _a						=		getattr(self.model_tester     ,							"key_length"     ,							__UpperCamelCase		)
          _a						=		getattr(self.model_tester     ,							"chunk_length"     ,							__UpperCamelCase		)

          if chunk_length is not None and hasattr(self.model_tester     ,							"num_hashes"		):
               _a						=		encoder_seq_length * self.model_tester.num_hashes

          for model_class in self.all_model_classes:
               _a						=		True
               _a						=		False
               _a						=		True
               _a						=		model_class(__UpperCamelCase		)

               _a						=		model(**self._prepare_for_class(__UpperCamelCase     ,							__UpperCamelCase		)     ,							training=__UpperCamelCase		)
               _a						=		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
               self.assertEqual(len(__UpperCamelCase		)     ,							self.model_tester.num_attention_outputs		)

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               _a						=		True
               _a						=		model_class(__UpperCamelCase		)
               _a						=		model(**self._prepare_for_class(__UpperCamelCase     ,							__UpperCamelCase		)     ,							training=__UpperCamelCase		)

               _a						=		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
               self.assertEqual(len(__UpperCamelCase		)     ,							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  a_					(			self		)       ->    Optional[Any]:
          # We use a simplified version of this test for EfficientFormer because it requires training=False
          # and Keras refuses to let us force that during functional construction
          _a			,			_a						=		self.model_tester.prepare_config_and_inputs_for_common()

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







def __UpperCamelCase   (			)      ->     str:







     '''simple docstring'''






     _a						=		Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
     return image






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






     @cached_property
     def  a_					(			self		)       ->    Dict:
          return (
              EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"		)
              if is_vision_available()
              else None
          )






     @slow
     def  a_					(			self		)       ->    Union[str, Any]:
          _a						=		TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"		)
          _a						=		self.default_image_processor
          _a						=		prepare_img()
          _a						=		image_processor(images=__UpperCamelCase     ,							return_tensors="tf"		)
          # forward pass
          _a						=		model(**__UpperCamelCase     ,							training=__UpperCamelCase		)
          # verify the logits
          _a						=		tf.TensorShape((1, 1_000)		)
          self.assertEqual(outputs.logits.shape     ,							__UpperCamelCase		)
          _a						=		tf.constant([-0.05_55, 0.48_25, -0.08_52]		)
          self.assertTrue(np.allclose(outputs.logits[0, :3]     ,							__UpperCamelCase     ,							atol=1e-4		)		)






     @slow
     def  a_					(			self		)       ->    int:
          _a						=		TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
              "snap-research/efficientformer-l1-300"		)
          _a						=		self.default_image_processor
          _a						=		prepare_img()
          _a						=		image_processor(images=__UpperCamelCase     ,							return_tensors="tf"		)
          # forward pass
          _a						=		model(**__UpperCamelCase     ,							training=__UpperCamelCase		)
          # verify the logits
          _a						=		tf.TensorShape((1, 1_000)		)
          self.assertEqual(outputs.logits.shape     ,							__UpperCamelCase		)
          _a						=		tf.constant([-0.13_12, 0.43_53, -1.04_99]		)
          self.assertTrue(np.allclose(outputs.logits[0, :3]     ,							__UpperCamelCase     ,							atol=1e-4		)		)





'''simple docstring'''

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__				     =		logging.get_logger(__name__)





class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ):
     UpperCAmelCase 					=				'''encoder-decoder'''
     UpperCAmelCase 					=				True






     def __init__(			self     ,							**__UpperCamelCase		)       ->    List[Any]:
          super().__init__(**__UpperCamelCase		)
          assert (
              "encoder" in kwargs and "decoder" in kwargs
          ), "Config has to be initialized with encoder and decoder config"
          _a						=		kwargs.pop("encoder"		)
          _a						=		encoder_config.pop("model_type"		)
          _a						=		kwargs.pop("decoder"		)
          _a						=		decoder_config.pop("model_type"		)

          from ..auto.configuration_auto import AutoConfig

          _a						=		AutoConfig.for_model(__UpperCamelCase     ,							**__UpperCamelCase		)
          _a						=		AutoConfig.for_model(__UpperCamelCase     ,							**__UpperCamelCase		)
          _a						=		True






     @classmethod
     def  a_					(			cls     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							**__UpperCamelCase		)       ->    PretrainedConfig:
          logger.info("Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"		)
          _a						=		True
          _a						=		True

          return cls(encoder=encoder_config.to_dict()     ,							decoder=decoder_config.to_dict()     ,							**__UpperCamelCase		)






     def  a_					(			self		)       ->    Any:
          _a						=		copy.deepcopy(self.__dict__		)
          _a						=		self.encoder.to_dict()
          _a						=		self.decoder.to_dict()
          _a						=		self.__class__.model_type
          return output

