
'''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  lowerCAmelCase__   (  lowerCamelCase_     ):






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     int													=       self.config_class(**self.inputs_dict		)
											self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE				,							'''hidden_sizes'''		)		)
											self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE				,							'''num_attention_heads'''		)		)







class  lowerCAmelCase__   :






					def __init__(   self				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE=13				,							__SCREAMING_SNAKE_CASE=64				,							__SCREAMING_SNAKE_CASE=3				,							__SCREAMING_SNAKE_CASE=3				,							__SCREAMING_SNAKE_CASE=2				,							__SCREAMING_SNAKE_CASE=1				,							__SCREAMING_SNAKE_CASE=16				,							__SCREAMING_SNAKE_CASE=[1_28, 2_56, 3_84]				,							__SCREAMING_SNAKE_CASE=[4, 6, 8]				,							__SCREAMING_SNAKE_CASE=[2, 3, 4]				,							__SCREAMING_SNAKE_CASE=[16, 16, 16]				,							__SCREAMING_SNAKE_CASE=0				,							__SCREAMING_SNAKE_CASE=[2, 2, 2]				,							__SCREAMING_SNAKE_CASE=[2, 2, 2]				,							__SCREAMING_SNAKE_CASE=0.02				,							__SCREAMING_SNAKE_CASE=True				,							__SCREAMING_SNAKE_CASE=True				,							__SCREAMING_SNAKE_CASE=2				,							):


											"""simple docstring"""





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






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Optional[Any]													=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

											lowercase_	:     str													=       self.get_config()
											return config, pixel_values, labels






					def 	_snake_case    (   self		):


											"""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 	_snake_case    (   self				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





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


											"""simple docstring"""





											lowercase_	:     int													=       self.num_labels
											lowercase_	:     Dict													=       LevitForImageClassification(__SCREAMING_SNAKE_CASE		)
											model.to(__SCREAMING_SNAKE_CASE		)
											model.eval()
											lowercase_	:     Optional[int]													=       model(__SCREAMING_SNAKE_CASE				,							labels=__SCREAMING_SNAKE_CASE		)
											self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.num_labels)		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Dict													=       self.prepare_config_and_inputs()
											lowercase_						, lowercase_						, lowercase_	:     List[Any]													=       config_and_inputs
											lowercase_	:     List[Any]													=       {'''pixel_values''': pixel_values}
											return config, inputs_dict







@require_torch
class  lowerCAmelCase__   (  lowerCamelCase_    ,						lowerCamelCase_    ,						unittest.TestCase     ):
					lowerCAmelCase_        =     (
					    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
					    if is_torch_available()
					    else ()
					)
					lowerCAmelCase_        =     (
					    {
					        '''feature-extraction''': LevitModel,
					        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
					    }
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_        =     False
					lowerCAmelCase_        =     False
					lowerCAmelCase_        =     False
					lowerCAmelCase_        =     False
					lowerCAmelCase_        =     False






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Union[str, Any]													=       LevitModelTester(self		)
											lowercase_	:     Any													=       ConfigTester(self				,							config_class=__SCREAMING_SNAKE_CASE				,							has_text_modality=__SCREAMING_SNAKE_CASE				,							hidden_size=37		)






					def 	_snake_case    (   self		):


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


											"""simple docstring"""





											return






					@unittest.skip(reason='''Levit does not use inputs_embeds'''		)
					def 	_snake_case    (   self		):


											"""simple docstring"""





											pass






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


											"""simple docstring"""





											pass






					@unittest.skip(reason='''Levit does not output attentions'''		)
					def 	_snake_case    (   self		):


											"""simple docstring"""





											pass






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_						, lowercase_	:     Optional[int]													=       self.model_tester.prepare_config_and_inputs_for_common()

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

																	lowercase_	:     Optional[int]													=       ['''pixel_values''']
																	self.assertListEqual(arg_names[:1]				,							__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											def check_hidden_states_output(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		):
																	lowercase_	:     str													=       model_class(__SCREAMING_SNAKE_CASE		)
																	model.to(__SCREAMING_SNAKE_CASE		)
																	model.eval()

																	with torch.no_grad():
																							lowercase_	:     List[Any]													=       model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		)		)

																	lowercase_	:     Optional[Any]													=       outputs.hidden_states

																	lowercase_	:     Any													=       len(self.model_tester.depths		) + 1
																	self.assertEqual(len(__SCREAMING_SNAKE_CASE		)				,							__SCREAMING_SNAKE_CASE		)

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

											lowercase_						, lowercase_	:     Tuple													=       self.model_tester.prepare_config_and_inputs_for_common()

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

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	lowercase_	:     Optional[int]													=       True

																	check_hidden_states_output(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		)






					@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''		)
					def 	_snake_case    (   self		):


											"""simple docstring"""





											pass






					def 	_snake_case    (   self				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE=False		):


											"""simple docstring"""





											lowercase_	:     Optional[int]													=       super()._prepare_for_class(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							return_labels=__SCREAMING_SNAKE_CASE		)

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

											return inputs_dict






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Optional[int]													=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Tuple													=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											if not self.model_tester.is_training:
																	return

											lowercase_						, lowercase_	:     str													=       self.model_tester.prepare_config_and_inputs_for_common()
											lowercase_	:     Dict													=       True

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






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_						, lowercase_	:     Optional[int]													=       self.model_tester.prepare_config_and_inputs_for_common()
											if not self.model_tester.is_training:
																	return

											lowercase_	:     Union[str, Any]													=       False
											lowercase_	:     int													=       True

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






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_						, lowercase_	:     List[Any]													=       self.model_tester.prepare_config_and_inputs_for_common()

											lowercase_	:     Union[str, 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(__SCREAMING_SNAKE_CASE		),
																	    ]
																	    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																	):
																							continue

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

																													lowercase_	:     List[Any]													=       model_class(__SCREAMING_SNAKE_CASE		)
																													model.to(__SCREAMING_SNAKE_CASE		)
																													model.train()

																													lowercase_	:     Any													=       self._prepare_for_class(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							return_labels=__SCREAMING_SNAKE_CASE		)

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

																													lowercase_	:     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=__SCREAMING_SNAKE_CASE		) as warning_list:
																																			lowercase_	:     List[Any]													=       model(**__SCREAMING_SNAKE_CASE		).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 	_snake_case    (   self		):


											"""simple docstring"""





											for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase_	:     List[Any]													=       LevitModel.from_pretrained(__SCREAMING_SNAKE_CASE		)
																	self.assertIsNotNone(__SCREAMING_SNAKE_CASE		)







def 					snake_case_		(				):



						"""simple docstring"""





						lowercase_	:     Any													=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
						return image






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






					@cached_property
					def 	_snake_case    (   self		):


											"""simple docstring"""





											return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)






					@slow
					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     List[Any]													=       LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
											    __SCREAMING_SNAKE_CASE		)

											lowercase_	:     str													=       self.default_image_processor
											lowercase_	:     Dict													=       prepare_img()
											lowercase_	:     List[Any]													=       image_processor(images=__SCREAMING_SNAKE_CASE				,							return_tensors='''pt'''		).to(__SCREAMING_SNAKE_CASE		)

											# forward pass
											with torch.no_grad():
																	lowercase_	:     List[Any]													=       model(**__SCREAMING_SNAKE_CASE		)

											# verify the logits
											lowercase_	:     Tuple													=       torch.Size((1, 10_00)		)
											self.assertEqual(outputs.logits.shape				,							__SCREAMING_SNAKE_CASE		)

											lowercase_	:     Any													=       torch.tensor([1.0_448, -0.3_745, -1.8_317]		).to(__SCREAMING_SNAKE_CASE		)

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





'''simple docstring'''







from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_lowercase :  int    							=       logging.get_logger(__name__)

_lowercase :  List[Any]    							=       {
    "shi-labs/nat-mini-in1k-224": "https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json",
    # See all Nat models at https://huggingface.co/models?filter=nat
}






class  lowerCAmelCase__   (  lowerCamelCase_    ,						lowerCamelCase_     ):
					lowerCAmelCase_        =     '''nat'''

					lowerCAmelCase_        =     {
					    '''num_attention_heads''': '''num_heads''',
					    '''num_hidden_layers''': '''num_layers''',
					}






					def __init__(   self				,							__SCREAMING_SNAKE_CASE=4				,							__SCREAMING_SNAKE_CASE=3				,							__SCREAMING_SNAKE_CASE=64				,							__SCREAMING_SNAKE_CASE=[3, 4, 6, 5]				,							__SCREAMING_SNAKE_CASE=[2, 4, 8, 16]				,							__SCREAMING_SNAKE_CASE=7				,							__SCREAMING_SNAKE_CASE=3.0				,							__SCREAMING_SNAKE_CASE=True				,							__SCREAMING_SNAKE_CASE=0.0				,							__SCREAMING_SNAKE_CASE=0.0				,							__SCREAMING_SNAKE_CASE=0.1				,							__SCREAMING_SNAKE_CASE="gelu"				,							__SCREAMING_SNAKE_CASE=0.02				,							__SCREAMING_SNAKE_CASE=1E-5				,							__SCREAMING_SNAKE_CASE=0.0				,							__SCREAMING_SNAKE_CASE=None				,							__SCREAMING_SNAKE_CASE=None				,							**__SCREAMING_SNAKE_CASE				,							):


											"""simple docstring"""





											super().__init__(**__SCREAMING_SNAKE_CASE		)

											lowercase_	:     Optional[int]													=       patch_size
											lowercase_	:     List[Any]													=       num_channels
											lowercase_	:     str													=       embed_dim
											lowercase_	:     List[str]													=       depths
											lowercase_	:     str													=       len(__SCREAMING_SNAKE_CASE		)
											lowercase_	:     Tuple													=       num_heads
											lowercase_	:     int													=       kernel_size
											lowercase_	:     Union[str, Any]													=       mlp_ratio
											lowercase_	:     Optional[int]													=       qkv_bias
											lowercase_	:     List[Any]													=       hidden_dropout_prob
											lowercase_	:     Optional[int]													=       attention_probs_dropout_prob
											lowercase_	:     List[Any]													=       drop_path_rate
											lowercase_	:     List[Any]													=       hidden_act
											lowercase_	:     int													=       layer_norm_eps
											lowercase_	:     int													=       initializer_range
											# we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
											# this indicates the channel dimension after the last stage of the model
											lowercase_	:     Dict													=       int(embed_dim * 2 ** (len(__SCREAMING_SNAKE_CASE		) - 1)		)
											lowercase_	:     Tuple													=       layer_scale_init_value
											lowercase_	:     Union[str, Any]													=       ['''stem'''] + [F'''stage{idx}''' for idx in range(1				,							len(__SCREAMING_SNAKE_CASE		) + 1		)]
											lowercase_						, lowercase_	:     int													=       get_aligned_output_features_output_indices(
											    out_features=__SCREAMING_SNAKE_CASE				,							out_indices=__SCREAMING_SNAKE_CASE				,							stage_names=self.stage_names		)



