"""simple docstring"""







import argparse
import os
import re

import packaging.version


__SCREAMING_SNAKE_CASE    	="examples/"
__SCREAMING_SNAKE_CASE    	={
    "examples": (re.compile(r"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), "check_min_version(\"VERSION\")\n"),
    "init": (re.compile(r"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), "__version__ = \"VERSION\"\n"),
    "setup": (re.compile(r"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), r"\1version=\"VERSION\","),
    "doc": (re.compile(r"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), "release = \"VERSION\"\n"),
}
__SCREAMING_SNAKE_CASE    	={
    "init": "src/transformers/__init__.py",
    "setup": "setup.py",
}
__SCREAMING_SNAKE_CASE    	="README.md"



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     Dict     ,			__SCREAMING_SNAKE_CASE							:     Dict     ,			__SCREAMING_SNAKE_CASE							:     Optional[int]      ):
     with open(__SCREAMING_SNAKE_CASE     ,			'r'     ,			encoding='utf-8'     ,			newline='\n'      ) as f:
          lowercase_	:				Tuple													=	f.read()
     lowercase_							,  lowercase_	:				List[str]													=	REPLACE_PATTERNS[pattern]
     lowercase_	:				int													=	replace.replace('VERSION'     ,			__SCREAMING_SNAKE_CASE      )
     lowercase_	:				Tuple													=	re_pattern.sub(__SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE      )
     with open(__SCREAMING_SNAKE_CASE     ,			'w'     ,			encoding='utf-8'     ,			newline='\n'      ) as f:
          f.write(__SCREAMING_SNAKE_CASE      )



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     Tuple      ):
     for folder, directories, fnames in os.walk(__SCREAMING_SNAKE_CASE      ):
          # Removing some of the folders with non-actively maintained examples from the walk
          if "research_projects" in directories:
               directories.remove('research_projects'      )
          if "legacy" in directories:
               directories.remove('legacy'      )
          for fname in fnames:
               if fname.endswith('.py'      ):
                    update_version_in_file(os.path.join(__SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE      )     ,			__SCREAMING_SNAKE_CASE     ,			pattern='examples'      )



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     Optional[int]=False      ):
     for pattern, fname in REPLACE_FILES.items():
          update_version_in_file(__SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE      )
     if not patch:
          update_version_in_examples(__SCREAMING_SNAKE_CASE      )



def 			lowercase__(       ):
     lowercase_	:				Optional[Any]													=	'🤗 Transformers currently provides the following architectures'
     lowercase_	:				Union[str, Any]													=	'1. Want to contribute a new model?'
     with open(__SCREAMING_SNAKE_CASE     ,			'r'     ,			encoding='utf-8'     ,			newline='\n'      ) as f:
          lowercase_	:				Optional[Any]													=	f.readlines()

     # Find the start of the list.
     lowercase_	:				int													=	0
     while not lines[start_index].startswith(_start_prompt      ):
          start_index += 1
     start_index += 1

     lowercase_	:				Tuple													=	start_index
     # Update the lines in the model list.
     while not lines[index].startswith(_end_prompt      ):
          if lines[index].startswith('1.'      ):
               lowercase_	:				Tuple													=	lines[index].replace(
                   'https://huggingface.co/docs/transformers/main/model_doc'     ,			'https://huggingface.co/docs/transformers/model_doc'     ,			)
          index += 1

     with open(__SCREAMING_SNAKE_CASE     ,			'w'     ,			encoding='utf-8'     ,			newline='\n'      ) as f:
          f.writelines(__SCREAMING_SNAKE_CASE      )



def 			lowercase__(       ):
     with open(REPLACE_FILES['init']     ,			'r'      ) as f:
          lowercase_	:				Tuple													=	f.read()
     lowercase_	:				List[str]													=	REPLACE_PATTERNS['init'][0].search(__SCREAMING_SNAKE_CASE      ).groups()[0]
     return packaging.version.parse(__SCREAMING_SNAKE_CASE      )



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     str=False      ):
     lowercase_	:				int													=	get_version()
     if patch and default_version.is_devrelease:
          raise ValueError('Can\'t create a patch version from the dev branch, checkout a released version!'      )
     if default_version.is_devrelease:
          lowercase_	:				Union[str, Any]													=	default_version.base_version
     elif patch:
          lowercase_	:				str													=	F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
     else:
          lowercase_	:				Optional[Any]													=	F'''{default_version.major}.{default_version.minor + 1}.0'''

     # Now let's ask nicely if that's the right one.
     lowercase_	:				Union[str, Any]													=	input(F'''Which version are you releasing? [{default_version}]'''      )
     if len(__SCREAMING_SNAKE_CASE      ) == 0:
          lowercase_	:				Union[str, Any]													=	default_version

     print(F'''Updating version to {version}.'''      )
     global_version_update(__SCREAMING_SNAKE_CASE     ,			patch=__SCREAMING_SNAKE_CASE      )
     if not patch:
          print('Cleaning main README, don\'t forget to run `make fix-copies`.'      )
          clean_main_ref_in_model_list()



def 			lowercase__(       ):
     lowercase_	:				int													=	get_version()
     lowercase_	:				Any													=	F'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
     lowercase_	:				List[Any]													=	current_version.base_version

     # Check with the user we got that right.
     lowercase_	:				Tuple													=	input(F'''Which version are we developing now? [{dev_version}]'''      )
     if len(__SCREAMING_SNAKE_CASE      ) == 0:
          lowercase_	:				Optional[Any]													=	dev_version

     print(F'''Updating version to {version}.'''      )
     global_version_update(__SCREAMING_SNAKE_CASE      )
     print('Cleaning main README, don\'t forget to run `make fix-copies`.'      )
     clean_main_ref_in_model_list()


if __name__ == "__main__":
       __SCREAMING_SNAKE_CASE    	=argparse.ArgumentParser()
       parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")
       parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")
       __SCREAMING_SNAKE_CASE    	=parser.parse_args()
       if not args.post_release:
              pre_release_work(patch=args.patch)
       elif args.patch:
              print("Nothing to do after a patch :-)")
       else:
              post_release_work()


"""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		(			lowercase_  ):
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        lowercase_	:				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     ,__UpperCamelCase     ,__UpperCamelCase=13     ,__UpperCamelCase=64     ,__UpperCamelCase=3     ,__UpperCamelCase=3     ,__UpperCamelCase=2     ,__UpperCamelCase=1     ,__UpperCamelCase=16     ,__UpperCamelCase=[128, 256, 384]     ,__UpperCamelCase=[4, 6, 8]     ,__UpperCamelCase=[2, 3, 4]     ,__UpperCamelCase=[16, 16, 16]     ,__UpperCamelCase=0     ,__UpperCamelCase=[2, 2, 2]     ,__UpperCamelCase=[2, 2, 2]     ,__UpperCamelCase=0.02     ,__UpperCamelCase=True     ,__UpperCamelCase=True     ,__UpperCamelCase=2     ,)	->      str:


        '''simple docstring'''


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


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

        lowercase_	:				List[str]													=	self.get_config()
        return config, pixel_values, labels
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''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 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Any:


        '''simple docstring'''


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


        '''simple docstring'''


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







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


        '''simple docstring'''


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







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

   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Tuple													=	LevitModelTester(self			)
        lowercase_	:				Dict													=	ConfigTester(self     ,config_class=__UpperCamelCase     ,has_text_modality=__UpperCamelCase     ,hidden_size=37			)
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


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


        '''simple docstring'''


        return
   @unittest.skip(reason='Levit does not use inputs_embeds'			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


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


        '''simple docstring'''


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


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


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

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

             lowercase_	:				Optional[int]													=	['pixel_values']
             self.assertListEqual(arg_names[:1]     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


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

             with torch.no_grad():
                  lowercase_	:				Optional[int]													=	model(**self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)			)

             lowercase_	:				Dict													=	outputs.hidden_states

             lowercase_	:				List[str]													=	len(self.model_tester.depths			) + 1
             self.assertEqual(len(__UpperCamelCase			)     ,__UpperCamelCase			)

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

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

        for model_class in self.all_model_classes:
             lowercase_	:				Any													=	True
             check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)

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


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase=False			)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				Optional[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 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				Any													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Dict													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        if not self.model_tester.is_training:
             return

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


        '''simple docstring'''


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

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


        '''simple docstring'''


        lowercase_							,  lowercase_	:				Any													=	self.model_tester.prepare_config_and_inputs_for_common()

        lowercase_	:				int													=	[
            {'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"]}'''			):
                       lowercase_	:				Any													=	problem_type['title']
                       lowercase_	:				Tuple													=	problem_type['num_labels']

                       lowercase_	:				Tuple													=	model_class(__UpperCamelCase			)
                       model.to(__UpperCamelCase			)
                       model.train()

                       lowercase_	:				Optional[int]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)

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

                       lowercase_	:				str													=	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:
                            lowercase_	:				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 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


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






def 			lowercase__(       ):
     lowercase_	:				Any													=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
     return image







@require_torch
@require_vision
class        UpperCamelCase		(			unittest.TestCase  ):
   @cached_property
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)







   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				Any													=	LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(
            __UpperCamelCase			)

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

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

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

        lowercase_	:				Any													=	torch.tensor([1.0448, -0.3745, -1.8317]			).to(__UpperCamelCase			)

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

