






"""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			(	snake_case_      ):


 def _lowercase	(     self		:						Dict							)					->       int:
   _a  :       List[Any]             =	self.config_class(**self.inputs_dict							)
   self.parent.assertTrue(hasattr(UpperCAmelCase__							,						"""hidden_sizes"""							)							)
   self.parent.assertTrue(hasattr(UpperCAmelCase__							,						"""num_attention_heads"""							)							)







class        UpperCamelCase			:


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


 def _lowercase	(     self		:						int							)					->       List[str]:
   _a  :       str             =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

   _a  :       List[Any]             =	None
   if self.use_labels:
     _a  :       Union[str, Any]             =	ids_tensor([self.batch_size]							,						self.num_labels							)

   _a  :       List[Any]             =	self.get_config()
   return config, pixel_values, labels


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







 def _lowercase	(     self		:						Tuple							)					->       Union[str, Any]:
   _a  :       Tuple             =	self.prepare_config_and_inputs()
   _a      ,  _a      ,  _a  :       Union[str, Any]             =	config_and_inputs
   _a  :       Dict             =	{"""pixel_values""": pixel_values}
   return config, inputs_dict







@require_torch
class        UpperCamelCase			(	snake_case_		,     snake_case_		,     unittest.TestCase      ):
 UpperCamelCase					:       int			=					(
     (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
     if is_torch_available()
     else ()
 )
 UpperCamelCase					:       int			=					(
     {
         '''feature-extraction''': LevitModel,
         '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 UpperCamelCase					:       List[str]			=					False
 UpperCamelCase					:       str			=					False
 UpperCamelCase					:       List[Any]			=					False
 UpperCamelCase					:       Any			=					False
 UpperCamelCase					:       List[Any]			=					False


 def _lowercase	(     self		:						Optional[Any]							)					->       List[str]:
   _a  :       List[Any]             =	LevitModelTester(self							)
   _a  :       str             =	ConfigTester(self							,						config_class=UpperCAmelCase__							,						has_text_modality=UpperCAmelCase__							,						hidden_size=37							)


 def _lowercase	(     self		:						int							)					->       Optional[int]:
   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		:						Optional[Any]							)					->       Optional[Any]:
   return


 @unittest.skip(reason="""Levit does not use inputs_embeds"""							)
 def _lowercase	(     self		:						Tuple							)					->       str:
   pass


 @unittest.skip(reason="""Levit does not support input and output embeddings"""							)
 def _lowercase	(     self		:						Tuple							)					->       int:
   pass


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


 def _lowercase	(     self		:						Dict							)					->       List[str]:
   _a      ,  _a  :       List[Any]             =	self.model_tester.prepare_config_and_inputs_for_common()

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

     _a  :       List[Any]             =	["""pixel_values"""]
     self.assertListEqual(arg_names[:1]							,						UpperCAmelCase__							)


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

     with torch.no_grad():
       _a  :       Dict             =	model(**self._prepare_for_class(UpperCAmelCase__							,						UpperCAmelCase__							)							)

     _a  :       Any             =	outputs.hidden_states

     _a  :       Any             =	len(self.model_tester.depths							) + 1
     self.assertEqual(len(UpperCAmelCase__							)							,						UpperCAmelCase__							)

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

   for model_class in self.all_model_classes:
     _a  :       Optional[int]             =	True
     check_hidden_states_output(UpperCAmelCase__							,						UpperCAmelCase__							,						UpperCAmelCase__							)

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


 def _lowercase	(     self		:						Optional[Any]							,						UpperCAmelCase__		:						List[str]							,						UpperCAmelCase__		:						Optional[int]							,						UpperCAmelCase__		:						List[Any]=False							)					->       List[str]:
   _a  :       Any             =	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 _lowercase	(     self		:						Dict							)					->       Any:
   _a  :       Optional[int]             =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCAmelCase__							)


 def _lowercase	(     self		:						Optional[int]							)					->       Tuple:
   _a  :       Dict             =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__							)


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

   _a      ,  _a  :       List[Any]             =	self.model_tester.prepare_config_and_inputs_for_common()
   _a  :       Union[str, Any]             =	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
     _a  :       str             =	model_class(UpperCAmelCase__							)
     model.to(UpperCAmelCase__							)
     model.train()
     _a  :       Tuple             =	self._prepare_for_class(UpperCAmelCase__							,						UpperCAmelCase__							,						return_labels=UpperCAmelCase__							)
     _a  :       int             =	model(**UpperCAmelCase__							).loss
     loss.backward()


 def _lowercase	(     self		:						Any							)					->       List[Any]:
   _a      ,  _a  :       Dict             =	self.model_tester.prepare_config_and_inputs_for_common()
   if not self.model_tester.is_training:
     return

   _a  :       List[Any]             =	False
   _a  :       str             =	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
     _a  :       str             =	model_class(UpperCAmelCase__							)
     model.gradient_checkpointing_enable()
     model.to(UpperCAmelCase__							)
     model.train()
     _a  :       Union[str, Any]             =	self._prepare_for_class(UpperCAmelCase__							,						UpperCAmelCase__							,						return_labels=UpperCAmelCase__							)
     _a  :       Any             =	model(**UpperCAmelCase__							).loss
     loss.backward()


 def _lowercase	(     self		:						Optional[Any]							)					->       Tuple:
   _a      ,  _a  :       str             =	self.model_tester.prepare_config_and_inputs_for_common()

   _a  :       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(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']}"""							):
         _a  :       Optional[int]             =	problem_type["""title"""]
         _a  :       str             =	problem_type["""num_labels"""]

         _a  :       List[str]             =	model_class(UpperCAmelCase__							)
         model.to(UpperCAmelCase__							)
         model.train()

         _a  :       List[str]             =	self._prepare_for_class(UpperCAmelCase__							,						UpperCAmelCase__							,						return_labels=UpperCAmelCase__							)

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

         _a  :       Optional[Any]             =	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:
           _a  :       Optional[int]             =	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 _lowercase	(     self		:						Optional[Any]							)					->       int:
   for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     _a  :       Optional[int]             =	LevitModel.from_pretrained(UpperCAmelCase__							)
     self.assertIsNotNone(UpperCAmelCase__							)







def 			lowerCAmelCase__     (     ):



  '''simple docstring'''
  _a  :       Tuple             =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
  return image






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


 @cached_property
 def _lowercase	(     self		:						List[str]							)					->       List[str]:
   return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)







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

   _a  :       Optional[int]             =	self.default_image_processor
   _a  :       int             =	prepare_img()
   _a  :       Dict             =	image_processor(images=UpperCAmelCase__							,						return_tensors="""pt"""							).to(UpperCAmelCase__							)

   # forward pass
   with torch.no_grad():
     _a  :       Union[str, Any]             =	model(**UpperCAmelCase__							)

   # verify the logits
   _a  :       int             =	torch.Size((1, 1000)							)
   self.assertEqual(outputs.logits.shape							,						UpperCAmelCase__							)

   _a  :       List[Any]             =	torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]							).to(UpperCAmelCase__							)

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









"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_snake_case          =   {
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _snake_case          =   [
     'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'AdaptiveEmbedding',
     'TransfoXLForSequenceClassification',
     'TransfoXLLMHeadModel',
     'TransfoXLModel',
     'TransfoXLPreTrainedModel',
     'load_tf_weights_in_transfo_xl',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _snake_case          =   [
     'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFAdaptiveEmbedding',
     'TFTransfoXLForSequenceClassification',
     'TFTransfoXLLMHeadModel',
     'TFTransfoXLMainLayer',
     'TFTransfoXLModel',
     'TFTransfoXLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_transfo_xl import (
      TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      AdaptiveEmbedding,
      TransfoXLForSequenceClassification,
      TransfoXLLMHeadModel,
      TransfoXLModel,
      TransfoXLPreTrainedModel,
      load_tf_weights_in_transfo_xl,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_transfo_xl import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAdaptiveEmbedding,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLMainLayer,
      TFTransfoXLModel,
      TFTransfoXLPreTrainedModel,
  )

else:
 import sys

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

