





from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers.models.xglm.modeling_tf_xglm import (
         TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFXGLMForCausalLM,
         TFXGLMModel,
     )



@require_tf
class    _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''
 lowercase_		=			XGLMConfig
 lowercase_		=			{}
 lowercase_		=			"gelu"

 def __init__(self				:   Optional[Any]       , UpperCAmelCase_				:   Union[str, Any]       , UpperCAmelCase_				:   Optional[int]=14       , UpperCAmelCase_				:   int=7       , UpperCAmelCase_				:   str=True       , UpperCAmelCase_				:   Optional[int]=True       , UpperCAmelCase_				:   int=True       , UpperCAmelCase_				:   Dict=99       , UpperCAmelCase_				:   Optional[int]=32       , UpperCAmelCase_				:   str=2       , UpperCAmelCase_				:   List[str]=4       , UpperCAmelCase_				:   List[str]=37       , UpperCAmelCase_				:   int="gelu"       , UpperCAmelCase_				:   Tuple=0.1       , UpperCAmelCase_				:   Union[str, Any]=0.1       , UpperCAmelCase_				:   Any=512       , UpperCAmelCase_				:   List[str]=0.02       , )       ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:      str			  =parent
   lowerCamelCase__:      int			  =batch_size
   lowerCamelCase__:      List[str]			  =seq_length
   lowerCamelCase__:      int			  =is_training
   lowerCamelCase__:      int			  =use_input_mask
   lowerCamelCase__:      Tuple			  =use_labels
   lowerCamelCase__:      Any			  =vocab_size
   lowerCamelCase__:      Dict			  =d_model
   lowerCamelCase__:      Optional[int]			  =num_hidden_layers
   lowerCamelCase__:      Tuple			  =num_attention_heads
   lowerCamelCase__:      Dict			  =ffn_dim
   lowerCamelCase__:      Optional[int]			  =activation_function
   lowerCamelCase__:      str			  =activation_dropout
   lowerCamelCase__:      int			  =attention_dropout
   lowerCamelCase__:      Optional[Any]			  =max_position_embeddings
   lowerCamelCase__:      Optional[int]			  =initializer_range
   lowerCamelCase__:      str			  =None
   lowerCamelCase__:      List[Any]			  =0
   lowerCamelCase__:      str			  =2
   lowerCamelCase__:      Union[str, Any]			  =1

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



   '''simple docstring'''



   return XGLMConfig.from_pretrained("facebook/xglm-564M")

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any])       ->int:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =tf.clip_by_value(
       ids_tensor([self.batch_size, self.seq_length]       , self.vocab_size)       , clip_value_min=0       , clip_value_max=3)

   lowerCamelCase__:      str			  =None
   if self.use_input_mask:
     lowerCamelCase__:      Tuple			  =random_attention_mask([self.batch_size, self.seq_length])

   lowerCamelCase__:      Dict			  =self.get_config()

   lowerCamelCase__:      Optional[Any]			  =floats_tensor([self.num_hidden_layers, self.num_attention_heads]       , 2)

   return (
       config,
       input_ids,
       input_mask,
       head_mask,
   )

 def 							SCREAMING_SNAKE_CASE_					(self				:   Tuple)       ->int:



   '''simple docstring'''



   return XGLMConfig(
       vocab_size=self.vocab_size       , d_model=self.hidden_size       , num_layers=self.num_hidden_layers       , attention_heads=self.num_attention_heads       , ffn_dim=self.ffn_dim       , activation_function=self.activation_function       , activation_dropout=self.activation_dropout       , attention_dropout=self.attention_dropout       , max_position_embeddings=self.max_position_embeddings       , initializer_range=self.initializer_range       , use_cache=UpperCAmelCase_       , bos_token_id=self.bos_token_id       , eos_token_id=self.eos_token_id       , pad_token_id=self.pad_token_id       , return_dict=UpperCAmelCase_       , )







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



   '''simple docstring'''



   lowerCamelCase__:      str			  =self.prepare_config_and_inputs()

   (
       (
       lowerCamelCase__
   )  ,					(
       lowerCamelCase__
   )  ,					(
       lowerCamelCase__
   )  ,					(
       lowerCamelCase__
   )  ,					
   ):      Union[str, Any]			  =config_and_inputs

   lowerCamelCase__:      str			  ={
       "input_ids": input_ids,
       "head_mask": head_mask,
   }

   return config, inputs_dict



@require_tf
class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							unittest.TestCase    ):







 '''simple docstring'''
 lowercase_		=			(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
 lowercase_		=			(TFXGLMForCausalLM,) if is_tf_available() else ()
 lowercase_		=			(
     {"feature-extraction": TFXGLMModel, "text-generation": TFXGLMForCausalLM} if is_tf_available() else {}
 )
 lowercase_		=			False
 lowercase_		=			False
 lowercase_		=			False

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



   '''simple docstring'''



   lowerCamelCase__:      Tuple			  =TFXGLMModelTester(self)
   lowerCamelCase__:      str			  =ConfigTester(self       , config_class=UpperCAmelCase_       , n_embd=37)

 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->str:



   '''simple docstring'''



   self.config_tester.run_common_tests()

 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int])       ->Dict:



   '''simple docstring'''



   for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowerCamelCase__:      Dict			  =TFXGLMModel.from_pretrained(UpperCAmelCase_)
     self.assertIsNotNone(UpperCAmelCase_)







 @unittest.skip(reason="Currently, model embeddings are going to undergo a major refactor.")
 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any])       ->Dict:



   '''simple docstring'''



   super().test_resize_token_embeddings()



@require_tf
class    _SCREAMING_SNAKE_CASE						(	unittest.TestCase    ):







 '''simple docstring'''

 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   Any       , UpperCAmelCase_				:   str=True)       ->Any:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M")
   lowerCamelCase__:      Optional[int]			  =tf.convert_to_tensor([[2, 268, 9_865]]       , dtype=tf.intaa)  # The dog
   # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
   # fmt: off
   lowerCamelCase__:      Union[str, Any]			  =[2, 268, 9_865, 67, 11, 1_988, 57_252, 9_865, 5, 984, 67, 1_988, 213_838, 1_658, 53, 70_446, 33, 6_657, 278, 1_581]
   # fmt: on
   lowerCamelCase__:      List[str]			  =model.generate(UpperCAmelCase_       , do_sample=UpperCAmelCase_       , num_beams=1)
   if verify_outputs:
     self.assertListEqual(output_ids[0].numpy().tolist()       , UpperCAmelCase_)

 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      Optional[int]			  =XGLMTokenizer.from_pretrained("facebook/xglm-564M")
   lowerCamelCase__:      Tuple			  =TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M")

   tf.random.set_seed(0)
   lowerCamelCase__:      Union[str, Any]			  =tokenizer("Today is a nice day and"       , return_tensors="tf")
   lowerCamelCase__:      Dict			  =tokenized.input_ids
   # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
   with tf.device(":/CPU:0"):
     lowerCamelCase__:      str			  =model.generate(UpperCAmelCase_       , do_sample=UpperCAmelCase_       , seed=[7, 0])
   lowerCamelCase__:      str			  =tokenizer.decode(output_ids[0]       , skip_special_tokens=UpperCAmelCase_)

   lowerCamelCase__:      Union[str, Any]			  =(
       "Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due"
   )
   self.assertEqual(UpperCAmelCase_       , UpperCAmelCase_)







 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->List[str]:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M")
   lowerCamelCase__:      Tuple			  =XGLMTokenizer.from_pretrained("facebook/xglm-564M")

   lowerCamelCase__:      str			  ="left"

   # use different length sentences to test batching
   lowerCamelCase__:      List[Any]			  =[
       "This is an extremelly long sentence that only exists to test the ability of the model to cope with "
       "left-padding, such as in batched generation. The output for the sequence below should be the same "
       "regardless of whether left padding is applied or not. When",
       "Hello, my dog is a little",
   ]

   lowerCamelCase__:      Optional[Any]			  =tokenizer(UpperCAmelCase_       , return_tensors="tf"       , padding=UpperCAmelCase_)
   lowerCamelCase__:      Optional[int]			  =inputs["input_ids"]

   lowerCamelCase__:      str			  =model.generate(input_ids=UpperCAmelCase_       , attention_mask=inputs["attention_mask"]       , max_new_tokens=12)

   lowerCamelCase__:      Tuple			  =tokenizer(sentences[0]       , return_tensors="tf").input_ids
   lowerCamelCase__:      Union[str, Any]			  =model.generate(input_ids=UpperCAmelCase_       , max_new_tokens=12)

   lowerCamelCase__:      Optional[Any]			  =tokenizer(sentences[1]       , return_tensors="tf").input_ids
   lowerCamelCase__:      Union[str, Any]			  =model.generate(input_ids=UpperCAmelCase_       , max_new_tokens=12)

   lowerCamelCase__:      Optional[Any]			  =tokenizer.batch_decode(UpperCAmelCase_       , skip_special_tokens=UpperCAmelCase_)
   lowerCamelCase__:      Any			  =tokenizer.decode(output_non_padded[0]       , skip_special_tokens=UpperCAmelCase_)
   lowerCamelCase__:      Union[str, Any]			  =tokenizer.decode(output_padded[0]       , skip_special_tokens=UpperCAmelCase_)

   lowerCamelCase__:      int			  =[
       "This is an extremelly long sentence that only exists to test the ability of the model to cope with "
       "left-padding, such as in batched generation. The output for the sequence below should be the same "
       "regardless of whether left padding is applied or not. When left padding is applied, the sequence will be "
       "a single",
       "Hello, my dog is a little bit of a shy one, but he is very friendly",
   ]
   self.assertListEqual(UpperCAmelCase_       , UpperCAmelCase_)
   self.assertListEqual(UpperCAmelCase_       , [non_padded_sentence, padded_sentence])


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


			"""simple docstring"""






			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)
							self.parent.assertTrue(hasattr(lowerCAmelCase__      ,   '''hidden_sizes'''						)						)
							self.parent.assertTrue(hasattr(lowerCAmelCase__      ,   '''num_attention_heads'''						)						)




class    _UpperCamelCase      :


			"""simple docstring"""






			def __init__(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__=13      ,   lowerCAmelCase__=64      ,   lowerCAmelCase__=3      ,   lowerCAmelCase__=3      ,   lowerCAmelCase__=2      ,   lowerCAmelCase__=1      ,   lowerCAmelCase__=16      ,   lowerCAmelCase__=[1_28, 2_56, 3_84]      ,   lowerCAmelCase__=[4, 6, 8]      ,   lowerCAmelCase__=[2, 3, 4]      ,   lowerCAmelCase__=[16, 16, 16]      ,   lowerCAmelCase__=0      ,   lowerCAmelCase__=[2, 2, 2]      ,   lowerCAmelCase__=[2, 2, 2]      ,   lowerCAmelCase__=0.02      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=2      ,   )     ->					Tuple:

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

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

							'''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        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							LevitModel(config=lowerCAmelCase__						)
							model.to(lowerCAmelCase__						)
							model.eval()
							__lowercase 			=							model(lowerCAmelCase__						)
							__lowercase 			=							(self.image_size, self.image_size)
							__lowercase			,     __lowercase 			=							image_size[0], image_size[1]
							for _ in range(4						):
											__lowercase 			=							floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
											__lowercase 			=							floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
							self.parent.assertEqual(
							    result.last_hidden_state.shape      ,   (self.batch_size, ceil(height / 4						) * ceil(width / 4						), self.hidden_sizes[-1])      ,   )





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					str:

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Union[str, 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    _UpperCamelCase      (						_UpperCAmelCase						,_UpperCAmelCase						,unittest.TestCase ):


			"""simple docstring"""






			__a  : int			 =						(
			    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
			    if is_torch_available()
			    else ()
			)
			__a  : List[str]			 =						(
			    {
			        '''feature-extraction''': LevitModel,
			        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
			    }
			    if is_torch_available()
			    else {}
			)

			__a  : int			 =						False
			__a  : Dict			 =						False
			__a  : Optional[Any]			 =						False
			__a  : Optional[int]			 =						False
			__a  : Dict			 =						False





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

							'''simple docstring'''


							__lowercase 			=							LevitModelTester(self						)
							__lowercase 			=							ConfigTester(self      ,   config_class=lowerCAmelCase__      ,   has_text_modality=lowerCAmelCase__      ,   hidden_size=37						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

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

							'''simple docstring'''


							return





			@unittest.skip(reason='''Levit does not use inputs_embeds'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Union[str, Any]:

							'''simple docstring'''


							pass





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

							'''simple docstring'''


							pass





			@unittest.skip(reason='''Levit does not output attentions'''						)
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase 			=							['''pixel_values''']
											self.assertListEqual(arg_names[:1]      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						):
											__lowercase 			=							model_class(lowerCAmelCase__						)
											model.to(lowerCAmelCase__						)
											model.eval()

											with torch.no_grad():
															__lowercase 			=							model(**self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__						)						)

											__lowercase 			=							outputs.hidden_states

											__lowercase 			=							len(self.model_tester.depths						) + 1
											self.assertEqual(len(lowerCAmelCase__						)      ,   lowerCAmelCase__						)

											__lowercase 			=							(self.model_tester.image_size, self.model_tester.image_size)
											__lowercase			,     __lowercase 			=							image_size[0], image_size[1]
											for _ in range(4						):
															__lowercase 			=							floor(
															    (
															        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
															        / self.model_tester.stride
															    )
															    + 1						)
															__lowercase 			=							floor(
															    (
															        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
															        / self.model_tester.stride
															    )
															    + 1						)
											# verify the first hidden states (first block)
											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]						)      ,   [
											        height * width,
											        self.model_tester.hidden_sizes[0],
											    ]      ,   )

							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase 			=							True
											check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)

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

											check_hidden_states_output(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)





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

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__=False						)     ->					str:

							'''simple docstring'''


							__lowercase 			=							super()._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)

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

							return inputs_dict





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

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							if not self.model_tester.is_training:
											return

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

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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
											return

							__lowercase 			=							False
							__lowercase 			=							True

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





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase			,     __lowercase 			=							self.model_tester.prepare_config_and_inputs_for_common()

							__lowercase 			=							[
							    {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
							    {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
							    {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
							]

							for model_class in self.all_model_classes:
											if (
											    model_class
											    not in [
											        *get_values(lowerCAmelCase__						),
											    ]
											    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
											):
															continue

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

																			__lowercase 			=							model_class(lowerCAmelCase__						)
																			model.to(lowerCAmelCase__						)
																			model.train()

																			__lowercase 			=							self._prepare_for_class(lowerCAmelCase__      ,   lowerCAmelCase__      ,   return_labels=lowerCAmelCase__						)

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

																			__lowercase 			=							inputs['''labels'''].to(problem_type['''dtype''']						)

																			# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																			# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																			# they have the same size." which is a symptom something in wrong for the regression problem.
																			# See https://github.com/huggingface/transformers/issues/11780
																			with warnings.catch_warnings(record=lowerCAmelCase__						) as warning_list:
																							__lowercase 			=							model(**lowerCAmelCase__						).loss
																			for w in warning_list:
																							if "Using a target size that is different to the input size" in str(w.message						):
																											raise ValueError(
																											    F"Something is going wrong in the regression problem: intercepted {w.message}"						)

																			loss.backward()





			@slow
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 			=							LevitModel.from_pretrained(lowerCAmelCase__						)
											self.assertIsNotNone(lowerCAmelCase__						)





def 				UpperCAmelCase						(    ):







				"""simple docstring"""



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




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


			"""simple docstring"""






			@cached_property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)





			@slow
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
							    lowerCAmelCase__						)

							__lowercase 			=							self.default_image_processor
							__lowercase 			=							prepare_img()
							__lowercase 			=							image_processor(images=lowerCAmelCase__      ,   return_tensors='''pt'''						).to(lowerCAmelCase__						)

							# forward pass
							with torch.no_grad():
											__lowercase 			=							model(**lowerCAmelCase__						)

							# verify the logits
							__lowercase 			=							torch.Size((1, 10_00)						)
							self.assertEqual(outputs.logits.shape      ,   lowerCAmelCase__						)

							__lowercase 			=							torch.tensor([1.0448, -0.3745, -1.8317]						).to(lowerCAmelCase__						)

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