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






    def _snake_case			(   self							):
       lowercase__:   List[Any]					=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

       lowercase__:   Tuple					=      self.get_config()

       return config, pixel_values, labels






    def _snake_case			(   self							):
       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=SCREAMING_SNAKE_CASE__    ,			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 _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   str					=      TFEfficientFormerModel(config=SCREAMING_SNAKE_CASE__							)
       lowercase__:   Dict					=      model(SCREAMING_SNAKE_CASE__    ,			training=SCREAMING_SNAKE_CASE__							)
       self.parent.assertEqual(result.last_hidden_state.shape    ,			(self.batch_size, self.seq_length, self.hidden_size)							)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   Optional[int]					=      self.type_sequence_label_size
       lowercase__:   Optional[int]					=      TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE__							)
       lowercase__:   Dict					=      model(SCREAMING_SNAKE_CASE__    ,			labels=SCREAMING_SNAKE_CASE__    ,			training=SCREAMING_SNAKE_CASE__							)
       self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size)							)

       # test greyscale images
       lowercase__:   int					=      1
       lowercase__:   Dict					=      TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE__							)

       lowercase__:   Dict					=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
       lowercase__:   List[Any]					=      model(SCREAMING_SNAKE_CASE__    ,			labels=SCREAMING_SNAKE_CASE__							)
       self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size)							)






    def _snake_case			(   self							):
       lowercase__:   List[Any]					=      self.prepare_config_and_inputs()
       lowercase__, lowercase__, lowercase__:   List[Any]					=      config_and_inputs
       lowercase__:   int					=      {'''pixel_values''': pixel_values}
       return config, inputs_dict



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



    """simple docstring"""

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

    _UpperCAmelCase	:Union[str, Any]						    = False

    _UpperCAmelCase	:Optional[Any]						    = False
    _UpperCAmelCase	:Union[str, Any]						    = False
    _UpperCAmelCase	:Union[str, Any]						    = False
    _UpperCAmelCase	:Optional[Any]						    = False






    def _snake_case			(   self							):
       lowercase__:   Any					=      TFEfficientFormerModelTester(self							)
       lowercase__:   Any					=      ConfigTester(
           self    ,			config_class=SCREAMING_SNAKE_CASE__    ,			has_text_modality=SCREAMING_SNAKE_CASE__    ,			hidden_size=37							)






    def _snake_case			(   self							):
       self.config_tester.run_common_tests()






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






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






    def _snake_case			(   self							):
       lowercase__, lowercase__:   Optional[int]					=      self.model_tester.prepare_config_and_inputs_for_common()

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

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






    def _snake_case			(   self							):
       def check_hidden_states_output(_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
          lowercase__:   Optional[int]					=      model_class(SCREAMING_SNAKE_CASE__							)

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

          lowercase__:   Union[str, Any]					=      getattr(
              self.model_tester    ,			'''expected_num_hidden_layers'''    ,			self.model_tester.num_hidden_layers + 1							)
          self.assertEqual(len(SCREAMING_SNAKE_CASE__							)    ,			SCREAMING_SNAKE_CASE__							)

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

             self.asseretIsInstance(SCREAMING_SNAKE_CASE__    ,			(list, tuple)							)
             self.assertEqual(len(SCREAMING_SNAKE_CASE__							)    ,			SCREAMING_SNAKE_CASE__							)
             lowercase__:   List[Any]					=      getattr(self.model_tester    ,			'''seq_length'''    ,			SCREAMING_SNAKE_CASE__							)
             lowercase__:   List[str]					=      getattr(self.model_tester    ,			'''decoder_seq_length'''    ,			SCREAMING_SNAKE_CASE__							)

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

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

       for model_class in self.all_model_classes:
          lowercase__:   str					=      True
          check_hidden_states_output(SCREAMING_SNAKE_CASE__    ,			SCREAMING_SNAKE_CASE__    ,			SCREAMING_SNAKE_CASE__							)

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

          check_hidden_states_output(SCREAMING_SNAKE_CASE__    ,			SCREAMING_SNAKE_CASE__    ,			SCREAMING_SNAKE_CASE__							)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase=False							):
       lowercase__:   int					=      super()._prepare_for_class(SCREAMING_SNAKE_CASE__    ,			SCREAMING_SNAKE_CASE__    ,			return_labels=SCREAMING_SNAKE_CASE__							)

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

       return inputs_dict






    def _snake_case			(   self							):
       lowercase__:   List[str]					=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)






    @unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''							)
    def _snake_case			(   self							):
       lowercase__:   List[Any]					=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__							)






    def _snake_case			(   self							):
       lowercase__:   Tuple					=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__							)






    @slow
    def _snake_case			(   self							):
       for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowercase__:   Union[str, Any]					=      TFEfficientFormerModel.from_pretrained(SCREAMING_SNAKE_CASE__							)
          self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)






    def _snake_case			(   self							):
       lowercase__, lowercase__:   Tuple					=      self.model_tester.prepare_config_and_inputs_for_common()
       lowercase__:   Any					=      True

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

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

       for model_class in self.all_model_classes:
          lowercase__:   Union[str, Any]					=      True
          lowercase__:   List[Any]					=      False
          lowercase__:   List[Any]					=      True
          lowercase__:   List[Any]					=      model_class(SCREAMING_SNAKE_CASE__							)

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

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

          lowercase__:   Optional[Any]					=      outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE__							)    ,			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 _snake_case			(   self							):
       # 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__:   Union[str, Any]					=      self.model_tester.prepare_config_and_inputs_for_common()

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



def SCREAMING_SNAKE_CASE__			(   )  ->  Union[str, Any]:
   lowercase__:   str					=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
   return image




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



    """simple docstring"""

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






    @slow
    def _snake_case			(   self							):
       lowercase__:   str					=      TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''							)
       lowercase__:   Dict					=      self.default_image_processor
       lowercase__:   Any					=      prepare_img()
       lowercase__:   int					=      image_processor(images=SCREAMING_SNAKE_CASE__    ,			return_tensors='''tf'''							)
       # forward pass
       lowercase__:   Any					=      model(**SCREAMING_SNAKE_CASE__    ,			training=SCREAMING_SNAKE_CASE__							)
       # verify the logits
       lowercase__:   Any					=      tf.TensorShape((1, 1000)							)
       self.assertEqual(outputs.logits.shape    ,			SCREAMING_SNAKE_CASE__							)
       lowercase__:   str					=      tf.constant([-0.0_555, 0.4_825, -0.0_852]							)
       self.assertTrue(np.allclose(outputs.logits[0, :3]    ,			SCREAMING_SNAKE_CASE__    ,			atol=1e-4							)							)






    @slow
    def _snake_case			(   self							):
       lowercase__:   Optional[int]					=      TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
           '''snap-research/efficientformer-l1-300'''							)
       lowercase__:   int					=      self.default_image_processor
       lowercase__:   Any					=      prepare_img()
       lowercase__:   Optional[Any]					=      image_processor(images=SCREAMING_SNAKE_CASE__    ,			return_tensors='''tf'''							)
       # forward pass
       lowercase__:   int					=      model(**SCREAMING_SNAKE_CASE__    ,			training=SCREAMING_SNAKE_CASE__							)
       # verify the logits
       lowercase__:   Dict					=      tf.TensorShape((1, 1000)							)
       self.assertEqual(outputs.logits.shape    ,			SCREAMING_SNAKE_CASE__							)
       lowercase__:   Dict					=      tf.constant([-0.1_312, 0.4_353, -1.0_499]							)
       self.assertTrue(np.allclose(outputs.logits[0, :3]    ,			SCREAMING_SNAKE_CASE__    ,			atol=1e-4							)							)

'''simple docstring'''

from abc import ABC, abstractmethod
from argparse import ArgumentParser







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 @staticmethod
 @abstractmethod
 def a					(      SCREAMING_SNAKE_CASE__   :	ArgumentParser							)  ->    Tuple:
  raise NotImplementedError()





 @abstractmethod
 def a					(      self   :	int							)  ->    Union[str, Any]:
  raise NotImplementedError()






