





"""simple docstring"""


import inspect
import unittest
import warnings
from math import ceil, floor

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

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,
      LevitForImageClassification,
      LevitForImageClassificationWithTeacher,
      LevitModel,
  )
  from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import LevitImageProcessor



class   __SCREAMING_SNAKE_CASE     (    _UpperCamelCase ):







  '''simple docstring'''


  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[Any]						)		->					Union[str, Any]:
        _UpperCamelCase   :						List[str]    =							self.config_class(**self.inputs_dict						)
        self.parent.assertTrue(hasattr(__a       , "hidden_sizes"						)						)
        self.parent.assertTrue(hasattr(__a       , "num_attention_heads"						)						)





class   __SCREAMING_SNAKE_CASE     :







  '''simple docstring'''


  def __init__(		self :							Dict       , __a :							Any       , __a :							Union[str, Any]=13       , __a :							Dict=64       , __a :							List[str]=3       , __a :							Any=3       , __a :							Optional[Any]=2       , __a :							Optional[Any]=1       , __a :							Any=16       , __a :							Dict=[128, 256, 384]       , __a :							str=[4, 6, 8]       , __a :							List[str]=[2, 3, 4]       , __a :							Tuple=[16, 16, 16]       , __a :							str=0       , __a :							Any=[2, 2, 2]       , __a :							str=[2, 2, 2]       , __a :							int=0.02       , __a :							Any=True       , __a :							List[str]=True       , __a :							Union[str, Any]=2       , )		->					str:
        _UpperCamelCase   :						Dict    =							parent
        _UpperCamelCase   :						str    =							batch_size
        _UpperCamelCase   :						Any    =							image_size
        _UpperCamelCase   :						Dict    =							num_channels
        _UpperCamelCase   :						List[Any]    =							kernel_size
        _UpperCamelCase   :						Tuple    =							stride
        _UpperCamelCase   :						List[str]    =							padding
        _UpperCamelCase   :						List[str]    =							hidden_sizes
        _UpperCamelCase   :						List[str]    =							num_attention_heads
        _UpperCamelCase   :						List[Any]    =							depths
        _UpperCamelCase   :						Optional[int]    =							key_dim
        _UpperCamelCase   :						Optional[int]    =							drop_path_rate
        _UpperCamelCase   :						List[Any]    =							patch_size
        _UpperCamelCase   :						Any    =							attention_ratio
        _UpperCamelCase   :						Union[str, Any]    =							mlp_ratio
        _UpperCamelCase   :						str    =							initializer_range
        _UpperCamelCase   :						List[str]    =							[
            ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
            ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
        ]
        _UpperCamelCase   :						Optional[Any]    =							is_training
        _UpperCamelCase   :						Dict    =							use_labels
        _UpperCamelCase   :						List[Any]    =							num_labels
        _UpperCamelCase   :						Tuple    =							initializer_range

  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple						)		->					Any:
        _UpperCamelCase   :						Dict    =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

        _UpperCamelCase   :						Optional[int]    =							None
        if self.use_labels:
              _UpperCamelCase   :						Tuple    =							ids_tensor([self.batch_size]       , self.num_labels						)

        _UpperCamelCase   :						Union[str, Any]    =							self.get_config()
        return config, pixel_values, labels

  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					Union[str, Any]:
        return LevitConfig(
            image_size=self.image_size       , num_channels=self.num_channels       , kernel_size=self.kernel_size       , stride=self.stride       , padding=self.padding       , patch_size=self.patch_size       , hidden_sizes=self.hidden_sizes       , num_attention_heads=self.num_attention_heads       , depths=self.depths       , key_dim=self.key_dim       , drop_path_rate=self.drop_path_rate       , mlp_ratio=self.mlp_ratio       , attention_ratio=self.attention_ratio       , initializer_range=self.initializer_range       , down_ops=self.down_ops       , )

  def  __SCREAMING_SNAKE_CASE					(		self :							Any       , __a :							Any       , __a :							Optional[Any]       , __a :							str						)		->					Tuple:
        _UpperCamelCase   :						Optional[int]    =							LevitModel(config=__a						)
        model.to(__a						)
        model.eval()
        _UpperCamelCase   :						Optional[Any]    =							model(__a						)
        _UpperCamelCase   :						List[str]    =							(self.image_size, self.image_size)
        _UpperCamelCase,	_UpperCamelCase   :						Optional[Any]    =							image_size[0], image_size[1]
        for _ in range(4						):
              _UpperCamelCase   :						Dict    =							floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
              _UpperCamelCase   :						Optional[Any]    =							floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
        self.parent.assertEqual(
            result.last_hidden_state.shape       , (self.batch_size, ceil(height / 4						) * ceil(width / 4						), self.hidden_sizes[-1])       , )

  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple       , __a :							str       , __a :							Optional[Any]       , __a :							Dict						)		->					Tuple:
        _UpperCamelCase   :						Union[str, Any]    =							self.num_labels
        _UpperCamelCase   :						str    =							LevitForImageClassification(__a						)
        model.to(__a						)
        model.eval()
        _UpperCamelCase   :						Any    =							model(__a       , labels=__a						)
        self.parent.assertEqual(result.logits.shape       , (self.batch_size, self.num_labels)						)


  def  __SCREAMING_SNAKE_CASE					(		self :							Union[str, Any]						)		->					Tuple:
        _UpperCamelCase   :						Union[str, Any]    =							self.prepare_config_and_inputs()
        _UpperCamelCase,	_UpperCamelCase,	_UpperCamelCase   :						List[str]    =							config_and_inputs
        _UpperCamelCase   :						List[Any]    =							{"pixel_values": pixel_values}
        return config, inputs_dict





@require_torch
class   __SCREAMING_SNAKE_CASE     (    _UpperCamelCase		,	_UpperCamelCase		,	unittest.TestCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Any						  =       (
      (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
      if is_torch_available()
      else ()
  )
  SCREAMING_SNAKE_CASE__				:List[str]						  =       (
      {
          "feature-extraction": LevitModel,
          "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
      }
      if is_torch_available()
      else {}
  )

  SCREAMING_SNAKE_CASE__				:Union[str, Any]						  =       False
  SCREAMING_SNAKE_CASE__				:str						  =       False
  SCREAMING_SNAKE_CASE__				:List[Any]						  =       False
  SCREAMING_SNAKE_CASE__				:str						  =       False
  SCREAMING_SNAKE_CASE__				:int						  =       False

  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]						)		->					List[str]:
        _UpperCamelCase   :						Optional[Any]    =							LevitModelTester(self						)
        _UpperCamelCase   :						Any    =							ConfigTester(self       , config_class=__a       , has_text_modality=__a       , hidden_size=37						)

  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]						)		->					List[Any]:
        self.create_and_test_config_common_properties()
        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()

  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]						)		->					Tuple:
        return

  @unittest.skip(reason="Levit does not use inputs_embeds"						)
  def  __SCREAMING_SNAKE_CASE					(		self :							int						)		->					Union[str, Any]:
        pass

  @unittest.skip(reason="Levit does not support input and output embeddings"						)
  def  __SCREAMING_SNAKE_CASE					(		self :							int						)		->					List[Any]:
        pass

  @unittest.skip(reason="Levit does not output attentions"						)
  def  __SCREAMING_SNAKE_CASE					(		self :							Any						)		->					List[Any]:
        pass

  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					List[Any]:
        _UpperCamelCase,	_UpperCamelCase   :						Any    =							self.model_tester.prepare_config_and_inputs_for_common()

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

              _UpperCamelCase   :						str    =							["pixel_values"]
              self.assertListEqual(arg_names[:1]       , __a						)

  def  __SCREAMING_SNAKE_CASE					(		self :							Dict						)		->					Optional[Any]:
        def check_hidden_states_output(__a :							int       , __a :							Any       , __a :							List[str]						):
              _UpperCamelCase   :						Union[str, Any]    =							model_class(__a						)
              model.to(__a						)
              model.eval()

              with torch.no_grad():
                    _UpperCamelCase   :						str    =							model(**self._prepare_for_class(__a       , __a						)						)

              _UpperCamelCase   :						Any    =							outputs.hidden_states

              _UpperCamelCase   :						Optional[int]    =							len(self.model_tester.depths						) + 1
              self.assertEqual(len(__a						)       , __a						)

              _UpperCamelCase   :						int    =							(self.model_tester.image_size, self.model_tester.image_size)
              _UpperCamelCase,	_UpperCamelCase   :						int    =							image_size[0], image_size[1]
              for _ in range(4						):
                    _UpperCamelCase   :						Optional[int]    =							floor(
                        (
                            (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                            / self.model_tester.stride
                        )
                        + 1						)
                    _UpperCamelCase   :						Optional[Any]    =							floor(
                        (
                            (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                            / self.model_tester.stride
                        )
                        + 1						)
              # verify the first hidden states (first block)
              self.assertListEqual(
                  list(hidden_states[0].shape[-2:]						)       , [
                      height * width,
                      self.model_tester.hidden_sizes[0],
                  ]       , )

        _UpperCamelCase,	_UpperCamelCase   :						Union[str, Any]    =							self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              _UpperCamelCase   :						str    =							True
              check_hidden_states_output(__a       , __a       , __a						)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              _UpperCamelCase   :						Union[str, Any]    =							True

              check_hidden_states_output(__a       , __a       , __a						)

  @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."						)
  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]						)		->					List[Any]:
        pass

  def  __SCREAMING_SNAKE_CASE					(		self :							Dict       , __a :							str       , __a :							List[str]       , __a :							Optional[int]=False						)		->					Optional[Any]:
        _UpperCamelCase   :						Dict    =							super()._prepare_for_class(__a       , __a       , return_labels=__a						)

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

        return inputs_dict

  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple						)		->					int:
        _UpperCamelCase   :						Dict    =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__a						)

  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					Optional[Any]:
        _UpperCamelCase   :						List[str]    =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__a						)

  def  __SCREAMING_SNAKE_CASE					(		self :							Any						)		->					Any:
        if not self.model_tester.is_training:
              return

        _UpperCamelCase,	_UpperCamelCase   :						Dict    =							self.model_tester.prepare_config_and_inputs_for_common()
        _UpperCamelCase   :						Dict    =							True

        for model_class in self.all_model_classes:
              # LevitForImageClassificationWithTeacher supports inference-only
              if (
                  model_class in get_values(__a						)
                  or model_class.__name__ == "LevitForImageClassificationWithTeacher"
              ):
                    continue
              _UpperCamelCase   :						Optional[Any]    =							model_class(__a						)
              model.to(__a						)
              model.train()
              _UpperCamelCase   :						str    =							self._prepare_for_class(__a       , __a       , return_labels=__a						)
              _UpperCamelCase   :						str    =							model(**__a						).loss
              loss.backward()

  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					List[str]:
        _UpperCamelCase,	_UpperCamelCase   :						Tuple    =							self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
              return

        _UpperCamelCase   :						int    =							False
        _UpperCamelCase   :						str    =							True

        for model_class in self.all_model_classes:
              if model_class in get_values(__a						) or not model_class.supports_gradient_checkpointing:
                    continue
              # LevitForImageClassificationWithTeacher supports inference-only
              if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                    continue
              _UpperCamelCase   :						List[str]    =							model_class(__a						)
              model.gradient_checkpointing_enable()
              model.to(__a						)
              model.train()
              _UpperCamelCase   :						int    =							self._prepare_for_class(__a       , __a       , return_labels=__a						)
              _UpperCamelCase   :						Tuple    =							model(**__a						).loss
              loss.backward()

  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]						)		->					Union[str, Any]:
        _UpperCamelCase,	_UpperCamelCase   :						Optional[int]    =							self.model_tester.prepare_config_and_inputs_for_common()

        _UpperCamelCase   :						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(__a						),
                  ]
                  or model_class.__name__ == "LevitForImageClassificationWithTeacher"
              ):
                    continue

              for problem_type in problem_types:
                    with self.subTest(msg=F'''Testing {model_class} with {problem_type['title']}'''						):
                          _UpperCamelCase   :						Tuple    =							problem_type["title"]
                          _UpperCamelCase   :						Tuple    =							problem_type["num_labels"]

                          _UpperCamelCase   :						Tuple    =							model_class(__a						)
                          model.to(__a						)
                          model.train()

                          _UpperCamelCase   :						int    =							self._prepare_for_class(__a       , __a       , return_labels=__a						)

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

                          _UpperCamelCase   :						List[str]    =							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=__a						) as warning_list:
                                _UpperCamelCase   :						Tuple    =							model(**__a						).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  __SCREAMING_SNAKE_CASE					(		self :							int						)		->					Optional[int]:
        for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _UpperCamelCase   :						List[Any]    =							LevitModel.from_pretrained(__a						)
              self.assertIsNotNone(__a						)





def        lowercase__     (       )       ->		List[Any]:




      """simple docstring"""

      _UpperCamelCase   :						List[Any]    =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
      return image



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







  '''simple docstring'''


  @cached_property
  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					Dict:
        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)


  @slow
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					Dict:
        _UpperCamelCase   :						Union[str, Any]    =							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
            __a						)

        _UpperCamelCase   :						Tuple    =							self.default_image_processor
        _UpperCamelCase   :						List[str]    =							prepare_img()
        _UpperCamelCase   :						Dict    =							image_processor(images=__a       , return_tensors="pt"						).to(__a						)

        # forward pass
        with torch.no_grad():
              _UpperCamelCase   :						Union[str, Any]    =							model(**__a						)

        # verify the logits
        _UpperCamelCase   :						Optional[Any]    =							torch.Size((1, 1000)						)
        self.assertEqual(outputs.logits.shape       , __a						)

        _UpperCamelCase   :						List[str]    =							torch.tensor([1.04_48, -0.37_45, -1.83_17]						).to(__a						)

        self.assertTrue(torch.allclose(outputs.logits[0, :3]       , __a       , atol=1e-4						)						)







"""simple docstring"""


from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase__						= logging.get_logger(__name__)

lowerCamelCase__						= {
    "google/mobilenet_v1_1.0_224": "https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json",
    "google/mobilenet_v1_0.75_192": "https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}



class   __SCREAMING_SNAKE_CASE     (    _UpperCamelCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:int						  =       "mobilenet_v1"

  def __init__(		self :							Optional[int]       , __a :							List[str]=3       , __a :							Union[str, Any]=224       , __a :							Tuple=1.0       , __a :							List[Any]=8       , __a :							Union[str, Any]="relu6"       , __a :							Dict=True       , __a :							Tuple=0.9_99       , __a :							Dict=0.02       , __a :							Any=0.0_01       , **__a :							Any       , )		->					int:
        super().__init__(**__a						)

        if depth_multiplier <= 0:
              raise ValueError("depth_multiplier must be greater than zero."						)

        _UpperCamelCase   :						Any    =							num_channels
        _UpperCamelCase   :						Optional[Any]    =							image_size
        _UpperCamelCase   :						Optional[Any]    =							depth_multiplier
        _UpperCamelCase   :						int    =							min_depth
        _UpperCamelCase   :						List[str]    =							hidden_act
        _UpperCamelCase   :						Union[str, Any]    =							tf_padding
        _UpperCamelCase   :						int    =							classifier_dropout_prob
        _UpperCamelCase   :						Optional[int]    =							initializer_range
        _UpperCamelCase   :						Union[str, Any]    =							layer_norm_eps





class   __SCREAMING_SNAKE_CASE     (    _UpperCamelCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:List[Any]						  =       version.parse("1.11" )

  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]						)		->					Mapping[str, Mapping[int, str]]:
        return OrderedDict([("pixel_values", {0: "batch"})]						)

  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					Mapping[str, Mapping[int, str]]:
        if self.task == "image-classification":
              return OrderedDict([("logits", {0: "batch"})]						)
        else:
              return OrderedDict([("last_hidden_state", {0: "batch"}), ("pooler_output", {0: "batch"})]						)


  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple						)		->					float:
        return 1e-4
