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





       '''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	,   )  ->  str:
        lowercase__				:    Optional[Any]  =					parent
        lowercase__				:    Any  =					batch_size
        lowercase__				:    List[str]  =					image_size
        lowercase__				:    Dict  =					patch_size
        lowercase__				:    str  =					num_channels
        lowercase__				:    List[Any]  =					is_training
        lowercase__				:    int  =					use_labels
        lowercase__				:    Any  =					hidden_size
        lowercase__				:    int  =					num_hidden_layers
        lowercase__				:    Any  =					num_attention_heads
        lowercase__				:    List[Any]  =					intermediate_size
        lowercase__				:    Optional[Any]  =					hidden_act
        lowercase__				:    Dict  =					hidden_dropout_prob
        lowercase__				:    int  =					attention_probs_dropout_prob
        lowercase__				:    str  =					type_sequence_label_size
        lowercase__				:    Union[str, Any]  =					initializer_range
        lowercase__				:    List[Any]  =					encoder_stride
        lowercase__				:    Dict  =					num_attention_outputs
        lowercase__				:    Dict  =					embed_dim
        lowercase__				:    int  =					embed_dim + 1
        lowercase__				:    Dict  =					resolution
        lowercase__				:    Tuple  =					depths
        lowercase__				:    str  =					hidden_sizes
        lowercase__				:    Dict  =					dim
        lowercase__				:    Dict  =					mlp_expansion_ratio

       def _lowerCAmelCase(						self )  ->  Any:
        lowercase__				:    str  =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        lowercase__				:    int  =					None
        if self.use_labels:
         lowercase__				:    Union[str, Any]  =					ids_tensor([self.batch_size]	,   self.type_sequence_label_size )

        lowercase__				:    Dict  =					self.get_config()

        return config, pixel_values, labels

       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        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 _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  int:
        lowercase__				:    Optional[Any]  =					TFEfficientFormerModel(config=__lowerCAmelCase )
        lowercase__				:    List[str]  =					model(__lowerCAmelCase	,   training=__lowerCAmelCase )
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.hidden_size) )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  int:
        lowercase__				:    Union[str, Any]  =					self.type_sequence_label_size
        lowercase__				:    Optional[Any]  =					TFEfficientFormerForImageClassification(__lowerCAmelCase )
        lowercase__				:    Optional[Any]  =					model(__lowerCAmelCase	,   labels=__lowerCAmelCase	,   training=__lowerCAmelCase )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.type_sequence_label_size) )

        # test greyscale images
        lowercase__				:    Dict  =					1
        lowercase__				:    List[Any]  =					TFEfficientFormerForImageClassification(__lowerCAmelCase )

        lowercase__				:    str  =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
        lowercase__				:    Tuple  =					model(__lowerCAmelCase	,   labels=__lowerCAmelCase )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.type_sequence_label_size) )


       def _lowerCAmelCase(						self )  ->  Any:
        lowercase__				:    List[str]  =					self.prepare_config_and_inputs()
        lowercase__ ,							lowercase__ ,							lowercase__				:    int  =					config_and_inputs
        lowercase__				:    Tuple  =					{'''pixel_values''': pixel_values}
        return config, inputs_dict



@require_tf
class 			UpperCAmelCase  (						a__    ,						a__    ,						unittest.TestCase					):





       '''simple docstring'''



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

       SCREAMING_SNAKE_CASE							=    False

       SCREAMING_SNAKE_CASE							=    False
       SCREAMING_SNAKE_CASE							=    False
       SCREAMING_SNAKE_CASE							=    False
       SCREAMING_SNAKE_CASE							=    False

       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    List[str]  =					TFEfficientFormerModelTester(self )
        lowercase__				:    Union[str, Any]  =					ConfigTester(
            self	,   config_class=__lowerCAmelCase	,   has_text_modality=__lowerCAmelCase	,   hidden_size=37 )

       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        self.config_tester.run_common_tests()

       @unittest.skip(reason='''EfficientFormer does not use inputs_embeds''' )
       def _lowerCAmelCase(						self )  ->  str:
        pass

       @unittest.skip(reason='''EfficientFormer does not support input and output embeddings''' )
       def _lowerCAmelCase(						self )  ->  List[str]:
        pass

       def _lowerCAmelCase(						self )  ->  int:
        lowercase__ ,							lowercase__				:    List[Any]  =					self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         lowercase__				:    Tuple  =					model_class(__lowerCAmelCase )
         lowercase__				:    Optional[int]  =					inspect.signature(model.call )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         lowercase__				:    Any  =					[*signature.parameters.keys()]

         lowercase__				:    int  =					['''pixel_values''']
         self.assertListEqual(arg_names[:1]	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Dict:
        def check_hidden_states_output(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase ):
         lowercase__				:    Union[str, Any]  =					model_class(__lowerCAmelCase )

         lowercase__				:    Tuple  =					model(**self._prepare_for_class(__lowerCAmelCase	,   __lowerCAmelCase )	,   training=__lowerCAmelCase )
         lowercase__				:    Optional[int]  =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

          self.asseretIsInstance(__lowerCAmelCase	,   (list, tuple) )
          self.assertEqual(len(__lowerCAmelCase )	,   __lowerCAmelCase )
          lowercase__				:    str  =					getattr(self.model_tester	,   '''seq_length'''	,   __lowerCAmelCase )
          lowercase__				:    Tuple  =					getattr(self.model_tester	,   '''decoder_seq_length'''	,   __lowerCAmelCase )

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

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

        for model_class in self.all_model_classes:
         lowercase__				:    int  =					True
         check_hidden_states_output(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

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

         check_hidden_states_output(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase=False )  ->  Optional[Any]:
        lowercase__				:    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 _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Tuple  =					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 _lowerCAmelCase(						self )  ->  Optional[int]:
        lowercase__				:    Optional[int]  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Tuple:
        lowercase__				:    Dict  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase )

       @slow
       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowercase__				:    Optional[Any]  =					TFEfficientFormerModel.from_pretrained(__lowerCAmelCase )
         self.assertIsNotNone(__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  List[Any]:
        lowercase__ ,							lowercase__				:    Optional[int]  =					self.model_tester.prepare_config_and_inputs_for_common()
        lowercase__				:    int  =					True

        lowercase__				:    List[Any]  =					getattr(self.model_tester	,   '''seq_length'''	,   __lowerCAmelCase )
        lowercase__				:    Union[str, Any]  =					getattr(self.model_tester	,   '''encoder_seq_length'''	,   __lowerCAmelCase )
        lowercase__				:    List[str]  =					getattr(self.model_tester	,   '''key_length'''	,   __lowerCAmelCase )
        lowercase__				:    List[Any]  =					getattr(self.model_tester	,   '''chunk_length'''	,   __lowerCAmelCase )

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

        for model_class in self.all_model_classes:
         lowercase__				:    int  =					True
         lowercase__				:    Dict  =					False
         lowercase__				:    List[str]  =					True
         lowercase__				:    Tuple  =					model_class(__lowerCAmelCase )

         lowercase__				:    List[Any]  =					model(**self._prepare_for_class(__lowerCAmelCase	,   __lowerCAmelCase )	,   training=__lowerCAmelCase )
         lowercase__				:    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"]
         lowercase__				:    Any  =					True
         lowercase__				:    Optional[int]  =					model_class(__lowerCAmelCase )
         lowercase__				:    Optional[Any]  =					model(**self._prepare_for_class(__lowerCAmelCase	,   __lowerCAmelCase )	,   training=__lowerCAmelCase )

         lowercase__				:    List[Any]  =					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 _lowerCAmelCase(						self )  ->  int:
        # 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
        lowercase__ ,							lowercase__				:    Optional[int]  =					self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         # Prepare our model
         lowercase__				:    Optional[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
         lowercase__				:    List[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
         }
         lowercase__				:    Optional[int]  =					model(__lowerCAmelCase )
         self.assertTrue(outputs_dict is not None )


def 			__UpperCamelCase       (   ):
 lowercase__				:    int  =					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
 return image





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





       '''simple docstring'''



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

       @slow
       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    Dict  =					TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300''' )
        lowercase__				:    Optional[int]  =					self.default_image_processor
        lowercase__				:    Union[str, Any]  =					prepare_img()
        lowercase__				:    int  =					image_processor(images=__lowerCAmelCase	,   return_tensors='''tf''' )
        # forward pass
        lowercase__				:    Any  =					model(**__lowerCAmelCase	,   training=__lowerCAmelCase )
        # verify the logits
        lowercase__				:    int  =					tf.TensorShape((1, 1000) )
        self.assertEqual(outputs.logits.shape	,   __lowerCAmelCase )
        lowercase__				:    Dict  =					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 _lowerCAmelCase(						self )  ->  List[str]:
        lowercase__				:    Optional[int]  =					TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
            '''snap-research/efficientformer-l1-300''' )
        lowercase__				:    List[str]  =					self.default_image_processor
        lowercase__				:    Optional[Any]  =					prepare_img()
        lowercase__				:    Optional[Any]  =					image_processor(images=__lowerCAmelCase	,   return_tensors='''tf''' )
        # forward pass
        lowercase__				:    str  =					model(**__lowerCAmelCase	,   training=__lowerCAmelCase )
        # verify the logits
        lowercase__				:    Optional[int]  =					tf.TensorShape((1, 1000) )
        self.assertEqual(outputs.logits.shape	,   __lowerCAmelCase )
        lowercase__				:    Union[str, Any]  =					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'''

import copy

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


__a: List[str]          =   logging.get_logger(__name__)



class 			UpperCAmelCase  (						a__					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    "encoder-decoder"
       SCREAMING_SNAKE_CASE							=    True

       def __init__(						self	,   **__lowerCAmelCase )  ->  int:
        super().__init__(**__lowerCAmelCase )
        assert (
            "encoder" in kwargs and "decoder" in kwargs
        ), "Config has to be initialized with encoder and decoder config"
        lowercase__				:    Optional[int]  =					kwargs.pop('''encoder''' )
        lowercase__				:    Union[str, Any]  =					encoder_config.pop('''model_type''' )
        lowercase__				:    Any  =					kwargs.pop('''decoder''' )
        lowercase__				:    Any  =					decoder_config.pop('''model_type''' )

        from ..auto.configuration_auto import AutoConfig

        lowercase__				:    Union[str, Any]  =					AutoConfig.for_model(__lowerCAmelCase	,   **__lowerCAmelCase )
        lowercase__				:    Optional[Any]  =					AutoConfig.for_model(__lowerCAmelCase	,   **__lowerCAmelCase )
        lowercase__				:    Tuple  =					True

       @classmethod
       def _lowerCAmelCase(						cls	,   __lowerCAmelCase	,   __lowerCAmelCase	,   **__lowerCAmelCase )  ->  PretrainedConfig:
        logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config''' )
        lowercase__				:    Union[str, Any]  =					True
        lowercase__				:    Any  =					True

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


       def _lowerCAmelCase(						self )  ->  Any:
        lowercase__				:    Any  =					copy.deepcopy(self.__dict__ )
        lowercase__				:    Optional[Any]  =					self.encoder.to_dict()
        lowercase__				:    Tuple  =					self.decoder.to_dict()
        lowercase__				:    Dict  =					self.__class__.model_type
        return output

