

"""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     snake_case	(				__snake_case  ):

				def 							lowercase_     (	self							:				str)->   str:



						'''simple docstring'''


						__lowerCAmelCase:       Union[str, Any]          =			self.config_class(**self.inputs_dict)
						self.parent.assertTrue(hasattr(UpperCamelCase__     ,  "hidden_sizes"))
						self.parent.assertTrue(hasattr(UpperCamelCase__     ,  "num_attention_heads"))





class     snake_case	:

				def __init__(	self							:				Dict     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				int=1_3     ,  UpperCamelCase__							:				Dict=6_4     ,  UpperCamelCase__							:				List[str]=3     ,  UpperCamelCase__							:				Optional[Any]=3     ,  UpperCamelCase__							:				Optional[Any]=2     ,  UpperCamelCase__							:				List[str]=1     ,  UpperCamelCase__							:				Any=1_6     ,  UpperCamelCase__							:				List[str]=[1_2_8, 2_5_6, 3_8_4]     ,  UpperCamelCase__							:				int=[4, 6, 8]     ,  UpperCamelCase__							:				int=[2, 3, 4]     ,  UpperCamelCase__							:				Any=[1_6, 1_6, 1_6]     ,  UpperCamelCase__							:				str=0     ,  UpperCamelCase__							:				Optional[Any]=[2, 2, 2]     ,  UpperCamelCase__							:				Optional[Any]=[2, 2, 2]     ,  UpperCamelCase__							:				List[str]=0.02     ,  UpperCamelCase__							:				Union[str, Any]=True     ,  UpperCamelCase__							:				Optional[int]=True     ,  UpperCamelCase__							:				Union[str, Any]=2     ,  )->   List[str]:



						'''simple docstring'''


						__lowerCAmelCase:       int          =			parent
						__lowerCAmelCase:       int          =			batch_size
						__lowerCAmelCase:       Any          =			image_size
						__lowerCAmelCase:       List[str]          =			num_channels
						__lowerCAmelCase:       int          =			kernel_size
						__lowerCAmelCase:       Tuple          =			stride
						__lowerCAmelCase:       List[str]          =			padding
						__lowerCAmelCase:       str          =			hidden_sizes
						__lowerCAmelCase:       int          =			num_attention_heads
						__lowerCAmelCase:       int          =			depths
						__lowerCAmelCase:       Tuple          =			key_dim
						__lowerCAmelCase:       Any          =			drop_path_rate
						__lowerCAmelCase:       List[Any]          =			patch_size
						__lowerCAmelCase:       Tuple          =			attention_ratio
						__lowerCAmelCase:       Optional[int]          =			mlp_ratio
						__lowerCAmelCase:       Dict          =			initializer_range
						__lowerCAmelCase:       Optional[int]          =			[
						    ["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],
						]
						__lowerCAmelCase:       Optional[Any]          =			is_training
						__lowerCAmelCase:       Union[str, Any]          =			use_labels
						__lowerCAmelCase:       Optional[Any]          =			num_labels
						__lowerCAmelCase:       Any          =			initializer_range

				def 							lowercase_     (	self							:				str)->   Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:       List[str]          =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

						__lowerCAmelCase:       List[str]          =			self.get_config()
						return config, pixel_values, labels

				def 							lowercase_     (	self							:				List[str])->   str:



						'''simple docstring'''


						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 							lowercase_     (	self							:				Any     ,  UpperCamelCase__							:				List[str]     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				Any)->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[Any]          =			LevitModel(config=UpperCamelCase__)
						model.to(UpperCamelCase__)
						model.eval()
						__lowerCAmelCase:       Tuple          =			model(UpperCamelCase__)
						__lowerCAmelCase:       str          =			(self.image_size, self.image_size)
						__lowerCAmelCase      , __lowerCAmelCase:       Dict          =			image_size[0], image_size[1]
						for _ in range(4):
								__lowerCAmelCase:       Dict          =			floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1)
								__lowerCAmelCase:       List[str]          =			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 							lowercase_     (	self							:				Optional[Any]     ,  UpperCamelCase__							:				List[str]     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				int)->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Tuple          =			self.num_labels
						__lowerCAmelCase:       int          =			LevitForImageClassification(UpperCamelCase__)
						model.to(UpperCamelCase__)
						model.eval()
						__lowerCAmelCase:       Optional[Any]          =			model(UpperCamelCase__     ,  labels=UpperCamelCase__)
						self.parent.assertEqual(result.logits.shape     ,  (self.batch_size, self.num_labels))




				def 							lowercase_     (	self							:				Dict)->   Optional[Any]:



						'''simple docstring'''


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





@require_torch
class     snake_case	(				__snake_case,							__snake_case,							unittest.TestCase  ):
				SCREAMING_SNAKE_CASE_   :      List[Any]         =  (
				    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
				    if is_torch_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_   :      Optional[Any]         =  (
				    {
				        """feature-extraction""": LevitModel,
				        """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				SCREAMING_SNAKE_CASE_   :      Union[str, Any]         =  False
				SCREAMING_SNAKE_CASE_   :      Any         =  False
				SCREAMING_SNAKE_CASE_   :      Dict         =  False
				SCREAMING_SNAKE_CASE_   :      Optional[Any]         =  False
				SCREAMING_SNAKE_CASE_   :      Any         =  False

				def 							lowercase_     (	self							:				str)->   Dict:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[int]          =			LevitModelTester(self)
						__lowerCAmelCase:       List[str]          =			ConfigTester(self     ,  config_class=UpperCamelCase__     ,  has_text_modality=UpperCamelCase__     ,  hidden_size=3_7)

				def 							lowercase_     (	self							:				List[str])->   str:



						'''simple docstring'''


						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 							lowercase_     (	self							:				Optional[int])->   Any:



						'''simple docstring'''


						return

				@unittest.skip(reason="Levit does not use inputs_embeds")
				def 							lowercase_     (	self							:				Optional[int])->   Dict:



						'''simple docstring'''


						pass

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



						'''simple docstring'''


						pass

				@unittest.skip(reason="Levit does not output attentions")
				def 							lowercase_     (	self							:				Union[str, Any])->   Optional[int]:



						'''simple docstring'''


						pass

				def 							lowercase_     (	self							:				List[str])->   Any:



						'''simple docstring'''


						__lowerCAmelCase      , __lowerCAmelCase:       int          =			self.model_tester.prepare_config_and_inputs_for_common()

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

								__lowerCAmelCase:       int          =			["pixel_values"]
								self.assertListEqual(arg_names[:1]     ,  UpperCamelCase__)

				def 							lowercase_     (	self							:				List[str])->   Optional[int]:



						'''simple docstring'''


						def check_hidden_states_output(UpperCamelCase__							:				str     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				Dict):
								__lowerCAmelCase:       List[str]          =			model_class(UpperCamelCase__)
								model.to(UpperCamelCase__)
								model.eval()

								with torch.no_grad():
										__lowerCAmelCase:       str          =			model(**self._prepare_for_class(UpperCamelCase__     ,  UpperCamelCase__))

								__lowerCAmelCase:       Optional[Any]          =			outputs.hidden_states

								__lowerCAmelCase:       Any          =			len(self.model_tester.depths) + 1
								self.assertEqual(len(UpperCamelCase__)     ,  UpperCamelCase__)

								__lowerCAmelCase:       Any          =			(self.model_tester.image_size, self.model_tester.image_size)
								__lowerCAmelCase      , __lowerCAmelCase:       Dict          =			image_size[0], image_size[1]
								for _ in range(4):
										__lowerCAmelCase:       Any          =			floor(
										    (
										        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1)
										__lowerCAmelCase:       Tuple          =			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],
								    ]     ,  )

						__lowerCAmelCase      , __lowerCAmelCase:       List[str]          =			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
								__lowerCAmelCase:       Tuple          =			True
								check_hidden_states_output(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__)

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

								check_hidden_states_output(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__)

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



						'''simple docstring'''


						pass

				def 							lowercase_     (	self							:				Union[str, Any]     ,  UpperCamelCase__							:				Any     ,  UpperCamelCase__							:				Union[str, Any]     ,  UpperCamelCase__							:				Tuple=False)->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[Any]          =			super()._prepare_for_class(UpperCamelCase__     ,  UpperCamelCase__     ,  return_labels=UpperCamelCase__)

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

						return inputs_dict

				def 							lowercase_     (	self							:				Dict)->   Tuple:



						'''simple docstring'''


						__lowerCAmelCase:       Any          =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase__)

				def 							lowercase_     (	self							:				Any)->   Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[Any]          =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__)

				def 							lowercase_     (	self							:				Any)->   Union[str, Any]:



						'''simple docstring'''


						if not self.model_tester.is_training:
								return

						__lowerCAmelCase      , __lowerCAmelCase:       Tuple          =			self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase:       Tuple          =			True

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

				def 							lowercase_     (	self							:				str)->   List[str]:



						'''simple docstring'''


						__lowerCAmelCase      , __lowerCAmelCase:       int          =			self.model_tester.prepare_config_and_inputs_for_common()
						if not self.model_tester.is_training:
								return

						__lowerCAmelCase:       Optional[Any]          =			False
						__lowerCAmelCase:       Dict          =			True

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

				def 							lowercase_     (	self							:				Optional[int])->   List[Any]:



						'''simple docstring'''


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

						__lowerCAmelCase:       Optional[Any]          =			[
						    {"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__ == "LevitForImageClassificationWithTeacher"
								):
										continue

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

												__lowerCAmelCase:       Optional[int]          =			model_class(UpperCamelCase__)
												model.to(UpperCamelCase__)
												model.train()

												__lowerCAmelCase:       Optional[Any]          =			self._prepare_for_class(UpperCamelCase__     ,  UpperCamelCase__     ,  return_labels=UpperCamelCase__)

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

												__lowerCAmelCase:       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:
														__lowerCAmelCase:       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 							lowercase_     (	self							:				Dict)->   Tuple:



						'''simple docstring'''


						for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								__lowerCAmelCase:       Optional[Any]          =			LevitModel.from_pretrained(UpperCamelCase__)
								self.assertIsNotNone(UpperCamelCase__)






def     a__    (    )	->	Optional[Any]:
		__lowerCAmelCase:       List[Any]          =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
		return image





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

				@cached_property
				def 							lowercase_     (	self							:				List[str])->   List[Any]:



						'''simple docstring'''


						return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])




				@slow
				def 							lowercase_     (	self							:				str)->   Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:       Dict          =			LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
						    UpperCamelCase__)

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

						# forward pass
						with torch.no_grad():
								__lowerCAmelCase:       Optional[int]          =			model(**UpperCamelCase__)

						# verify the logits
						__lowerCAmelCase:       List[str]          =			torch.Size((1, 1_0_0_0))
						self.assertEqual(outputs.logits.shape     ,  UpperCamelCase__)

						__lowerCAmelCase:       List[Any]          =			torch.tensor([1.0448, -0.3745, -1.8317]).to(UpperCamelCase__)

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





"""simple docstring"""


import pytest

from datasets import inspect_metric, list_metrics, load_metric






@pytest.fixture
def     a__    (    __SCREAMING_SNAKE_CASE )	->	Union[str, Any]:
		monkeypatch.setattr("datasets.utils.deprecation_utils._emitted_deprecation_warnings"					, set() )






@pytest.fixture
def     a__    (    __SCREAMING_SNAKE_CASE )	->	str:





		class     snake_case	:

						def __init__(	self							:				int     ,  UpperCamelCase__							:				Optional[int])->   Union[str, Any]:



								'''simple docstring'''


								__lowerCAmelCase:       str          =			metric_id





		class     snake_case	:
						SCREAMING_SNAKE_CASE_   :      List[Any]         =  [MetricMock(__snake_case  ) for metric_id in ["""accuracy""", """mse""", """precision""", """codeparrot/apps_metric"""]]

						def 							lowercase_     (	self							:				Tuple)->   Union[str, Any]:



								'''simple docstring'''


								return self._metrics


		monkeypatch.setattr("datasets.inspect.huggingface_hub"					, HfhMock() )






@pytest.mark.parametrize(
    "func, args"					, [(load_metric, ("metrics/mse",)), (list_metrics, ()), (inspect_metric, ("metrics/mse", "tmp_path"))] )
def     a__    (    __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE )	->	Optional[Any]:
		if "tmp_path" in args:
				__lowerCAmelCase:       Tuple          =			tuple(arg if arg != "tmp_path" else tmp_path for arg in args )
		with pytest.warns(__SCREAMING_SNAKE_CASE					, match="https://huggingface.co/docs/evaluate" ):
				func(*__SCREAMING_SNAKE_CASE )


