




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__			(  lowercase		):






			'''simple docstring'''



			def       A_					(						self						):
							_lowerCamelCase  :    int					=					self.config_class(**self.inputs_dict						)
							self.parent.assertTrue(hasattr(A__						,   'hidden_sizes'						)						)
							self.parent.assertTrue(hasattr(A__						,   'num_attention_heads'						)						)






class lowerCAmelCase__			:






			'''simple docstring'''



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

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

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






			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					self.prepare_config_and_inputs()
							_lowerCamelCase  :    List[Any]					=					config_and_inputs
							_lowerCamelCase  :    List[Any]					=					{"""pixel_values""": pixel_values}
							return config, inputs_dict






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






			'''simple docstring'''



			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       A_					(						self						):
							_lowerCamelCase  :    Dict					=					LevitModelTester(self						)
							_lowerCamelCase  :    Optional[int]					=					ConfigTester(self						,   config_class=A__						,   has_text_modality=A__						,   hidden_size=37						)
			def       A_					(						self						):
							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       A_					(						self						):
							return
			@unittest.skip(reason='Levit does not use inputs_embeds'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='Levit does not support input and output embeddings'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='Levit does not output attentions'						)
			def       A_					(						self						):
							pass
			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					self.model_tester.prepare_config_and_inputs_for_common()

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

											_lowerCamelCase  :    Optional[Any]					=					["""pixel_values"""]
											self.assertListEqual(arg_names[:1]						,   A__						)
			def       A_					(						self						):
							def check_hidden_states_output(lowercase						,   lowercase						,   lowercase						):
											_lowerCamelCase  :    str					=					model_class(A__						)
											model.to(A__						)
											model.eval()

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

											_lowerCamelCase  :    List[Any]					=					outputs.hidden_states

											_lowerCamelCase  :    int					=					len(self.model_tester.depths						) + 1
											self.assertEqual(len(A__						)						,   A__						)

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

							_lowerCamelCase  :    str					=					self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											_lowerCamelCase  :    Union[str, Any]					=					True
											check_hidden_states_output(A__						,   A__						,   A__						)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											_lowerCamelCase  :    Dict					=					True

											check_hidden_states_output(A__						,   A__						,   A__						)
			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'						)
			def       A_					(						self						):
							pass
			def       A_					(						self						,   lowercase						,   lowercase						,   lowercase=False						):
							_lowerCamelCase  :    Tuple					=					super()._prepare_for_class(A__						,   A__						,   return_labels=A__						)

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

							return inputs_dict
			def       A_					(						self						):
							_lowerCamelCase  :    List[str]					=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A__						)
			def       A_					(						self						):
							_lowerCamelCase  :    int					=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*A__						)
			def       A_					(						self						):
							if not self.model_tester.is_training:
											return

							_lowerCamelCase  :    Tuple					=					self.model_tester.prepare_config_and_inputs_for_common()
							_lowerCamelCase  :    Dict					=					True

							for model_class in self.all_model_classes:
											# LevitForImageClassificationWithTeacher supports inference-only
											if (
											    model_class in get_values(A__						)
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
															continue
											_lowerCamelCase  :    Dict					=					model_class(A__						)
											model.to(A__						)
											model.train()
											_lowerCamelCase  :    Union[str, Any]					=					self._prepare_for_class(A__						,   A__						,   return_labels=A__						)
											_lowerCamelCase  :    List[Any]					=					model(**A__						).loss
											loss.backward()
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[int]					=					self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
											return

							_lowerCamelCase  :    Dict					=					False
							_lowerCamelCase  :    Any					=					True

							for model_class in self.all_model_classes:
											if model_class in get_values(A__						) or not model_class.supports_gradient_checkpointing:
															continue
											# LevitForImageClassificationWithTeacher supports inference-only
											if model_class.__name__ == "LevitForImageClassificationWithTeacher":
															continue
											_lowerCamelCase  :    List[Any]					=					model_class(A__						)
											model.gradient_checkpointing_enable()
											model.to(A__						)
											model.train()
											_lowerCamelCase  :    Optional[Any]					=					self._prepare_for_class(A__						,   A__						,   return_labels=A__						)
											_lowerCamelCase  :    Any					=					model(**A__						).loss
											loss.backward()
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[Any]					=					self.model_tester.prepare_config_and_inputs_for_common()

							_lowerCamelCase  :    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(A__						),
											    ]
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
															continue

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

																			_lowerCamelCase  :    List[Any]					=					model_class(A__						)
																			model.to(A__						)
																			model.train()

																			_lowerCamelCase  :    Optional[Any]					=					self._prepare_for_class(A__						,   A__						,   return_labels=A__						)

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

																			_lowerCamelCase  :    Dict					=					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=A__						) as warning_list:
																							_lowerCamelCase  :    Dict					=					model(**A__						).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       A_					(						self						):
							for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											_lowerCamelCase  :    Union[str, Any]					=					LevitModel.from_pretrained(A__						)
											self.assertIsNotNone(A__						)







def   _snake_case    (       ):
				_lowerCamelCase  :    Union[str, Any]					=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
				return image






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






			'''simple docstring'''



			@cached_property
			def       A_					(						self						):
							return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)






			@slow
			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
							    A__						)

							_lowerCamelCase  :    Optional[int]					=					self.default_image_processor
							_lowerCamelCase  :    List[Any]					=					prepare_img()
							_lowerCamelCase  :    Dict					=					image_processor(images=A__						,   return_tensors='pt'						).to(A__						)

							# forward pass
							with torch.no_grad():
											_lowerCamelCase  :    Optional[int]					=					model(**A__						)

							# verify the logits
							_lowerCamelCase  :    List[Any]					=					torch.Size((1, 1000)						)
							self.assertEqual(outputs.logits.shape						,   A__						)

							_lowerCamelCase  :    Any					=					torch.tensor([1.04_48, -0.37_45, -1.83_17]						).to(A__						)

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





"""simple docstring"""






from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxSeqaSeqConfigWithPast
from ...utils import logging


lowercase__  		=		logging.get_logger(__name__)

lowercase__  		=		{
    """google/umt5-small""": """https://huggingface.co/google/umt5-small/resolve/main/config.json""",
    # See all umt5 models at https://huggingface.co/models?filter=umt5
}






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    """umt5"""
			lowerCamelCase__   =    ["""past_key_values"""]
			def __init__(						self						,   lowercase=250112						,   lowercase=512						,   lowercase=64						,   lowercase=1024						,   lowercase=8						,   lowercase=None						,   lowercase=6						,   lowercase=32						,   lowercase=128						,   lowercase=0.1						,   lowercase=1E-6						,   lowercase=1.0						,   lowercase="gated-gelu"						,   lowercase=True						,   lowercase=True						,   lowercase="T5Tokenizer"						,   lowercase=True						,   lowercase=0						,   lowercase=1						,   lowercase=0						,   **lowercase						,   ):
							super().__init__(
							    is_encoder_decoder=lowercase						,   tokenizer_class=lowercase						,   tie_word_embeddings=lowercase						,   pad_token_id=lowercase						,   eos_token_id=lowercase						,   decoder_start_token_id=lowercase						,   **lowercase						,   )
							_lowerCamelCase  :    Union[str, Any]					=					vocab_size
							_lowerCamelCase  :    Optional[Any]					=					d_model
							_lowerCamelCase  :    Optional[Any]					=					d_kv
							_lowerCamelCase  :    Optional[int]					=					d_ff
							_lowerCamelCase  :    List[str]					=					num_layers
							_lowerCamelCase  :    Union[str, Any]					=					(
							    num_decoder_layers if num_decoder_layers is not None else self.num_layers
							)  # default = symmetry
							_lowerCamelCase  :    List[str]					=					num_heads
							_lowerCamelCase  :    int					=					relative_attention_num_buckets
							_lowerCamelCase  :    Union[str, Any]					=					relative_attention_max_distance
							_lowerCamelCase  :    int					=					dropout_rate
							_lowerCamelCase  :    List[Any]					=					layer_norm_epsilon
							_lowerCamelCase  :    Union[str, Any]					=					initializer_factor
							_lowerCamelCase  :    List[Any]					=					feed_forward_proj
							_lowerCamelCase  :    Dict					=					use_cache

							_lowerCamelCase  :    Dict					=					self.feed_forward_proj.split('-'						)
							_lowerCamelCase  :    List[str]					=					act_info[-1]
							_lowerCamelCase  :    int					=					act_info[0] == 'gated'

							if len(lowercase						) > 1 and act_info[0] != "gated" or len(lowercase						) > 2:
											raise ValueError(
											    F'''`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.'''
											    'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '
											    '\'gated-gelu\' or \'relu\''						)

							if feed_forward_proj == "gated-gelu":
											_lowerCamelCase  :    Optional[int]					=					'gelu_new'
			@property
			def       A_					(						self						):
							return self.d_model
			@property
			def       A_					(						self						):
							return self.num_heads






			@property
			def       A_					(						self						):
							return self.num_layers






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			@property
			# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					{
							    'input_ids': {0: 'batch', 1: 'encoder_sequence'},
							    'attention_mask': {0: 'batch', 1: 'encoder_sequence'},
							}
							if self.use_past:
											_lowerCamelCase  :    Optional[int]					=					'past_encoder_sequence + sequence'
											_lowerCamelCase  :    int					=					{0: 'batch'}
											_lowerCamelCase  :    List[str]					=					{0: 'batch', 1: 'past_decoder_sequence + sequence'}
							else:
											_lowerCamelCase  :    Dict					=					{0: 'batch', 1: 'decoder_sequence'}
											_lowerCamelCase  :    str					=					{0: 'batch', 1: 'decoder_sequence'}

							if self.use_past:
											self.fill_with_past_key_values_(lowercase						,   direction='inputs'						)

							return common_inputs
			@property
			# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
			def       A_					(						self						):
							return 13






			@property
			def       A_					(						self						):
							return 5E-4