






import functools
import gc
import inspect

import torch

from .imports import is_npu_available, is_xpu_available






def   a			(						*lowerCamelCase_				):






				'''simple docstring'''
				if not isinstance(lowerCamelCase_		,   lowerCamelCase_				):
								lowercase__    =			list(lowerCamelCase_				)
				for i in range(len(lowerCamelCase_				)				):
								lowercase__    =			None
				gc.collect()
				if is_xpu_available():
								torch.xpu.empty_cache()
				elif is_npu_available():
								torch.npu.empty_cache()
				else:
								torch.cuda.empty_cache()
				return objects






def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			[
				    '''CUDA out of memory.''',  # CUDA OOM
				    '''cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.''',  # CUDNN SNAFU
				    '''DefaultCPUAllocator: can\'t allocate memory''',  # CPU OOM
				]
				if isinstance(lowerCamelCase_		,   lowerCamelCase_				) and len(exception.args				) == 1:
								return any(err in exception.args[0] for err in _statements				)
				return False






def   a			(						lowerCamelCase_ = None		,   lowerCamelCase_ = 128				):






				'''simple docstring'''
				if function is None:
								return functools.partial(lowerCamelCase_		,   starting_batch_size=lowerCamelCase_				)

				lowercase__    =			starting_batch_size

				def decorator(*lowerCamelCase_		,   **lowerCamelCase_				):
								nonlocal batch_size
								gc.collect()
								if is_xpu_available():
												torch.xpu.empty_cache()
								elif is_npu_available():
												torch.npu.empty_cache()
								else:
												torch.cuda.empty_cache()
								lowercase__    =			list(inspect.signature(lowerCamelCase_				).parameters.keys()				)
								# Guard against user error
								if len(lowerCamelCase_				) < (len(lowerCamelCase_				) + 1):
												lowercase__    =			''', '''.join([F"""{arg}={value}""" for arg, value in zip(params[1:]		,   args[1:]				)]				)
												raise TypeError(
												    F"""Batch size was passed into `{function.__name__}` as the first argument when called."""
												    F"""Remove this as the decorator already does so: `{function.__name__}({arg_str})`"""				)
								while True:
												if batch_size == 0:
																raise RuntimeError('''No executable batch size found, reached zero.'''				)
												try:
																return function(lowerCamelCase_		,   *lowerCamelCase_		,   **lowerCamelCase_				)
												except Exception as e:
																if should_reduce_batch_size(lowerCamelCase_				):
																				gc.collect()
																				if is_xpu_available():
																								torch.xpu.empty_cache()
																				elif is_npu_available():
																								torch.npu.empty_cache()
																				else:
																								torch.cuda.empty_cache()
																				batch_size //= 2
																else:
																				raise

				return decorator












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       _UpperCAmelCase					(       A__	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    Any  ):

								'''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       _UpperCAmelCase					:

				"""simple docstring"""




				def __init__(     self						:    Tuple,  lowerCamelCase						:    str,  lowerCamelCase						:    str=13,  lowerCamelCase						:    Union[str, Any]=64,  lowerCamelCase						:    str=3,  lowerCamelCase						:    int=3,  lowerCamelCase						:    Dict=2,  lowerCamelCase						:    int=1,  lowerCamelCase						:    Optional[Any]=16,  lowerCamelCase						:    Dict=[128, 256, 384],  lowerCamelCase						:    Tuple=[4, 6, 8],  lowerCamelCase						:    Optional[Any]=[2, 3, 4],  lowerCamelCase						:    str=[16, 16, 16],  lowerCamelCase						:    Dict=0,  lowerCamelCase						:    List[str]=[2, 2, 2],  lowerCamelCase						:    str=[2, 2, 2],  lowerCamelCase						:    List[Any]=0.02,  lowerCamelCase						:    Any=True,  lowerCamelCase						:    Tuple=True,  lowerCamelCase						:    Optional[Any]=2,  ):

								'''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 				lowercase__   (     self						:    Tuple  ):

								'''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 				lowercase__   (     self						:    List[str]  ):

								'''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 				lowercase__   (     self						:    Any,  lowerCamelCase						:    List[Any],  lowerCamelCase						:    int,  lowerCamelCase						:    int  ):

								'''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 				lowercase__   (     self						:    Union[str, Any],  lowerCamelCase						:    int,  lowerCamelCase						:    List[Any],  lowerCamelCase						:    List[Any]  ):

								'''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 				lowercase__   (     self						:    int  ):

								'''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       _UpperCAmelCase					(       A__		,A__		,unittest.TestCase	):

				"""simple docstring"""




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

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								lowercase__    =			LevitModelTester(self  )
								lowercase__    =			ConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase,  hidden_size=37  )




				def 				lowercase__   (     self						:    str  ):

								'''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 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								return




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

								'''simple docstring'''
								pass




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

								'''simple docstring'''
								pass




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

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    List[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 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								def check_hidden_states_output(lowerCamelCase						:    Optional[int],  lowerCamelCase						:    str,  lowerCamelCase						:    Tuple  ):
												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 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    Union[str, Any],  lowerCamelCase						:    List[Any],  lowerCamelCase						:    Any,  lowerCamelCase						:    Any=False  ):

								'''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 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCamelCase  )




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

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

								'''simple docstring'''
								for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowercase__    =			LevitModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )






def   a			(						):






				'''simple docstring'''
				lowercase__    =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
				return image




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

				"""simple docstring"""




				@cached_property
				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )




				@slow
				def 				lowercase__   (     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, 1_000)  )
								self.assertEqual(outputs.logits.shape,  lowerCamelCase  )

								lowercase__    =			torch.tensor([1.0448, -0.3745, -1.8317]  ).to(lowerCamelCase  )

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




