





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







	'''simple docstring'''

	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				__lowercase			  =							self.config_class(**self.inputs_dict	)
				self.parent.assertTrue(hasattr(_lowerCamelCase       ,'''hidden_sizes'''	)	)
				self.parent.assertTrue(hasattr(_lowerCamelCase       ,'''num_attention_heads'''	)	)






class 							__lowercase    :







	'''simple docstring'''

	def __init__(self       ,_lowerCamelCase       ,_lowerCamelCase=13       ,_lowerCamelCase=64       ,_lowerCamelCase=3       ,_lowerCamelCase=3       ,_lowerCamelCase=2       ,_lowerCamelCase=1       ,_lowerCamelCase=16       ,_lowerCamelCase=[128, 256, 384]       ,_lowerCamelCase=[4, 6, 8]       ,_lowerCamelCase=[2, 3, 4]       ,_lowerCamelCase=[16, 16, 16]       ,_lowerCamelCase=0       ,_lowerCamelCase=[2, 2, 2]       ,_lowerCamelCase=[2, 2, 2]       ,_lowerCamelCase=0.0_2       ,_lowerCamelCase=True       ,_lowerCamelCase=True       ,_lowerCamelCase=2       ,)							->							int:







				'''simple docstring'''





				__lowercase			  =							parent
				__lowercase			  =							batch_size
				__lowercase			  =							image_size
				__lowercase			  =							num_channels
				__lowercase			  =							kernel_size
				__lowercase			  =							stride
				__lowercase			  =							padding
				__lowercase			  =							hidden_sizes
				__lowercase			  =							num_attention_heads
				__lowercase			  =							depths
				__lowercase			  =							key_dim
				__lowercase			  =							drop_path_rate
				__lowercase			  =							patch_size
				__lowercase			  =							attention_ratio
				__lowercase			  =							mlp_ratio
				__lowercase			  =							initializer_range
				__lowercase			  =							[
				    ['''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			  =							is_training
				__lowercase			  =							use_labels
				__lowercase			  =							num_labels
				__lowercase			  =							initializer_range


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





				__lowercase			  =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''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   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	)							->							Dict:







				'''simple docstring'''





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







				'''simple docstring'''





				__lowercase			  =							self.num_labels
				__lowercase			  =							LevitForImageClassification(_lowerCamelCase	)
				model.to(_lowerCamelCase	)
				model.eval()
				__lowercase			  =							model(_lowerCamelCase       ,labels=_lowerCamelCase	)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_labels)	)


	def   _UpperCAmelCase       (self	)							->							str:







				'''simple docstring'''





				__lowercase			  =							self.prepare_config_and_inputs()
				__lowercase  ,						__lowercase  ,						__lowercase			  =							config_and_inputs
				__lowercase			  =							{'''pixel_values''': pixel_values}
				return config, inputs_dict






@require_torch
class 							__lowercase    ( lowerCAmelCase__	, lowerCAmelCase__	, unittest.TestCase  ):







	'''simple docstring'''

	a      :			Union[str, Any]     =    (
	    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
	    if is_torch_available()
	    else ()
	)
	a      :			int     =    (
	    {
	        "feature-extraction": LevitModel,
	        "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	a      :			List[str]     =    False
	a      :			Dict     =    False
	a      :			List[Any]     =    False
	a      :			Tuple     =    False
	a      :			Optional[Any]     =    False


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				__lowercase			  =							LevitModelTester(self	)
				__lowercase			  =							ConfigTester(self       ,config_class=_lowerCamelCase       ,has_text_modality=_lowerCamelCase       ,hidden_size=37	)


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







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







				'''simple docstring'''





				return


	@unittest.skip(reason='''Levit does not use inputs_embeds'''	)
	def   _UpperCAmelCase       (self	)							->							List[str]:







				'''simple docstring'''





				pass


	@unittest.skip(reason='''Levit does not support input and output embeddings'''	)
	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				pass


	@unittest.skip(reason='''Levit does not output attentions'''	)
	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()

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

							__lowercase			  =							['''pixel_values''']
							self.assertListEqual(arg_names[:1]       ,_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





				def check_hidden_states_output(_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):
							__lowercase			  =							model_class(_lowerCamelCase	)
							model.to(_lowerCamelCase	)
							model.eval()

							with torch.no_grad():
										__lowercase			  =							model(**self._prepare_for_class(_lowerCamelCase       ,_lowerCamelCase	)	)

							__lowercase			  =							outputs.hidden_states

							__lowercase			  =							len(self.model_tester.depths	) + 1
							self.assertEqual(len(_lowerCamelCase	)       ,_lowerCamelCase	)

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

				for model_class in self.all_model_classes:
							__lowercase			  =							True
							check_hidden_states_output(_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							__lowercase			  =							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   _UpperCAmelCase       (self	)							->							List[str]:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase=False	)							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase			  =							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   _UpperCAmelCase       (self	)							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase	)


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







				'''simple docstring'''





				if not self.model_tester.is_training:
							return

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


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





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

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


	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()

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

													__lowercase			  =							model_class(_lowerCamelCase	)
													model.to(_lowerCamelCase	)
													model.train()

													__lowercase			  =							self._prepare_for_class(_lowerCamelCase       ,_lowerCamelCase       ,return_labels=_lowerCamelCase	)

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

													__lowercase			  =							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:
																__lowercase			  =							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   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowercase			  =							LevitModel.from_pretrained(_lowerCamelCase	)
							self.assertIsNotNone(_lowerCamelCase	)





def 				_lowerCAmelCase  (			):
			__lowercase			  =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
			return image






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







	'''simple docstring'''

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







				'''simple docstring'''





				return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)


	@slow
	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase			  =							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(
				    _lowerCamelCase	)

				__lowercase			  =							self.default_image_processor
				__lowercase			  =							prepare_img()
				__lowercase			  =							image_processor(images=_lowerCamelCase       ,return_tensors='''pt'''	).to(_lowerCamelCase	)

				# forward pass
				with torch.no_grad():
							__lowercase			  =							model(**_lowerCamelCase	)

				# verify the logits
				__lowercase			  =							torch.Size((1, 1000)	)
				self.assertEqual(outputs.logits.shape       ,_lowerCamelCase	)

				__lowercase			  =							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

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_SCREAMING_SNAKE_CASE   =      {'''configuration_focalnet''': ['''FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FocalNetConfig''']}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_SCREAMING_SNAKE_CASE   =      [
	    '''FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''FocalNetForImageClassification''',
	    '''FocalNetForMaskedImageModeling''',
	    '''FocalNetBackbone''',
	    '''FocalNetModel''',
	    '''FocalNetPreTrainedModel''',
	]

if TYPE_CHECKING:
	from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_focalnet import (
		    FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST,
		    FocalNetBackbone,
		    FocalNetForImageClassification,
		    FocalNetForMaskedImageModeling,
		    FocalNetModel,
		    FocalNetPreTrainedModel,
		)

else:
	import sys

	_SCREAMING_SNAKE_CASE   =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





