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




					"""simple docstring"""

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







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

									UpperCAmelCase__    =							None
									if self.use_labels:
													UpperCAmelCase__    =							ids_tensor([self.batch_size]					,self.num_labels    )

									UpperCAmelCase__    =							self.get_config()
									return config, pixel_values, labels







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







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							self.prepare_config_and_inputs()
									UpperCAmelCase__   ,			UpperCAmelCase__   ,			UpperCAmelCase__    =							config_and_inputs
									UpperCAmelCase__    =							{'pixel_values': pixel_values}
									return config, inputs_dict






@require_torch
class        snake_case (				__UpperCAmelCase   ,					__UpperCAmelCase   ,					unittest.TestCase       ):




					"""simple docstring"""

					snake_case__       					=				(
					    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
					    if is_torch_available()
					    else ()
					)
					snake_case__       					=				(
					    {
					        "feature-extraction": LevitModel,
					        "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
					    }
					    if is_torch_available()
					    else {}
					)

					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									UpperCAmelCase__    =							LevitModelTester(self    )
									UpperCAmelCase__    =							ConfigTester(self					,config_class=lowerCamelCase__					,has_text_modality=lowerCamelCase__					,hidden_size=37    )







					def 	__lowerCAmelCase		(       self     :			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 	__lowerCAmelCase		(       self     :			int    ):
									return







					@unittest.skip(reason='Levit does not use inputs_embeds'    )
					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									pass







					@unittest.skip(reason='Levit does not support input and output embeddings'    )
					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									pass







					@unittest.skip(reason='Levit does not output attentions'    )
					def 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									pass







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													UpperCAmelCase__    =							model_class(lowerCamelCase__    )
													UpperCAmelCase__    =							inspect.signature(model.forward    )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													UpperCAmelCase__    =							[*signature.parameters.keys()]

													UpperCAmelCase__    =							['pixel_values']
													self.assertListEqual(arg_names[:1]					,lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									def check_hidden_states_output(lowerCamelCase__     :			Tuple					,lowerCamelCase__     :			Tuple					,lowerCamelCase__     :			int    ):
													UpperCAmelCase__    =							model_class(lowerCamelCase__    )
													model.to(lowerCamelCase__    )
													model.eval()

													with torch.no_grad():
																	UpperCAmelCase__    =							model(**self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )    )

													UpperCAmelCase__    =							outputs.hidden_states

													UpperCAmelCase__    =							len(self.model_tester.depths    ) + 1
													self.assertEqual(len(lowerCamelCase__    )					,lowerCamelCase__    )

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

									for model_class in self.all_model_classes:
													UpperCAmelCase__    =							True
													check_hidden_states_output(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													UpperCAmelCase__    =							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 	__lowerCAmelCase		(       self     :			Dict    ):
									pass







					def 	__lowerCAmelCase		(       self     :			List[str]					,lowerCamelCase__     :			Optional[int]					,lowerCamelCase__     :			int					,lowerCamelCase__     :			Union[str, Any]=False    ):
									UpperCAmelCase__    =							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 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									if not self.model_tester.is_training:
													return

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







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
													return

									UpperCAmelCase__    =							False
									UpperCAmelCase__    =							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
													UpperCAmelCase__    =							model_class(lowerCamelCase__    )
													model.gradient_checkpointing_enable()
													model.to(lowerCamelCase__    )
													model.train()
													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )
													UpperCAmelCase__    =							model(**lowerCamelCase__    ).loss
													loss.backward()







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs_for_common()

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

																					UpperCAmelCase__    =							model_class(lowerCamelCase__    )
																					model.to(lowerCamelCase__    )
																					model.train()

																					UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )

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

																					UpperCAmelCase__    =							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:
																									UpperCAmelCase__    =							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 	__lowerCAmelCase		(       self     :			int    ):
									for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__    =							LevitModel.from_pretrained(lowerCamelCase__    )
													self.assertIsNotNone(lowerCamelCase__    )






def 						a_		(      ):
				UpperCAmelCase__    =							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 	__lowerCAmelCase		(       self     :			Dict    ):
									return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )







					@slow
					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									UpperCAmelCase__    =							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
									    lowerCamelCase__    )

									UpperCAmelCase__    =							self.default_image_processor
									UpperCAmelCase__    =							prepare_img()
									UpperCAmelCase__    =							image_processor(images=lowerCamelCase__					,return_tensors='pt'    ).to(lowerCamelCase__    )

									# forward pass
									with torch.no_grad():
													UpperCAmelCase__    =							model(**lowerCamelCase__    )

									# verify the logits
									UpperCAmelCase__    =							torch.Size((1, 1_000)    )
									self.assertEqual(outputs.logits.shape					,lowerCamelCase__    )

									UpperCAmelCase__    =							torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]    ).to(lowerCamelCase__    )

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




"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowerCAmelCase__						:						int		  =			{
    'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
    'tokenization_tapas': ['TapasTokenizer'],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__						:						Union[str, Any]		  =			[
						    'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TapasForMaskedLM',
						    'TapasForQuestionAnswering',
						    'TapasForSequenceClassification',
						    'TapasModel',
						    'TapasPreTrainedModel',
						    'load_tf_weights_in_tapas',
						]
try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__						:						Optional[Any]		  =			[
						    'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TFTapasForMaskedLM',
						    'TFTapasForQuestionAnswering',
						    'TFTapasForSequenceClassification',
						    'TFTapasModel',
						    'TFTapasPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
						from .tokenization_tapas import TapasTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tapas import (
												    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TapasForMaskedLM,
												    TapasForQuestionAnswering,
												    TapasForSequenceClassification,
												    TapasModel,
												    TapasPreTrainedModel,
												    load_tf_weights_in_tapas,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_tapas import (
												    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFTapasForMaskedLM,
												    TFTapasForQuestionAnswering,
												    TFTapasForSequenceClassification,
												    TFTapasModel,
												    TFTapasPreTrainedModel,
												)


else:
						import sys

						lowerCAmelCase__						:						Dict		  =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



