

'''simple docstring'''
import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        MODEL_MAPPING,
        EfficientFormerForImageClassification,
        EfficientFormerForImageClassificationWithTeacher,
        EfficientFormerModel,
    )
    from transformers.models.efficientformer.modeling_efficientformer import (
        EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
    )


if is_vision_available():
    from PIL import Image

    from transformers import EfficientFormerImageProcessor


class      a__						:


   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.0_2    ,       _UpperCamelCase = 2    ,       _UpperCamelCase = 1    ,       _UpperCamelCase = 128    ,       _UpperCamelCase = [2, 2, 2, 2]    ,       _UpperCamelCase = 2    ,       _UpperCamelCase = 2    ,       ):





      """simple docstring"""





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


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





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

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

      _lowercase    :   Tuple      =     self.get_config()
      return config, pixel_values, labels


   def 		_lowerCamelCase     (				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=_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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Any      =     EfficientFormerModel(config=_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      _lowercase    :   str      =     model(_UpperCamelCase						)
      self.parent.assertEqual(result.last_hidden_state.shape    ,       (self.batch_size, self.seq_length, self.hidden_size)						)


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   List[Any]      =     self.type_sequence_label_size
      _lowercase    :   Optional[Any]      =     EfficientFormerForImageClassification(_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      _lowercase    :   Tuple      =     model(_UpperCamelCase    ,       labels=_UpperCamelCase						)
      self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.type_sequence_label_size)						)

      # test greyscale images
      _lowercase    :   List[str]      =     1
      _lowercase    :   List[str]      =     EfficientFormerForImageClassification(_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()

      _lowercase    :   Tuple      =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
      _lowercase    :   Any      =     model(_UpperCamelCase						)
      self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.type_sequence_label_size)						)






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Optional[int]      =     self.prepare_config_and_inputs()
      (
          (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   
      )    :   List[Any]      =     config_and_inputs
      _lowercase    :   Tuple      =     {"pixel_values": pixel_values}
      return config, inputs_dict




@require_torch
class      a__						(							lowerCamelCase_						,   lowerCamelCase_						,   unittest.TestCase						):
   _SCREAMING_SNAKE_CASE					:  List[Any]			 =							(
       (
           EfficientFormerModel,
           EfficientFormerForImageClassificationWithTeacher,
           EfficientFormerForImageClassification,
       )
       if is_torch_available()
       else ()
   )
   _SCREAMING_SNAKE_CASE					:  Tuple			 =							(
       {
           'feature-extraction': EfficientFormerModel,
           'image-classification': (
               EfficientFormerForImageClassification,
               EfficientFormerForImageClassificationWithTeacher,
           ),
       }
       if is_torch_available()
       else {}
   )
   _SCREAMING_SNAKE_CASE					:  Tuple			 =							False

   _SCREAMING_SNAKE_CASE					:  int			 =							False
   _SCREAMING_SNAKE_CASE					:  Optional[int]			 =							False
   _SCREAMING_SNAKE_CASE					:  Union[str, Any]			 =							False


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Dict      =     EfficientFormerModelTester(self						)
      _lowercase    :   Optional[int]      =     ConfigTester(
          self    ,       config_class=_UpperCamelCase    ,       has_text_modality=_UpperCamelCase    ,       hidden_size=37						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      self.config_tester.run_common_tests()


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





      """simple docstring"""





      pass


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





      """simple docstring"""





      pass


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





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

      for model_class in self.all_model_classes:
         _lowercase    :   Dict      =     model_class(_UpperCamelCase						)
         _lowercase    :   Optional[Any]      =     inspect.signature(model.forward						)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _lowercase    :   List[Any]      =     [*signature.parameters.keys()]

         _lowercase    :   Tuple      =     ["pixel_values"]
         self.assertListEqual(arg_names[:1]    ,       _UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      def check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):
         _lowercase    :   str      =     model_class(_UpperCamelCase						)
         model.to(_UpperCamelCase						)
         model.eval()

         with torch.no_grad():
            _lowercase    :   List[str]      =     model(**self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase						)						)

         _lowercase    :   str      =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

            self.assertIsInstance(_UpperCamelCase    ,       (list, tuple)						)
            self.assertEqual(len(_UpperCamelCase						)    ,       _UpperCamelCase						)
            _lowercase    :   Dict      =     getattr(self.model_tester    ,       "seq_length"    ,       _UpperCamelCase						)
            _lowercase    :   List[Any]      =     getattr(self.model_tester    ,       "decoder_seq_length"    ,       _UpperCamelCase						)

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

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

      for model_class in self.all_model_classes:
         _lowercase    :   Dict      =     True
         check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         _lowercase    :   Optional[int]      =     True

         check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase=False						):





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     super()._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase    ,       return_labels=_UpperCamelCase						)

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

      return inputs_dict


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   int      =     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 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   List[str]      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   int      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      if not self.model_tester.is_training:
         return

      _lowercase  ,   _lowercase    :   int      =     self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase    :   Tuple      =     True

      for model_class in self.all_model_classes:
         # EfficientFormerForImageClassificationWithTeacher supports inference-only
         if (
             model_class in get_values(_UpperCamelCase						)
             or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
         ):
            continue
         _lowercase    :   Any      =     model_class(_UpperCamelCase						)
         model.to(_UpperCamelCase						)
         model.train()
         _lowercase    :   Tuple      =     self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase    ,       return_labels=_UpperCamelCase						)
         _lowercase    :   int      =     model(**_UpperCamelCase						).loss
         loss.backward()


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





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

      _lowercase    :   List[str]      =     [
          {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float},
          {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long},
          {"title": "regression", "num_labels": 1, "dtype": torch.float},
      ]

      for model_class in self.all_model_classes:
         if (
             model_class
             not in [
                 *get_values(_UpperCamelCase						),
             ]
             or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
         ):
            continue

         for problem_type in problem_types:
            with self.subTest(msg=f'''Testing {model_class} with {problem_type['title']}'''						):
               _lowercase    :   Dict      =     problem_type["title"]
               _lowercase    :   List[Any]      =     problem_type["num_labels"]

               _lowercase    :   List[Any]      =     model_class(_UpperCamelCase						)
               model.to(_UpperCamelCase						)
               model.train()

               _lowercase    :   List[str]      =     self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase    ,       return_labels=_UpperCamelCase						)

               if problem_type["num_labels"] > 1:
                  _lowercase    :   List[str]      =     inputs["labels"].unsqueeze(1						).repeat(1    ,       problem_type["num_labels"]						)

               _lowercase    :   Tuple      =     inputs["labels"].to(problem_type["dtype"]						)

               # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
               # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
               # they have the same size." which is a symptom something in wrong for the regression problem.
               # See https://github.com/huggingface/transformers/issues/11780
               with warnings.catch_warnings(record=_UpperCamelCase						) as warning_list:
                  _lowercase    :   Union[str, Any]      =     model(**_UpperCamelCase						).loss
               for w in warning_list:
                  if "Using a target size that is different to the input size" in str(w.message						):
                     raise ValueError(
                         f'''Something is going wrong in the regression problem: intercepted {w.message}'''						)

               loss.backward()


   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowercase    :   Tuple      =     EfficientFormerModel.from_pretrained(_UpperCamelCase						)
         self.assertIsNotNone(_UpperCamelCase						)






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase  ,   _lowercase    :   str      =     self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase    :   Optional[int]      =     True

      _lowercase    :   Any      =     getattr(self.model_tester    ,       "seq_length"    ,       _UpperCamelCase						)
      _lowercase    :   List[str]      =     getattr(self.model_tester    ,       "encoder_seq_length"    ,       _UpperCamelCase						)
      _lowercase    :   str      =     getattr(self.model_tester    ,       "key_length"    ,       _UpperCamelCase						)
      _lowercase    :   Optional[Any]      =     getattr(self.model_tester    ,       "chunk_length"    ,       _UpperCamelCase						)

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

      for model_class in self.all_model_classes:
         _lowercase    :   Dict      =     True
         _lowercase    :   str      =     False
         _lowercase    :   Union[str, Any]      =     True
         _lowercase    :   List[str]      =     model_class(_UpperCamelCase						)
         model.to(_UpperCamelCase						)
         model.eval()
         with torch.no_grad():
            _lowercase    :   Optional[int]      =     model(**self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase						)						)
         _lowercase    :   Union[str, Any]      =     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"]
         _lowercase    :   Any      =     True
         _lowercase    :   int      =     model_class(_UpperCamelCase						)
         model.to(_UpperCamelCase						)
         model.eval()
         with torch.no_grad():
            _lowercase    :   Optional[int]      =     model(**self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase						)						)
         _lowercase    :   str      =     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	(			)    ->			str:
   _lowercase    :   List[str]      =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
   return image


@require_torch
@require_vision
class      a__						(							unittest.TestCase						):


   @cached_property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





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


   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"						).to(
          _UpperCamelCase						)

      _lowercase    :   Dict      =     self.default_image_processor
      _lowercase    :   Optional[int]      =     prepare_img()
      _lowercase    :   Any      =     image_processor(images=_UpperCamelCase    ,       return_tensors="pt"						).to(_UpperCamelCase						)

      # forward pass
      with torch.no_grad():
         _lowercase    :   List[str]      =     model(**_UpperCamelCase						)

      # verify the logits
      _lowercase    :   Tuple      =     (1, 1000)
      self.assertEqual(outputs.logits.shape    ,       _UpperCamelCase						)

      _lowercase    :   str      =     torch.tensor([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]						).to(_UpperCamelCase						)
      self.assertTrue(torch.allclose(outputs.logits[0][:3]    ,       _UpperCamelCase    ,       atol=1E-4						)						)






   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     EfficientFormerForImageClassificationWithTeacher.from_pretrained(
          "snap-research/efficientformer-l1-300"						).to(_UpperCamelCase						)

      _lowercase    :   Union[str, Any]      =     self.default_image_processor
      _lowercase    :   List[str]      =     prepare_img()
      _lowercase    :   List[str]      =     image_processor(images=_UpperCamelCase    ,       return_tensors="pt"						).to(_UpperCamelCase						)

      # forward pass
      with torch.no_grad():
         _lowercase    :   List[Any]      =     model(**_UpperCamelCase						)

      # verify the logits
      _lowercase    :   Union[str, Any]      =     (1, 1000)
      self.assertEqual(outputs.logits.shape    ,       _UpperCamelCase						)

      _lowercase    :   List[str]      =     torch.tensor([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]						).to(_UpperCamelCase						)
      self.assertTrue(torch.allclose(outputs.logits[0][:3]    ,       _UpperCamelCase    ,       atol=1E-4						)						)









'''simple docstring'''
def       _A	(			snake_case  )    ->			int:

   # validate:
   if not isinstance(snake_case	,							snake_case  ) or not all(
       isinstance(snake_case	,							snake_case  ) and item >= 0 for item in citations  ):
      raise ValueError("The citations should be a list of non negative integers."  )

   citations.sort()
   _lowercase    :   Tuple      =     len(snake_case  )

   for i in range(snake_case  ):
      if citations[len_citations - 1 - i] <= i:
         return i

   return len_citations


if __name__ == "__main__":
    import doctest

    doctest.testmod()






