

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        A__(a_							):
						"""simple docstring"""






						def 			UpperCamelCase__					(    self    )     -> List[str]:
									a_						:						str 							= self.config_class(**self.inputs_dict    )
									self.parent.assertTrue(hasattr(_lowercase  ,      """hidden_sizes"""    )    )
									self.parent.assertTrue(hasattr(_lowercase  ,      """num_attention_heads"""    )    )







class        A__:
						"""simple docstring"""






						def __init__(    self  ,      _lowercase  ,      _lowercase=13  ,      _lowercase=64  ,      _lowercase=3  ,      _lowercase=3  ,      _lowercase=2  ,      _lowercase=1  ,      _lowercase=16  ,      _lowercase=[128, 256, 384]  ,      _lowercase=[4, 6, 8]  ,      _lowercase=[2, 3, 4]  ,      _lowercase=[16, 16, 16]  ,      _lowercase=0  ,      _lowercase=[2, 2, 2]  ,      _lowercase=[2, 2, 2]  ,      _lowercase=0.0_2  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=2  ,      )     -> Optional[int]:
									a_						:						Union[str, Any] 							= parent
									a_						:						Optional[Any] 							= batch_size
									a_						:						Tuple 							= image_size
									a_						:						List[str] 							= num_channels
									a_						:						Optional[int] 							= kernel_size
									a_						:						Optional[Any] 							= stride
									a_						:						Union[str, Any] 							= padding
									a_						:						Optional[int] 							= hidden_sizes
									a_						:						Union[str, Any] 							= num_attention_heads
									a_						:						Optional[int] 							= depths
									a_						:						Tuple 							= key_dim
									a_						:						int 							= drop_path_rate
									a_						:						Union[str, Any] 							= patch_size
									a_						:						Optional[Any] 							= attention_ratio
									a_						:						List[str] 							= mlp_ratio
									a_						:						Optional[Any] 							= initializer_range
									a_						:						Union[str, Any] 							= [
									    ["""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],
									]
									a_						:						int 							= is_training
									a_						:						Union[str, Any] 							= use_labels
									a_						:						Optional[Any] 							= num_labels
									a_						:						str 							= initializer_range





						def 			UpperCamelCase__					(    self    )     -> str:
									a_						:						List[str] 							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

									a_						:						Any 							= None
									if self.use_labels:
												a_						:						Tuple 							= ids_tensor([self.batch_size]  ,      self.num_labels    )

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





						def 			UpperCamelCase__					(    self    )     -> int:
									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 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase    )     -> Dict:
									a_						:						Any 							= LevitModel(config=_lowercase    )
									model.to(_lowercase    )
									model.eval()
									a_						:						Dict 							= model(_lowercase    )
									a_						:						List[str] 							= (self.image_size, self.image_size)
									a_							,					a_						:						Tuple 							= image_size[0], image_size[1]
									for _ in range(4    ):
												a_						:						Dict 							= floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1    )
												a_						:						Optional[int] 							= 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 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase    )     -> Any:
									a_						:						List[str] 							= self.num_labels
									a_						:						Tuple 							= LevitForImageClassification(_lowercase    )
									model.to(_lowercase    )
									model.eval()
									a_						:						Optional[int] 							= model(_lowercase  ,      labels=_lowercase    )
									self.parent.assertEqual(result.logits.shape  ,      (self.batch_size, self.num_labels)    )





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







@require_torch
class        A__(a_,  a_,  unittest.TestCase							):
						"""simple docstring"""






						_A    :				Union[str, Any]       					=			(
						    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
						    if is_torch_available()
						    else ()
						)
						_A    :				Tuple       					=			(
						    {
						        '''feature-extraction''': LevitModel,
						        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
						    }
						    if is_torch_available()
						    else {}
						)

						_A    :				Tuple       					=			False
						_A    :				Union[str, Any]       					=			False
						_A    :				Any       					=			False
						_A    :				Optional[Any]       					=			False
						_A    :				Dict       					=			False





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						List[Any] 							= LevitModelTester(self    )
									a_						:						Union[str, Any] 							= ConfigTester(self  ,      config_class=_lowercase  ,      has_text_modality=_lowercase  ,      hidden_size=37    )





						def 			UpperCamelCase__					(    self    )     -> Union[str, 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 			UpperCamelCase__					(    self    )     -> List[str]:
									return





						@unittest.skip(reason="""Levit does not use inputs_embeds"""    )
						def 			UpperCamelCase__					(    self    )     -> Dict:
									pass





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





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





						def 			UpperCamelCase__					(    self    )     -> Union[str, Any]:
									a_							,					a_						:						List[Any] 							= self.model_tester.prepare_config_and_inputs_for_common()

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

												a_						:						Optional[int] 							= ["""pixel_values"""]
												self.assertListEqual(arg_names[:1]  ,      _lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Tuple:
									def check_hidden_states_output(_lowercase  ,      _lowercase  ,      _lowercase    ):
												a_						:						Dict 							= model_class(_lowercase    )
												model.to(_lowercase    )
												model.eval()

												with torch.no_grad():
															a_						:						Union[str, Any] 							= model(**self._prepare_for_class(_lowercase  ,      _lowercase    )    )

												a_						:						str 							= outputs.hidden_states

												a_						:						List[Any] 							= len(self.model_tester.depths    ) + 1
												self.assertEqual(len(_lowercase    )  ,      _lowercase    )

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

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

									for model_class in self.all_model_classes:
												a_						:						Tuple 							= True
												check_hidden_states_output(_lowercase  ,      _lowercase  ,      _lowercase    )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												a_						:						Tuple 							= True

												check_hidden_states_output(_lowercase  ,      _lowercase  ,      _lowercase    )





						@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""    )
						def 			UpperCamelCase__					(    self    )     -> Tuple:
									pass





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase=False    )     -> Optional[Any]:
									a_						:						Optional[int] 							= super()._prepare_for_class(_lowercase  ,      _lowercase  ,      return_labels=_lowercase    )

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

									return inputs_dict





						def 			UpperCamelCase__					(    self    )     -> List[Any]:
									a_						:						Union[str, Any] 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						List[str] 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									if not self.model_tester.is_training:
												return

									a_							,					a_						:						Optional[Any] 							= self.model_tester.prepare_config_and_inputs_for_common()
									a_						:						Optional[int] 							= True

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





						def 			UpperCamelCase__					(    self    )     -> int:
									a_							,					a_						:						Optional[Any] 							= self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
												return

									a_						:						List[Any] 							= False
									a_						:						List[str] 							= True

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





						def 			UpperCamelCase__					(    self    )     -> int:
									a_							,					a_						:						Any 							= self.model_tester.prepare_config_and_inputs_for_common()

									a_						:						List[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(_lowercase    ),
												    ]
												    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
												):
															continue

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

																		a_						:						Optional[Any] 							= model_class(_lowercase    )
																		model.to(_lowercase    )
																		model.train()

																		a_						:						Any 							= self._prepare_for_class(_lowercase  ,      _lowercase  ,      return_labels=_lowercase    )

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

																		a_						:						Union[str, Any] 							= 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=_lowercase    ) as warning_list:
																					a_						:						str 							= model(**_lowercase    ).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 			UpperCamelCase__					(    self    )     -> List[Any]:
									for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_						:						int 							= LevitModel.from_pretrained(_lowercase    )
												self.assertIsNotNone(_lowercase    )







def 					_UpperCAmelCase				(						):

			'''simple docstring'''



			a_						:						Union[str, Any] 							= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""")
			return image



@require_torch
@require_vision
class        A__(unittest.TestCase							):
						"""simple docstring"""






						@cached_property
						def 			UpperCamelCase__					(    self    )     -> Any:
									return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )





						@slow
						def 			UpperCamelCase__					(    self    )     -> Union[str, Any]:
									a_						:						List[Any] 							= LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
									    _lowercase    )

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

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

									# verify the logits
									a_						:						List[Any] 							= torch.Size((1, 1_000)    )
									self.assertEqual(outputs.logits.shape  ,      _lowercase    )

									a_						:						Union[str, Any] 							= torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]    ).to(_lowercase    )

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





__snake_case				:      int   		=			[
    """Audio""",
    """Array2D""",
    """Array3D""",
    """Array4D""",
    """Array5D""",
    """ClassLabel""",
    """Features""",
    """Sequence""",
    """Value""",
    """Image""",
    """Translation""",
    """TranslationVariableLanguages""",
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages


