


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 	_a							(      UpperCamelCase__      ):

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





									"""simple docstring"""







									lowercase__						=				self.config_class(**self.inputs_dict							)
									self.parent.assertTrue(hasattr(UpperCamelCase_   ,						'''hidden_sizes'''							)							)
									self.parent.assertTrue(hasattr(UpperCamelCase_   ,						'''num_attention_heads'''							)							)


class 	_a							:

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





									"""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 				lowerCamelCase_			(     self:     str							)      ->       Union[str, 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 				lowerCamelCase_			(     self:     Tuple							)      ->       Optional[Any]:





									"""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 				lowerCamelCase_			(     self:     Union[str, Any]   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     List[str]   ,						UpperCamelCase_:     List[str]							)      ->       Union[str, Any]:





									"""simple docstring"""







									lowercase__						=				LevitModel(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__						=				model(UpperCamelCase_							)
									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 				lowerCamelCase_			(     self:     List[Any]   ,						UpperCamelCase_:     List[Any]   ,						UpperCamelCase_:     str   ,						UpperCamelCase_:     List[str]							)      ->       str:





									"""simple docstring"""







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


							def 				lowerCamelCase_			(     self:     str							)      ->       List[Any]:





									"""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 	_a							(      UpperCamelCase__					,     UpperCamelCase__					,     unittest.TestCase      ):
							_lowercase     :      str  				=			(
							    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
							    if is_torch_available()
							    else ()
							)
							_lowercase     :      Tuple  				=			(
							    {
							        '''feature-extraction''': LevitModel,
							        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
							    }
							    if is_torch_available()
							    else {}
							)

							_lowercase     :      Any  				=			False
							_lowercase     :      Union[str, Any]  				=			False
							_lowercase     :      Tuple  				=			False
							_lowercase     :      Dict  				=			False
							_lowercase     :      Any  				=			False

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





									"""simple docstring"""







									lowercase__						=				LevitModelTester(self							)
									lowercase__						=				ConfigTester(self   ,						config_class=UpperCamelCase_   ,						has_text_modality=UpperCamelCase_   ,						hidden_size=37							)

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





									"""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 				lowerCamelCase_			(     self:     Any							)      ->       Dict:





									"""simple docstring"""







									return

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





									"""simple docstring"""







									pass

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





									"""simple docstring"""







									pass

							@unittest.skip(reason='''Levit does not output attentions'''							)
							def 				lowerCamelCase_			(     self:     Optional[int]							)      ->       Union[str, Any]:





									"""simple docstring"""







									pass

							def 				lowerCamelCase_			(     self:     Tuple							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											lowercase__						=				model_class(UpperCamelCase_							)
											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]   ,						UpperCamelCase_							)

							def 				lowerCamelCase_			(     self:     Optional[int]							)      ->       Tuple:





									"""simple docstring"""







									def check_hidden_states_output(UpperCamelCase_:     int   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     str							):
											lowercase__						=				model_class(UpperCamelCase_							)
											model.to(UpperCamelCase_							)
											model.eval()

											with torch.no_grad():
													lowercase__						=				model(**self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_							)							)

											lowercase__						=				outputs.hidden_states

											lowercase__						=				len(self.model_tester.depths							) + 1
											self.assertEqual(len(UpperCamelCase_							)   ,						UpperCamelCase_							)

											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(UpperCamelCase_   ,						UpperCamelCase_   ,						UpperCamelCase_							)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowercase__						=				True

											check_hidden_states_output(UpperCamelCase_   ,						UpperCamelCase_   ,						UpperCamelCase_							)

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





									"""simple docstring"""







									pass

							def 				lowerCamelCase_			(     self:     Union[str, Any]   ,						UpperCamelCase_:     str   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     Optional[int]=False							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__						=				super()._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)

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

									return inputs_dict

							def 				lowerCamelCase_			(     self:     Any							)      ->       int:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCamelCase_							)

							def 				lowerCamelCase_			(     self:     Tuple							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_							)

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





									"""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(UpperCamelCase_							)
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
													continue
											lowercase__						=				model_class(UpperCamelCase_							)
											model.to(UpperCamelCase_							)
											model.train()
											lowercase__						=				self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)
											lowercase__						=				model(**UpperCamelCase_							).loss
											loss.backward()

							def 				lowerCamelCase_			(     self:     Optional[Any]							)      ->       List[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(UpperCamelCase_							) or not model_class.supports_gradient_checkpointing:
													continue
											# LevitForImageClassificationWithTeacher supports inference-only
											if model_class.__name__ == "LevitForImageClassificationWithTeacher":
													continue
											lowercase__						=				model_class(UpperCamelCase_							)
											model.gradient_checkpointing_enable()
											model.to(UpperCamelCase_							)
											model.train()
											lowercase__						=				self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)
											lowercase__						=				model(**UpperCamelCase_							).loss
											loss.backward()

							def 				lowerCamelCase_			(     self:     List[Any]							)      ->       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(UpperCamelCase_							),
											    ]
											    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(UpperCamelCase_							)
															model.to(UpperCamelCase_							)
															model.train()

															lowercase__						=				self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)

															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=UpperCamelCase_							) as warning_list:
																	lowercase__						=				model(**UpperCamelCase_							).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:     Dict							)      ->       str:





									"""simple docstring"""







									for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowercase__						=				LevitModel.from_pretrained(UpperCamelCase_							)
											self.assertIsNotNone(UpperCamelCase_							)
def       _a			(				):


		"""simple docstring"""




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


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

							@cached_property
							def 				lowerCamelCase_			(     self:     Any							)      ->       Dict:





									"""simple docstring"""







									return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)


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





									"""simple docstring"""







									lowercase__						=				LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
									    UpperCamelCase_							)

									lowercase__						=				self.default_image_processor
									lowercase__						=				prepare_img()
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(**UpperCamelCase_							)

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

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

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






import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase	=							logging.get_logger(__name__)

lowerCAmelCase	=							{
    'microsoft/git-base': 'https://huggingface.co/microsoft/git-base/resolve/main/config.json',
}


class 	_a							(      UpperCamelCase__      ):
							_lowercase     :      int  				=			'''git_vision_model'''

							def __init__(							self:     Tuple   ,						UpperCamelCase_:     Optional[int]=768   ,						UpperCamelCase_:     Optional[int]=3_072   ,						UpperCamelCase_:     Optional[int]=12   ,						UpperCamelCase_:     Union[str, Any]=12   ,						UpperCamelCase_:     Any=3   ,						UpperCamelCase_:     str=224   ,						UpperCamelCase_:     int=16   ,						UpperCamelCase_:     Any="quick_gelu"   ,						UpperCamelCase_:     Union[str, Any]=1E-5   ,						UpperCamelCase_:     Tuple=0.0   ,						UpperCamelCase_:     Tuple=0.02   ,						**UpperCamelCase_:     str   ,						)      ->       Optional[int]:





									"""simple docstring"""







									super().__init__(**UpperCamelCase_							)

									lowercase__						=				hidden_size
									lowercase__						=				intermediate_size
									lowercase__						=				num_hidden_layers
									lowercase__						=				num_attention_heads
									lowercase__						=				num_channels
									lowercase__						=				patch_size
									lowercase__						=				image_size
									lowercase__						=				initializer_range
									lowercase__						=				attention_dropout
									lowercase__						=				layer_norm_eps
									lowercase__						=				hidden_act


							@classmethod
							def 				lowerCamelCase_			(							cls:     Optional[Any]   ,						UpperCamelCase_:     Union[str, os.PathLike]   ,						**UpperCamelCase_:     List[Any]							)      ->       "PretrainedConfig":





									"""simple docstring"""







									cls._set_token_in_kwargs(UpperCamelCase_							)

									lowercase__					,		lowercase__						=				cls.get_config_dict(UpperCamelCase_   ,						**UpperCamelCase_							)

									# get the vision config dict if we are loading from GITConfig
									if config_dict.get('''model_type'''							) == "git":
											lowercase__						=				config_dict['''vision_config''']

									if "model_type" in config_dict and hasattr(cls   ,						'''model_type'''							) and config_dict["model_type"] != cls.model_type:
											logger.warning(
											    f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
											    f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'							)

									return cls.from_dict(UpperCamelCase_   ,						**UpperCamelCase_							)


class 	_a							(      UpperCamelCase__      ):
							_lowercase     :      Optional[int]  				=			'''git'''

							def __init__(							self:     Optional[Any]   ,						UpperCamelCase_:     Optional[Any]=None   ,						UpperCamelCase_:     List[str]=30_522   ,						UpperCamelCase_:     List[Any]=768   ,						UpperCamelCase_:     List[Any]=6   ,						UpperCamelCase_:     Union[str, Any]=12   ,						UpperCamelCase_:     Any=3_072   ,						UpperCamelCase_:     Any="gelu"   ,						UpperCamelCase_:     List[Any]=0.1   ,						UpperCamelCase_:     Dict=0.1   ,						UpperCamelCase_:     str=1_024   ,						UpperCamelCase_:     Any=0.02   ,						UpperCamelCase_:     str=1E-1_2   ,						UpperCamelCase_:     Optional[int]=0   ,						UpperCamelCase_:     Optional[Any]="absolute"   ,						UpperCamelCase_:     Optional[int]=True   ,						UpperCamelCase_:     List[Any]=False   ,						UpperCamelCase_:     List[Any]=101   ,						UpperCamelCase_:     int=102   ,						UpperCamelCase_:     List[str]=None   ,						**UpperCamelCase_:     int   ,						)      ->       Union[str, Any]:





									"""simple docstring"""







									super().__init__(bos_token_id=UpperCamelCase_   ,						eos_token_id=UpperCamelCase_   ,						pad_token_id=UpperCamelCase_   ,						**UpperCamelCase_							)

									if vision_config is None:
											lowercase__						=				{}
											logger.info('''vision_config is None. initializing the GitVisionConfig with default values.'''							)

									lowercase__						=				GitVisionConfig(**UpperCamelCase_							)
									lowercase__						=				vocab_size
									lowercase__						=				hidden_size
									lowercase__						=				num_hidden_layers
									lowercase__						=				num_attention_heads
									lowercase__						=				hidden_act
									lowercase__						=				intermediate_size
									lowercase__						=				hidden_dropout_prob
									lowercase__						=				attention_probs_dropout_prob
									lowercase__						=				max_position_embeddings
									lowercase__						=				initializer_range
									lowercase__						=				layer_norm_eps
									lowercase__						=				position_embedding_type
									lowercase__						=				use_cache
									lowercase__						=				tie_word_embeddings
									lowercase__						=				num_image_with_embedding

									lowercase__						=				bos_token_id
									lowercase__						=				eos_token_id


							def 				lowerCamelCase_			(							self:     Dict							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				copy.deepcopy(self.__dict__							)
									lowercase__						=				self.vision_config.to_dict()
									lowercase__						=				self.__class__.model_type
									return output


