

'''simple docstring'''
import functools
import operator

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


lowerCamelCase :      Optional[int]					 =     logging.get_logger(__name__)

lowerCamelCase :      List[Any]					 =     {
    """asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}







class 							A__    (       UpperCAmelCase__  ):
  A__		 =				'sew-d'





  def __init__(		self      :	Dict							,					_a      :	Optional[Any]=32							,					_a      :	List[Any]=768							,					_a      :	int=12							,					_a      :	Dict=12							,					_a      :	Union[str, Any]=3072							,					_a      :	Dict=2							,					_a      :	List[Any]=512							,					_a      :	Union[str, Any]=256							,					_a      :	Optional[int]=True							,					_a      :	List[str]=True							,					_a      :	List[Any]=("p2c", "c2p")							,					_a      :	Optional[int]="layer_norm"							,					_a      :	List[Any]="gelu_python"							,					_a      :	int=0.1							,					_a      :	Optional[int]=0.1							,					_a      :	Optional[int]=0.1							,					_a      :	List[str]=0.0							,					_a      :	Any=0.1							,					_a      :	Dict=0.02							,					_a      :	str=1e-7							,					_a      :	Optional[int]=1e-5							,					_a      :	int="group"							,					_a      :	str="gelu"							,					_a      :	List[str]=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)							,					_a      :	int=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)							,					_a      :	List[Any]=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)							,					_a      :	List[Any]=False							,					_a      :	int=128							,					_a      :	List[Any]=16							,					_a      :	Tuple=True							,					_a      :	Any=0.05							,					_a      :	Tuple=10							,					_a      :	List[str]=2							,					_a      :	Any=0.0							,					_a      :	int=10							,					_a      :	Optional[Any]=0							,					_a      :	Optional[Any]="mean"							,					_a      :	List[Any]=False							,					_a      :	int=False							,					_a      :	str=256							,					_a      :	int=0							,					_a      :	str=1							,					_a      :	Any=2							,					**_a      :	Union[str, Any]							,					)	->    Optional[int]:





       '''simple docstring'''






       super().__init__(**lowercase_							,					pad_token_id=lowercase_							,					bos_token_id=lowercase_							,					eos_token_id=lowercase_ )
       _SCREAMING_SNAKE_CASE							    =hidden_size
       _SCREAMING_SNAKE_CASE							    =feat_extract_norm
       _SCREAMING_SNAKE_CASE							    =feat_extract_activation
       _SCREAMING_SNAKE_CASE							    =list(lowercase_ )
       _SCREAMING_SNAKE_CASE							    =list(lowercase_ )
       _SCREAMING_SNAKE_CASE							    =list(lowercase_ )
       _SCREAMING_SNAKE_CASE							    =conv_bias
       _SCREAMING_SNAKE_CASE							    =num_conv_pos_embeddings
       _SCREAMING_SNAKE_CASE							    =num_conv_pos_embedding_groups
       _SCREAMING_SNAKE_CASE							    =len(self.conv_dim )
       _SCREAMING_SNAKE_CASE							    =num_hidden_layers
       _SCREAMING_SNAKE_CASE							    =intermediate_size
       _SCREAMING_SNAKE_CASE							    =squeeze_factor
       _SCREAMING_SNAKE_CASE							    =max_position_embeddings
       _SCREAMING_SNAKE_CASE							    =position_buckets
       _SCREAMING_SNAKE_CASE							    =share_att_key
       _SCREAMING_SNAKE_CASE							    =relative_attention
       _SCREAMING_SNAKE_CASE							    =norm_rel_ebd
       _SCREAMING_SNAKE_CASE							    =list(lowercase_ )
       _SCREAMING_SNAKE_CASE							    =hidden_act
       _SCREAMING_SNAKE_CASE							    =num_attention_heads
       _SCREAMING_SNAKE_CASE							    =hidden_dropout
       _SCREAMING_SNAKE_CASE							    =attention_dropout
       _SCREAMING_SNAKE_CASE							    =activation_dropout
       _SCREAMING_SNAKE_CASE							    =feat_proj_dropout
       _SCREAMING_SNAKE_CASE							    =final_dropout
       _SCREAMING_SNAKE_CASE							    =layer_norm_eps
       _SCREAMING_SNAKE_CASE							    =feature_layer_norm_eps
       _SCREAMING_SNAKE_CASE							    =initializer_range
       _SCREAMING_SNAKE_CASE							    =vocab_size

       if (
           (len(self.conv_stride ) != self.num_feat_extract_layers)
           or (len(self.conv_kernel ) != self.num_feat_extract_layers)
           or (len(self.conv_dim ) != self.num_feat_extract_layers)
       ):
            raise ValueError(
                'Configuration for convolutional layers is incorrect.'
                'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
                f"but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)"
                f"= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`." )

       # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
       _SCREAMING_SNAKE_CASE							    =apply_spec_augment
       _SCREAMING_SNAKE_CASE							    =mask_time_prob
       _SCREAMING_SNAKE_CASE							    =mask_time_length
       _SCREAMING_SNAKE_CASE							    =mask_time_min_masks
       _SCREAMING_SNAKE_CASE							    =mask_feature_prob
       _SCREAMING_SNAKE_CASE							    =mask_feature_length
       _SCREAMING_SNAKE_CASE							    =mask_feature_min_masks

       # ctc loss
       _SCREAMING_SNAKE_CASE							    =ctc_loss_reduction
       _SCREAMING_SNAKE_CASE							    =ctc_zero_infinity

       # sequence classification
       _SCREAMING_SNAKE_CASE							    =use_weighted_layer_sum
       _SCREAMING_SNAKE_CASE							    =classifier_proj_size





  @property
  def 						A  (		self      :	Any )	->    List[Any]:





       '''simple docstring'''






       return functools.reduce(operator.mul							,					self.conv_stride							,					1 )








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






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.config_class(**self.inputs_dict)
          self.parent.assertTrue(hasattr(lowercase_						,	'''hidden_sizes'''))
          self.parent.assertTrue(hasattr(lowercase_						,	'''num_attention_heads'''))




class 							lowerCAmelCase__				:






      '''simple docstring'''

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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		parent
          SCREAMING_SNAKE_CASE_      :  Any    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		image_size
          SCREAMING_SNAKE_CASE_      :  int    						=		num_channels
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		kernel_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		stride
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		padding
          SCREAMING_SNAKE_CASE_      :  int    						=		hidden_sizes
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		num_attention_heads
          SCREAMING_SNAKE_CASE_      :  int    						=		depths
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		key_dim
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		drop_path_rate
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		patch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		attention_ratio
          SCREAMING_SNAKE_CASE_      :  str    						=		mlp_ratio
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		initializer_range
          SCREAMING_SNAKE_CASE_      :  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],
          ]
          SCREAMING_SNAKE_CASE_      :  Any    						=		is_training
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		use_labels
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		num_labels
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		initializer_range
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.get_config()
          return config, pixel_values, labels
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[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     :  Union[str, Any]						,	lowercase_     :  Any						,	lowercase_     :  int						,	lowercase_     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		LevitModel(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		model(lowercase_)
          SCREAMING_SNAKE_CASE_      :  Any    						=		(self.image_size, self.image_size)
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Tuple    						=		image_size[0], image_size[1]
          for _ in range(4):
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1)
              SCREAMING_SNAKE_CASE_      :  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 _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]						,	lowercase_     :  int						,	lowercase_     :  Union[str, Any]						,	lowercase_     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		self.num_labels
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		LevitForImageClassification(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model(lowercase_						,	labels=lowercase_)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_labels))



      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.prepare_config_and_inputs()
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		config_and_inputs
          SCREAMING_SNAKE_CASE_      :  int    						=		{'''pixel_values''': pixel_values}
          return config, inputs_dict




@require_torch
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		UpperCAmelCase__				,		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 _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		LevitModelTester(self)
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		ConfigTester(self						,	config_class=lowercase_						,	has_text_modality=lowercase_						,	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     :  Union[str, Any]):




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




          '''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     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      :  Any    						=		model_class(lowercase_)
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		inspect.signature(model.forward)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE_      :  Dict    						=		[*signature.parameters.keys()]

              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		['''pixel_values''']
              self.assertListEqual(arg_names[:1]						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          def check_hidden_states_output(lowercase_     :  List[str]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  str):
              SCREAMING_SNAKE_CASE_      :  str    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()

              with torch.no_grad():
                  SCREAMING_SNAKE_CASE_      :  Tuple    						=		model(**self._prepare_for_class(lowercase_						,	lowercase_))

              SCREAMING_SNAKE_CASE_      :  str    						=		outputs.hidden_states

              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		len(self.model_tester.depths) + 1
              self.assertEqual(len(lowercase_)						,	lowercase_)

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

          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs_for_common()

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

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              SCREAMING_SNAKE_CASE_      :  Tuple    						=		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 _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          pass
      def _SCREAMING_SNAKE_CASE (						self     :  int						,	lowercase_     :  Optional[Any]						,	lowercase_     :  Optional[int]						,	lowercase_     :  Tuple=False):




          '''simple docstring'''


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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          if not self.model_tester.is_training:
              return

          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		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
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.train()
              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self._prepare_for_class(lowercase_						,	lowercase_						,	return_labels=lowercase_)
              SCREAMING_SNAKE_CASE_      :  Dict    						=		model(**lowercase_).loss
              loss.backward()
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


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

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		False
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		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
              SCREAMING_SNAKE_CASE_      :  List[str]    						=		model_class(lowercase_)
              model.gradient_checkpointing_enable()
              model.to(lowercase_)
              model.train()
              SCREAMING_SNAKE_CASE_      :  Dict    						=		self._prepare_for_class(lowercase_						,	lowercase_						,	return_labels=lowercase_)
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model(**lowercase_).loss
              loss.backward()
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  str    						=		self.model_tester.prepare_config_and_inputs_for_common()

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

                      SCREAMING_SNAKE_CASE_      :  str    						=		model_class(lowercase_)
                      model.to(lowercase_)
                      model.train()

                      SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self._prepare_for_class(lowercase_						,	lowercase_						,	return_labels=lowercase_)

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

                      SCREAMING_SNAKE_CASE_      :  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=lowercase_) as warning_list:
                          SCREAMING_SNAKE_CASE_      :  int    						=		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 _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		LevitModel.from_pretrained(lowercase_)
              self.assertIsNotNone(lowercase_)



def 					_A			() ->       Union[str, Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  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 _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])



      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
              lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.default_image_processor
          SCREAMING_SNAKE_CASE_      :  str    						=		prepare_img()
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processor(images=lowercase_						,	return_tensors='''pt''').to(lowercase_)

          # forward pass
          with torch.no_grad():
              SCREAMING_SNAKE_CASE_      :  Any    						=		model(**lowercase_)

          # verify the logits
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		torch.Size((1, 1000))
          self.assertEqual(outputs.logits.shape						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		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))


