

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				:




      """simple docstring"""

      def __init__(      self       :							List[Any]	, UpperCAmelCase       :							Optional[Any]	, UpperCAmelCase       :							int = 13	, UpperCAmelCase       :							int = 64	, UpperCAmelCase       :							int = 2	, UpperCAmelCase       :							int = 3	, UpperCAmelCase       :							int = 3	, UpperCAmelCase       :							bool = True	, UpperCAmelCase       :							bool = True	, UpperCAmelCase       :							int = 128	, UpperCAmelCase       :							str=[16, 32, 64, 128]	, UpperCAmelCase       :							int = 7	, UpperCAmelCase       :							int = 4	, UpperCAmelCase       :							int = 37	, UpperCAmelCase       :							str = "gelu"	, UpperCAmelCase       :							float = 0.1	, UpperCAmelCase       :							float = 0.1	, UpperCAmelCase       :							int = 10	, UpperCAmelCase       :							float = 0.02	, UpperCAmelCase       :							int = 2	, UpperCAmelCase       :							int = 1	, UpperCAmelCase       :							int = 128	, UpperCAmelCase       :							List[int] = [2, 2, 2, 2]	, UpperCAmelCase       :							int = 2	, UpperCAmelCase       :							int = 2	, ):
            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       :							Tuple  ):
            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       :							Optional[int]  ):
            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       :							Any	, UpperCAmelCase       :							Union[str, Any]	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int  ):
            A_	     =							EfficientFormerModel(config=UpperCAmelCase  )
            model.to(UpperCAmelCase  )
            model.eval()
            A_	     =							model(UpperCAmelCase  )
            self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.hidden_size)  )





      def 		__A  (      self       :							str	, UpperCAmelCase       :							Union[str, Any]	, UpperCAmelCase       :							Dict	, UpperCAmelCase       :							List[str]  ):
            A_	     =							self.type_sequence_label_size
            A_	     =							EfficientFormerForImageClassification(UpperCAmelCase  )
            model.to(UpperCAmelCase  )
            model.eval()
            A_	     =							model(UpperCAmelCase	, labels=UpperCAmelCase  )
            self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.type_sequence_label_size)  )

            # test greyscale images
            A_	     =							1
            A_	     =							EfficientFormerForImageClassification(UpperCAmelCase  )
            model.to(UpperCAmelCase  )
            model.eval()

            A_	     =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
            A_	     =							model(UpperCAmelCase  )
            self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.type_sequence_label_size)  )







      def 		__A  (      self       :							List[Any]  ):
            A_	     =							self.prepare_config_and_inputs()
            (
                (
                A_
            )     ,    (
                A_
            )     ,    (
                A_
            )     ,    
            )	     =							config_and_inputs
            A_	     =							{"pixel_values": pixel_values}
            return config, inputs_dict




@require_torch
class      _a				( snake_case_    ,							snake_case_    ,							unittest.TestCase							):




      """simple docstring"""

      _lowerCamelCase					: Optional[int]					=					(
          (
              EfficientFormerModel,
              EfficientFormerForImageClassificationWithTeacher,
              EfficientFormerForImageClassification,
          )
          if is_torch_available()
          else ()
      )
      _lowerCamelCase					: Optional[int]					=					(
          {
              'feature-extraction': EfficientFormerModel,
              'image-classification': (
                  EfficientFormerForImageClassification,
                  EfficientFormerForImageClassificationWithTeacher,
              ),
          }
          if is_torch_available()
          else {}
      )
      _lowerCamelCase					: Any					=					False

      _lowerCamelCase					: Optional[Any]					=					False
      _lowerCamelCase					: Optional[Any]					=					False
      _lowerCamelCase					: Any					=					False





      def 		__A  (      self       :							Optional[int]  ):
            A_	     =							EfficientFormerModelTester(self  )
            A_	     =							ConfigTester(
                self	, config_class=UpperCAmelCase	, has_text_modality=UpperCAmelCase	, hidden_size=37  )





      def 		__A  (      self       :							Dict  ):
            self.config_tester.run_common_tests()





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





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





      def 		__A  (      self       :							Optional[Any]  ):
            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.forward  )
                  # 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       :							Dict  ):
            def check_hidden_states_output(UpperCAmelCase       :							str	, UpperCAmelCase       :							Union[str, Any]	, UpperCAmelCase       :							Optional[int]  ):
                  A_	     =							model_class(UpperCAmelCase  )
                  model.to(UpperCAmelCase  )
                  model.eval()

                  with torch.no_grad():
                        A_	     =							model(**self._prepare_for_class(UpperCAmelCase	, 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.assertIsInstance(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       :							Tuple	, UpperCAmelCase       :							Union[str, Any]	, UpperCAmelCase       :							Optional[int]	, UpperCAmelCase       :							Any=False  ):
            A_	     =							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 		__A  (      self       :							List[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       :							Optional[int]  ):
            A_	     =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase  )





      def 		__A  (      self       :							int  ):
            A_	     =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase  )





      def 		__A  (      self       :							int  ):
            if not self.model_tester.is_training:
                  return

            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()
            A_	     =							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
                  A_	     =							model_class(UpperCAmelCase  )
                  model.to(UpperCAmelCase  )
                  model.train()
                  A_	     =							self._prepare_for_class(UpperCAmelCase	, UpperCAmelCase	, return_labels=UpperCAmelCase  )
                  A_	     =							model(**UpperCAmelCase  ).loss
                  loss.backward()





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

            A_	     =							[
                {"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"]}'''  ):
                              A_	     =							problem_type["title"]
                              A_	     =							problem_type["num_labels"]

                              A_	     =							model_class(UpperCAmelCase  )
                              model.to(UpperCAmelCase  )
                              model.train()

                              A_	     =							self._prepare_for_class(UpperCAmelCase	, UpperCAmelCase	, return_labels=UpperCAmelCase  )

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

                              A_	     =							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:
                                    A_	     =							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 		__A  (      self       :							str  ):
            for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_	     =							EfficientFormerModel.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  )
                  model.to(UpperCAmelCase  )
                  model.eval()
                  with torch.no_grad():
                        A_	     =							model(**self._prepare_for_class(UpperCAmelCase	, 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  )
                  model.to(UpperCAmelCase  )
                  model.eval()
                  with torch.no_grad():
                        A_	     =							model(**self._prepare_for_class(UpperCAmelCase	, 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 			__snake_case	(   ):



      """simple docstring"""

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



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




      """simple docstring"""

      @cached_property
      def 		__A  (      self       :							Optional[int]  ):
            return (
                EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"  )
                if is_vision_available()
                else None
            )





      @slow
      def 		__A  (      self       :							List[str]  ):
            A_	     =							EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"  ).to(
                UpperCAmelCase  )

            A_	     =							self.default_image_processor
            A_	     =							prepare_img()
            A_	     =							image_processor(images=UpperCAmelCase	, return_tensors="pt"  ).to(UpperCAmelCase  )

            # forward pass
            with torch.no_grad():
                  A_	     =							model(**UpperCAmelCase  )

            # verify the logits
            A_	     =							(1, 1000)
            self.assertEqual(outputs.logits.shape	, UpperCAmelCase  )

            A_	     =							torch.tensor([-0.0_555, 0.4_825, -0.0_852]  ).to(UpperCAmelCase  )
            self.assertTrue(torch.allclose(outputs.logits[0][:3]	, UpperCAmelCase	, atol=1E-4  )  )







      @slow
      def 		__A  (      self       :							Optional[int]  ):
            A_	     =							EfficientFormerForImageClassificationWithTeacher.from_pretrained(
                "snap-research/efficientformer-l1-300"  ).to(UpperCAmelCase  )

            A_	     =							self.default_image_processor
            A_	     =							prepare_img()
            A_	     =							image_processor(images=UpperCAmelCase	, return_tensors="pt"  ).to(UpperCAmelCase  )

            # forward pass
            with torch.no_grad():
                  A_	     =							model(**UpperCAmelCase  )

            # verify the logits
            A_	     =							(1, 1000)
            self.assertEqual(outputs.logits.shape	, UpperCAmelCase  )

            A_	     =							torch.tensor([-0.1_312, 0.4_353, -1.0_499]  ).to(UpperCAmelCase  )
            self.assertTrue(torch.allclose(outputs.logits[0][:3]	, UpperCAmelCase	, atol=1E-4  )  )


import pytest

from datasets.utils.version import Version

@pytest.mark.parametrize(
    "other, expected_equality"							,[
        (Version("1.0.0"						), True),
        ("1.0.0", True),
        (Version("2.0.0"						), False),
        ("2.0.0", False),
        ("1", False),
        ("a", False),
        (1, False),
        (None, False),
    ]							,)
def 			__snake_case	(   __UpperCamelCase  :   Any							,__UpperCamelCase  :   List[Any]						):



      """simple docstring"""

      A_	     =							Version("1.0.0"						)
      assert (version == other) is expected_equality
      assert (version != other) is not expected_equality
      assert (hash(__UpperCamelCase						) == hash(__UpperCamelCase						)) is expected_equality