




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



					'''simple docstring'''





					def     __snake_case						(	self     :						Any)    ->							Union[str, Any]:
								A_									= self.config_class(**self.inputs_dict)
								self.parent.assertTrue(hasattr(_lowercase      ,       'hidden_sizes'))
								self.parent.assertTrue(hasattr(_lowercase      ,       'num_attention_heads'))





class   __UpperCAmelCase				:



					'''simple docstring'''





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



					def     __snake_case						(	self     :						List[str])    ->							Optional[int]:
								A_									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

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



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



					def     __snake_case						(	self     :						Union[str, Any])    ->							Any:
								A_									= self.prepare_config_and_inputs()
								A_		, A_		, A_									= config_and_inputs
								A_									= {'pixel_values': pixel_values}
								return config, inputs_dict





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



					'''simple docstring'''





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

					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False



					def     __snake_case						(	self     :						Optional[int])    ->							List[Any]:
								A_									= LevitModelTester(self)
								A_									= ConfigTester(self      ,       config_class=_lowercase      ,       has_text_modality=_lowercase      ,       hidden_size=37)



					def     __snake_case						(	self     :						Optional[int])    ->							Union[str, Any]:
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()



					def     __snake_case						(	self     :						List[str])    ->							int:
								return



					@unittest.skip(reason='Levit does not use inputs_embeds')
					def     __snake_case						(	self     :						Dict)    ->							Any:
								pass



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



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



					def     __snake_case						(	self     :						Any)    ->							str:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

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

											A_									= ['pixel_values']
											self.assertListEqual(arg_names[:1]      ,       _lowercase)



					def     __snake_case						(	self     :						Optional[Any])    ->							List[Any]:
								def check_hidden_states_output(_lowercase     :						int      ,       _lowercase     :						Tuple      ,       _lowercase     :						Union[str, Any]):
											A_									= model_class(_lowercase)
											model.to(_lowercase)
											model.eval()

											with torch.no_grad():
														A_									= model(**self._prepare_for_class(_lowercase      ,       _lowercase))

											A_									= outputs.hidden_states

											A_									= len(self.model_tester.depths) + 1
											self.assertEqual(len(_lowercase)      ,       _lowercase)

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

								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_									= True
											check_hidden_states_output(_lowercase      ,       _lowercase      ,       _lowercase)

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

											check_hidden_states_output(_lowercase      ,       _lowercase      ,       _lowercase)



					@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
					def     __snake_case						(	self     :						Union[str, Any])    ->							Tuple:
								pass



					def     __snake_case						(	self     :						int      ,       _lowercase     :						str      ,       _lowercase     :						Union[str, Any]      ,       _lowercase     :						Dict=False)    ->							Dict:
								A_									= super()._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)

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

								return inputs_dict



					def     __snake_case						(	self     :						Optional[Any])    ->							List[str]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase)



					def     __snake_case						(	self     :						int)    ->							Dict:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowercase)



					def     __snake_case						(	self     :						Optional[Any])    ->							Optional[Any]:
								if not self.model_tester.is_training:
											return

								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()
								A_									= True

								for model_class in self.all_model_classes:
											# LevitForImageClassificationWithTeacher supports inference-only
											if (
											    model_class in get_values(_lowercase)
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
														continue
											A_									= model_class(_lowercase)
											model.to(_lowercase)
											model.train()
											A_									= self._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)
											A_									= model(**_lowercase).loss
											loss.backward()



					def     __snake_case						(	self     :						str)    ->							Tuple:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()
								if not self.model_tester.is_training:
											return

								A_									= False
								A_									= True

								for model_class in self.all_model_classes:
											if model_class in get_values(_lowercase) or not model_class.supports_gradient_checkpointing:
														continue
											# LevitForImageClassificationWithTeacher supports inference-only
											if model_class.__name__ == "LevitForImageClassificationWithTeacher":
														continue
											A_									= model_class(_lowercase)
											model.gradient_checkpointing_enable()
											model.to(_lowercase)
											model.train()
											A_									= self._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)
											A_									= model(**_lowercase).loss
											loss.backward()



					def     __snake_case						(	self     :						List[str])    ->							Tuple:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								A_									= [
								    {'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(_lowercase),
											    ]
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
														continue

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

																	A_									= model_class(_lowercase)
																	model.to(_lowercase)
																	model.train()

																	A_									= self._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)

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

																	A_									= 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=_lowercase) as warning_list:
																				A_									= model(**_lowercase).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     :						str)    ->							Tuple:
								for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A_									= LevitModel.from_pretrained(_lowercase)
											self.assertIsNotNone(_lowercase)





def 			lowerCamelCase(							)		->		int:
			A_									= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
			return image






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



					'''simple docstring'''





					@cached_property
					def     __snake_case						(	self     :						Dict)    ->							int:
								return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])



					@slow
					def     __snake_case						(	self     :						List[Any])    ->							List[Any]:
								A_									= LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
								    _lowercase)

								A_									= self.default_image_processor
								A_									= prepare_img()
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(**_lowercase)

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

								A_									= torch.tensor([1.04_48, -0.37_45, -1.83_17]).to(_lowercase)

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










'''simple docstring'''
import os
from typing import List, Optional, Union

from ...image_processing_utils import BatchFeature
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
from ..auto import AutoTokenizer
class   __UpperCAmelCase				(     lowerCAmelCase				):



					'''simple docstring'''





					_UpperCamelCase							=		["""image_processor""", """tokenizer"""]
					_UpperCamelCase							=		"""BlipImageProcessor"""
					_UpperCamelCase							=		"""AutoTokenizer"""



					def __init__(	self     :						Union[str, Any]      ,       _lowercase     :						Union[str, Any]      ,       _lowercase     :						List[Any]      ,       _lowercase     :						List[str])    ->							Union[str, Any]:
								super().__init__(_lowercase      ,       _lowercase)

								# add QFormer tokenizer
								A_									= qformer_tokenizer



					def __call__(	self     :						Optional[int]      ,       _lowercase     :						ImageInput = None      ,       _lowercase     :						Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,       _lowercase     :						bool = True      ,       _lowercase     :						Union[bool, str, PaddingStrategy] = False      ,       _lowercase     :						Union[bool, str, TruncationStrategy] = None      ,       _lowercase     :						Optional[int] = None      ,       _lowercase     :						int = 0      ,       _lowercase     :						Optional[int] = None      ,       _lowercase     :						Optional[bool] = None      ,       _lowercase     :						bool = False      ,       _lowercase     :						bool = False      ,       _lowercase     :						bool = False      ,       _lowercase     :						bool = False      ,       _lowercase     :						bool = False      ,       _lowercase     :						bool = True      ,       _lowercase     :						Optional[Union[str, TensorType]] = None      ,       **_lowercase     :						List[Any]      ,       )    ->							BatchFeature:
								if images is None and text is None:
											raise ValueError('You have to specify at least images or text.')

								A_									= BatchFeature()

								if text is not None:
											A_									= self.tokenizer(
											    text=_lowercase      ,       add_special_tokens=_lowercase      ,       padding=_lowercase      ,       truncation=_lowercase      ,       max_length=_lowercase      ,       stride=_lowercase      ,       pad_to_multiple_of=_lowercase      ,       return_attention_mask=_lowercase      ,       return_overflowing_tokens=_lowercase      ,       return_special_tokens_mask=_lowercase      ,       return_offsets_mapping=_lowercase      ,       return_token_type_ids=_lowercase      ,       return_length=_lowercase      ,       verbose=_lowercase      ,       return_tensors=_lowercase      ,       **_lowercase      ,       )
											encoding.update(_lowercase)
											A_									= self.qformer_tokenizer(
											    text=_lowercase      ,       add_special_tokens=_lowercase      ,       padding=_lowercase      ,       truncation=_lowercase      ,       max_length=_lowercase      ,       stride=_lowercase      ,       pad_to_multiple_of=_lowercase      ,       return_attention_mask=_lowercase      ,       return_overflowing_tokens=_lowercase      ,       return_special_tokens_mask=_lowercase      ,       return_offsets_mapping=_lowercase      ,       return_token_type_ids=_lowercase      ,       return_length=_lowercase      ,       verbose=_lowercase      ,       return_tensors=_lowercase      ,       **_lowercase      ,       )
											A_									= qformer_text_encoding.pop('input_ids')
											A_									= qformer_text_encoding.pop('attention_mask')

								if images is not None:
											A_									= self.image_processor(_lowercase      ,       return_tensors=_lowercase)
											encoding.update(_lowercase)

								return encoding



					def     __snake_case						(	self     :						List[Any]      ,       *_lowercase     :						Optional[Any]      ,       **_lowercase     :						List[Any])    ->							Union[str, Any]:
								return self.tokenizer.batch_decode(*_lowercase      ,       **_lowercase)



					def     __snake_case						(	self     :						Optional[int]      ,       *_lowercase     :						List[Any]      ,       **_lowercase     :						List[str])    ->							str:
								return self.tokenizer.decode(*_lowercase      ,       **_lowercase)



					@property
					# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
					def     __snake_case						(	self     :						Any)    ->							Optional[int]:
								A_									= self.tokenizer.model_input_names
								A_									= self.image_processor.model_input_names
								return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))



					def     __snake_case						(	self     :						Optional[Any]      ,       _lowercase     :						Optional[int]      ,       **_lowercase     :						int)    ->							Tuple:
								if os.path.isfile(_lowercase):
											raise ValueError(F'Provided path ({save_directory}) should be a directory, not a file')
								os.makedirs(_lowercase      ,       exist_ok=_lowercase)
								A_									= os.path.join(_lowercase      ,       'qformer_tokenizer')
								self.qformer_tokenizer.save_pretrained(_lowercase)
								return super().save_pretrained(_lowercase      ,       **_lowercase)



					@classmethod
					def     __snake_case						(	cls     :						Dict      ,       _lowercase     :						Dict      ,       **_lowercase     :						int)    ->							Any:
								A_									= AutoTokenizer.from_pretrained(_lowercase      ,       subfolder='qformer_tokenizer')
								A_									= cls._get_arguments_from_pretrained(_lowercase      ,       **_lowercase)
								args.append(_lowercase)
								return cls(*_lowercase)




