


'''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__(							a__							):







						'''simple docstring'''




						def 						lowercase_ (				self							)					->    Optional[Any]:
										lowerCAmelCase_ :      int    				=				self.config_class(**self.inputs_dict							)
										self.parent.assertTrue(hasattr(lowerCAmelCase__   ,						'''hidden_sizes'''							)							)
										self.parent.assertTrue(hasattr(lowerCAmelCase__   ,						'''num_attention_heads'''							)							)







class 				snake_case__:







						'''simple docstring'''




						def __init__(				self   ,						__lowercase   ,						__lowercase=1_3   ,						__lowercase=6_4   ,						__lowercase=3   ,						__lowercase=3   ,						__lowercase=2   ,						__lowercase=1   ,						__lowercase=1_6   ,						__lowercase=[1_2_8, 2_5_6, 3_8_4]   ,						__lowercase=[4, 6, 8]   ,						__lowercase=[2, 3, 4]   ,						__lowercase=[1_6, 1_6, 1_6]   ,						__lowercase=0   ,						__lowercase=[2, 2, 2]   ,						__lowercase=[2, 2, 2]   ,						__lowercase=0.02   ,						__lowercase=True   ,						__lowercase=True   ,						__lowercase=2   ,						)					->    Union[str, Any]:
										lowerCAmelCase_ :      List[str]    				=				parent
										lowerCAmelCase_ :      List[str]    				=				batch_size
										lowerCAmelCase_ :      Union[str, Any]    				=				image_size
										lowerCAmelCase_ :      str    				=				num_channels
										lowerCAmelCase_ :      Optional[Any]    				=				kernel_size
										lowerCAmelCase_ :      Optional[int]    				=				stride
										lowerCAmelCase_ :      List[Any]    				=				padding
										lowerCAmelCase_ :      Tuple    				=				hidden_sizes
										lowerCAmelCase_ :      Any    				=				num_attention_heads
										lowerCAmelCase_ :      Union[str, Any]    				=				depths
										lowerCAmelCase_ :      int    				=				key_dim
										lowerCAmelCase_ :      Union[str, Any]    				=				drop_path_rate
										lowerCAmelCase_ :      Optional[Any]    				=				patch_size
										lowerCAmelCase_ :      int    				=				attention_ratio
										lowerCAmelCase_ :      str    				=				mlp_ratio
										lowerCAmelCase_ :      Any    				=				initializer_range
										lowerCAmelCase_ :      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],
										]
										lowerCAmelCase_ :      Dict    				=				is_training
										lowerCAmelCase_ :      Tuple    				=				use_labels
										lowerCAmelCase_ :      Any    				=				num_labels
										lowerCAmelCase_ :      Any    				=				initializer_range




						def 						lowercase_ (				self							)					->    Tuple:
										lowerCAmelCase_ :      int    				=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										lowerCAmelCase_ :      Tuple    				=				None
										if self.use_labels:
														lowerCAmelCase_ :      List[str]    				=				ids_tensor([self.batch_size]   ,						self.num_labels							)

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




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




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







@require_torch
class 				snake_case__(							a__,						a__,						unittest.TestCase							):







						'''simple docstring'''




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

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




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      List[Any]    				=				LevitModelTester(self							)
										lowerCAmelCase_ :      Optional[int]    				=				ConfigTester(self   ,						config_class=lowerCAmelCase__   ,						has_text_modality=lowerCAmelCase__   ,						hidden_size=3_7							)




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




						@unittest.skip(reason='''Levit does not use inputs_embeds'''							)
						def 						lowercase_ (				self							)					->    Optional[Any]:
										pass




						@unittest.skip(reason='''Levit does not support input and output embeddings'''							)
						def 						lowercase_ (				self							)					->    Dict:
										pass




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




						def 						lowercase_ (				self							)					->    Dict:
										lowerCAmelCase_ :      Optional[Any]    				=				self.model_tester.prepare_config_and_inputs_for_common()

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

														lowerCAmelCase_ :      Dict    				=				["pixel_values"]
														self.assertListEqual(arg_names[:1]   ,						lowerCAmelCase__							)




						def 						lowercase_ (				self							)					->    int:
										def check_hidden_states_output(__lowercase   ,						__lowercase   ,						__lowercase							):
														lowerCAmelCase_ :      Optional[Any]    				=				model_class(lowerCAmelCase__							)
														model.to(lowerCAmelCase__							)
														model.eval()

														with torch.no_grad():
																		lowerCAmelCase_ :      Optional[int]    				=				model(**self._prepare_for_class(lowerCAmelCase__   ,						lowerCAmelCase__							)							)

														lowerCAmelCase_ :      Tuple    				=				outputs.hidden_states

														lowerCAmelCase_ :      Any    				=				len(self.model_tester.depths							) + 1
														self.assertEqual(len(lowerCAmelCase__							)   ,						lowerCAmelCase__							)

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

										for model_class in self.all_model_classes:
														lowerCAmelCase_ :      List[str]    				=				True
														check_hidden_states_output(lowerCAmelCase__   ,						lowerCAmelCase__   ,						lowerCAmelCase__							)

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														lowerCAmelCase_ :      List[Any]    				=				True

														check_hidden_states_output(lowerCAmelCase__   ,						lowerCAmelCase__   ,						lowerCAmelCase__							)




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




						def 						lowercase_ (				self   ,						__lowercase   ,						__lowercase   ,						__lowercase=False							)					->    Union[str, Any]:
										lowerCAmelCase_ :      Optional[int]    				=				super()._prepare_for_class(lowerCAmelCase__   ,						lowerCAmelCase__   ,						return_labels=lowerCAmelCase__							)

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

										return inputs_dict




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Dict    				=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase__							)




						def 						lowercase_ (				self							)					->    str:
										lowerCAmelCase_ :      Optional[int]    				=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__							)




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

										lowerCAmelCase_ :      List[str]    				=				self.model_tester.prepare_config_and_inputs_for_common()
										lowerCAmelCase_ :      List[Any]    				=				True

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




						def 						lowercase_ (				self							)					->    List[str]:
										lowerCAmelCase_ :      str    				=				self.model_tester.prepare_config_and_inputs_for_common()
										if not self.model_tester.is_training:
														return

										lowerCAmelCase_ :      Any    				=				False
										lowerCAmelCase_ :      str    				=				True

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




						def 						lowercase_ (				self							)					->    Dict:
										lowerCAmelCase_ :      str    				=				self.model_tester.prepare_config_and_inputs_for_common()

										lowerCAmelCase_ :      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(lowerCAmelCase__							),
														    ]
														    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_ :      str    				=				problem_type["title"]
																						lowerCAmelCase_ :      int    				=				problem_type["num_labels"]

																						lowerCAmelCase_ :      Union[str, Any]    				=				model_class(lowerCAmelCase__							)
																						model.to(lowerCAmelCase__							)
																						model.train()

																						lowerCAmelCase_ :      List[Any]    				=				self._prepare_for_class(lowerCAmelCase__   ,						lowerCAmelCase__   ,						return_labels=lowerCAmelCase__							)

																						if problem_type["num_labels"] > 1:
																										lowerCAmelCase_ :      Optional[Any]    				=				inputs["labels"].unsqueeze(1							).repeat(1   ,						problem_type['''num_labels''']							)

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






def 			lowerCAmelCase (		)-> List[str]:
				lowerCAmelCase_ :      Dict    				=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
				return image







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







						'''simple docstring'''




						@cached_property
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)




						@slow
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										lowerCAmelCase_ :      Optional[int]    				=				LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
										    lowerCAmelCase__							)

										lowerCAmelCase_ :      Optional[Any]    				=				self.default_image_processor
										lowerCAmelCase_ :      int    				=				prepare_img()
										lowerCAmelCase_ :      Any    				=				image_processor(images=lowerCAmelCase__   ,						return_tensors='''pt'''							).to(lowerCAmelCase__							)

										# forward pass
										with torch.no_grad():
														lowerCAmelCase_ :      Optional[Any]    				=				model(**lowerCAmelCase__							)

										# verify the logits
										lowerCAmelCase_ :      Dict    				=				torch.Size((1, 1_0_0_0)							)
										self.assertEqual(outputs.logits.shape   ,						lowerCAmelCase__							)

										lowerCAmelCase_ :      Optional[Any]    				=				torch.tensor([1.04_48, -0.37_45, -1.83_17]							).to(lowerCAmelCase__							)

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



_UpperCAmelCase			:  int     =frozenset(
    [
        """prompt""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
        """cross_attention_kwargs""",
    ]
)

_UpperCAmelCase			:  List[Any]     =frozenset(["""prompt""", """negative_prompt"""])

_UpperCAmelCase			:  Dict     =frozenset([])

_UpperCAmelCase			:  int     =frozenset(["""image"""])

_UpperCAmelCase			:  Tuple     =frozenset(
    [
        """image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

_UpperCAmelCase			:  int     =frozenset(["""image"""])

_UpperCAmelCase			:  str     =frozenset(
    [
        """prompt""",
        """image""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
    ]
)

_UpperCAmelCase			:  int     =frozenset(["""prompt""", """image""", """negative_prompt"""])

_UpperCAmelCase			:  Optional[int]     =frozenset(
    [
        # Text guided image variation with an image mask
        """prompt""",
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
    ]
)

_UpperCAmelCase			:  Optional[int]     =frozenset(["""prompt""", """image""", """mask_image""", """negative_prompt"""])

_UpperCAmelCase			:  Optional[Any]     =frozenset(
    [
        # image variation with an image mask
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

_UpperCAmelCase			:  Optional[Any]     =frozenset(["""image""", """mask_image"""])

_UpperCAmelCase			:  Union[str, Any]     =frozenset(
    [
        """example_image""",
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

_UpperCAmelCase			:  Tuple     =frozenset(["""example_image""", """image""", """mask_image"""])

_UpperCAmelCase			:  Any     =frozenset(["""class_labels"""])

_UpperCAmelCase			:  List[Any]     =frozenset(["""class_labels"""])

_UpperCAmelCase			:  int     =frozenset(["""batch_size"""])

_UpperCAmelCase			:  str     =frozenset([])

_UpperCAmelCase			:  str     =frozenset(["""batch_size"""])

_UpperCAmelCase			:  Optional[Any]     =frozenset([])

_UpperCAmelCase			:  Tuple     =frozenset(
    [
        """prompt""",
        """audio_length_in_s""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
        """cross_attention_kwargs""",
    ]
)

_UpperCAmelCase			:  Tuple     =frozenset(["""prompt""", """negative_prompt"""])
_UpperCAmelCase			:  List[str]     =frozenset(["""input_tokens"""])

_UpperCAmelCase			:  Optional[Any]     =frozenset(["""input_tokens"""])