




import math
import os
import re
import sys
import unittest
from pathlib import Path
from typing import Tuple
from unittest.mock import patch

from parameterized import parameterized

from transformers.testing_utils import (
    CaptureStderr,
    ExtendSysPath,
    TestCasePlus,
    execute_subprocess_async,
    get_gpu_count,
    get_torch_dist_unique_port,
    require_apex,
    require_bitsandbytes,
    require_fairscale,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    require_torch_non_multi_gpu,
    slow,
)
from transformers.trainer_callback import TrainerState
from transformers.trainer_utils import set_seed


_lowerCAmelCase  :      Tuple						=      os.path.abspath(os.path.dirname(__file__))
with ExtendSysPath(F'''{bindir}/../../examples/pytorch/translation'''):
  from run_translation import main  # noqa


set_seed(4_2)
_lowerCAmelCase  :      List[Any]						=      "sshleifer/student_marian_en_ro_6_1"
_lowerCAmelCase  :      Optional[int]						=      "sshleifer/tiny-mbart"
@require_torch
class 	_UpperCamelCase					( lowercase_						):
      def 		UpperCAmelCase_  (	self      :List[Any]       ,					lowerCamelCase      :List[str]=False       ,					lowerCamelCase      :Optional[Any]=None       ,					lowerCamelCase      :Optional[int]=True       ,					lowerCamelCase      :Any=True       ,					lowerCamelCase      :str=True       ,					lowerCamelCase      :int=True       ,					)   ->	str:
       UpperCAmelCase__							       =  self.run_trainer(
           eval_steps=1       ,					max_len=12       ,					model_name=__UpperCamelCase       ,					num_train_epochs=1       ,					distributed=__UpperCamelCase       ,					extra_args_str=__UpperCamelCase       ,					predict_with_generate=__UpperCamelCase       ,					do_train=__UpperCamelCase       ,					do_eval=__UpperCamelCase       ,					do_predict=__UpperCamelCase       ,					)
       UpperCAmelCase__							       =  TrainerState.load_from_json(os.path.join(__UpperCamelCase       ,					"trainer_state.json"					)					).log_history

       if not do_eval:
        return

       UpperCAmelCase__							       =  [log for log in logs if 'eval_loss' in log.keys()]

       UpperCAmelCase__							       =  eval_metrics[0]
       if predict_with_generate:
        assert "eval_bleu" in first_step_stats

        UpperCAmelCase__							       =  eval_metrics[-1]
        assert isinstance(last_step_stats["eval_bleu"]       ,					__UpperCamelCase					)
        assert not math.isnan(float(last_step_stats["eval_loss"]					)					), "eval_loss must not be `nan`"
      @require_torch_non_multi_gpu
      def 		UpperCAmelCase_  (	self      :List[Any]					)   ->	Optional[Any]:
       self.run_seqaseq_quick()
      @require_torch_multi_gpu
      def 		UpperCAmelCase_  (	self      :Tuple					)   ->	Optional[int]:
       self.run_seqaseq_quick(distributed=__UpperCamelCase					)
      @require_torch_multi_gpu
      def 		UpperCAmelCase_  (	self      :Union[str, Any]					)   ->	Optional[int]:
       self.run_seqaseq_quick(distributed=__UpperCamelCase					)
      @unittest.skip("Requires an update of the env running those tests"					)
      @require_torch_multi_gpu
      @require_fairscale
      def 		UpperCAmelCase_  (	self      :Dict					)   ->	Optional[int]:
       self.run_seqaseq_quick(distributed=__UpperCamelCase       ,					extra_args_str="--sharded_ddp simple"					)
      @unittest.skip("Requires an update of the env running those tests"					)
      @require_torch_multi_gpu
      @require_fairscale
      def 		UpperCAmelCase_  (	self      :Any					)   ->	List[Any]:
       self.run_seqaseq_quick(distributed=__UpperCamelCase       ,					extra_args_str="--sharded_ddp simple --fp16"					)
      @unittest.skip("Requires an update of the env running those tests"					)
      @require_torch_multi_gpu
      @require_fairscale
      def 		UpperCAmelCase_  (	self      :Any					)   ->	int:
       self.run_seqaseq_quick(distributed=__UpperCamelCase       ,					extra_args_str="--sharded_ddp zero_dp_2"       ,					predict_with_generate=__UpperCamelCase					)
      @unittest.skip("Requires an update of the env running those tests"					)
      @require_torch_multi_gpu
      @require_fairscale
      def 		UpperCAmelCase_  (	self      :List[str]					)   ->	str:
       self.run_seqaseq_quick(
           distributed=__UpperCamelCase       ,					extra_args_str="--sharded_ddp zero_dp_2 --fp16"       ,					predict_with_generate=__UpperCamelCase					)
      @require_apex
      @require_torch_gpu
      def 		UpperCAmelCase_  (	self      :str					)   ->	str:
       self.run_seqaseq_quick(distributed=__UpperCamelCase       ,					extra_args_str="--fp16 --fp16_backend=apex"					)
       # test 2nd time - was getting eval_loss': nan'
       # to reproduce the problem set distributed=False
       self.run_seqaseq_quick(distributed=__UpperCamelCase       ,					extra_args_str="--fp16 --fp16_backend=apex"					)
      @parameterized.expand(["base", "low", "high", "mixed"]					)
      @require_torch_multi_gpu
      def 		UpperCAmelCase_  (	self      :Tuple       ,					lowerCamelCase      :Dict					)   ->	Tuple:
       UpperCAmelCase__							       =  {
           # test with the default log_level - should be info and thus log info once
           'base': {'extra_args_str': '', 'n_matches': 1},
           # test with low log_level and log_level_replica - should be noisy on all processes
           # now the info string should appear twice on 2 processes
           'low': {'extra_args_str': '--log_level debug --log_level_replica debug', 'n_matches': 2},
           # test with high log_level and low log_level_replica
           # now the info string should appear once only on the replica
           'high': {'extra_args_str': '--log_level error --log_level_replica debug', 'n_matches': 1},
           # test with high log_level and log_level_replica - should be quiet on all processes
           'mixed': {'extra_args_str': '--log_level error --log_level_replica error', 'n_matches': 0},
       }

       UpperCAmelCase__							       =  experiments[experiment_id]
       UpperCAmelCase__							       =  {'distributed': True, 'predict_with_generate': False, 'do_eval': False, 'do_predict': False}
       UpperCAmelCase__							       =  'Running training'
       with CaptureStderr() as cl:
        self.run_seqaseq_quick(**__UpperCamelCase       ,					extra_args_str=data["extra_args_str"]					)
       UpperCAmelCase__							       =  len(re.findall(__UpperCamelCase       ,					cl.err					)					)
       self.assertEqual(__UpperCamelCase       ,					data["n_matches"]					)
      @slow
      def 		UpperCAmelCase_  (	self      :str					)   ->	List[Any]:
       UpperCAmelCase__							       =  self.run_trainer(
           eval_steps=2       ,					max_len=128       ,					model_name=__UpperCamelCase       ,					learning_rate=3e-4       ,					num_train_epochs=10       ,					distributed=__UpperCamelCase       ,					)

       # Check metrics
       UpperCAmelCase__							       =  TrainerState.load_from_json(os.path.join(__UpperCamelCase       ,					"trainer_state.json"					)					).log_history
       UpperCAmelCase__							       =  [log for log in logs if 'eval_loss' in log.keys()]
       UpperCAmelCase__							       =  eval_metrics[0]
       UpperCAmelCase__							       =  eval_metrics[-1]

       assert first_step_stats["eval_loss"] > last_step_stats["eval_loss"], "model learned nothing"
       assert isinstance(last_step_stats["eval_bleu"]       ,					__UpperCamelCase					)

       # test if do_predict saves generations and metrics
       UpperCAmelCase__							       =  os.listdir(__UpperCamelCase					)
       UpperCAmelCase__							       =  {os.path.basename(__UpperCamelCase					) for p in contents}
       assert "generated_predictions.txt" in contents
       assert "predict_results.json" in contents
      @slow
      @require_bitsandbytes
      def 		UpperCAmelCase_  (	self      :Any					)   ->	List[str]:
       from transformers.training_args import OptimizerNames

       def train_and_return_metrics(lowerCamelCase      :int					) -> Tuple[int, float]:
        UpperCAmelCase__							       =  '--skip_memory_metrics 0'

        UpperCAmelCase__							       =  self.run_trainer(
            max_len=128       ,					model_name=__UpperCamelCase       ,					learning_rate=3e-4       ,					num_train_epochs=1       ,					optim=__UpperCamelCase       ,					distributed=__UpperCamelCase       ,					extra_args_str=__UpperCamelCase       ,					do_eval=__UpperCamelCase       ,					do_predict=__UpperCamelCase       ,					n_gpus_to_use=1       ,					)

        # Check metrics
        UpperCAmelCase__							       =  TrainerState.load_from_json(Path(__UpperCamelCase       ,					"trainer_state.json"					)					).log_history
        UpperCAmelCase__							       =  int(logs[0]["train_mem_gpu_peaked_delta"] / 2**20					)
        UpperCAmelCase__							       =  int(logs[0]["train_mem_gpu_alloc_delta"] / 2**20					)

        UpperCAmelCase__							       =  logs[0]['train_loss']
        return gpu_peak_mem_mb, gpu_alloc_mem_mb, loss

       UpperCAmelCase__							       =  train_and_return_metrics(OptimizerNames.ADAMW_TORCH.value					)
       UpperCAmelCase__							       =  train_and_return_metrics(OptimizerNames.ADAMW_BNB.value					)

       UpperCAmelCase__							       =  gpu_alloc_mem_orig - gpu_alloc_mem_bnb

       UpperCAmelCase__							       =  gpu_peak_mem_orig + gpu_alloc_mem_orig
       UpperCAmelCase__							       =  gpu_peak_mem_bnb + gpu_alloc_mem_bnb
       UpperCAmelCase__							       =  gpu_total_mem_orig - gpu_total_mem_bnb

       # sshleifer/student_marian_en_ro_6_1 has 54M parameter, 29M of which is `nn.Embedding` which
       # doesn't get quantized and remains in fp32. Therefore we only have 25M parameters quantized
       # in 2 bytes and the diff in optim memory usage is derived as so:
       #
       # - normal 25*8=~200MB (8 bytes per param)
       # - bnb    25*2= ~50MB (2 bytes per param)
       #
       # Thus we should expect ~150MB total memory saved.
       #
       # Peak memory should be the same - the total should be different by about that same margin
       #
       # After leaving a small margin to accommodate for differences between gpus let's check
       # that we have at least 120MB in savings
       UpperCAmelCase__							       =  120

       # uncomment the following if this test starts failing - requires py38 for a new print feature
       # gpu_peak_mem_diff = gpu_peak_mem_orig - gpu_peak_mem_bnb
       # print(f"{gpu_alloc_mem_orig=}MB {gpu_peak_mem_orig=}MB {gpu_alloc_mem_orig+gpu_peak_mem_orig=}MB")
       # print(f" {gpu_alloc_mem_bnb=}MB  {gpu_peak_mem_bnb=}MB  {gpu_alloc_mem_bnb+gpu_peak_mem_bnb=}MB")
       # print(f"{gpu_alloc_mem_diff=}MB")
       # print(f"{gpu_peak_mem_diff=}MB")
       # print(f"{gpu_total_mem_orig=}MB, {gpu_total_mem_bnb=}MB")
       # print(f"{gpu_total_mem_diff=}MB, {gpu_total_mem_diff=}MB")

       self.assertGreater(
           __UpperCamelCase       ,					__UpperCamelCase       ,					"should use ~150MB less alloc gpu memory with BNB, compared to without it for this model but got"
           f''' a difference of {gpu_alloc_mem_diff}MB, with gpu_alloc_mem_orig={gpu_alloc_mem_orig}MB and'''
           f''' gpu_alloc_mem_bnb={gpu_alloc_mem_bnb}MB'''       ,					)

       self.assertGreater(
           __UpperCamelCase       ,					__UpperCamelCase       ,					"should use ~150MB less total gpu memory with BNB, compared to without it for this model but got"
           f''' a difference of {gpu_total_mem_diff}MB, with gpu_total_mem_orig={gpu_total_mem_orig}MB and'''
           f''' gpu_total_mem_bnb={gpu_total_mem_bnb}MB'''       ,					)

       self.assertEqual(
           __UpperCamelCase       ,					__UpperCamelCase       ,					f'''loss should be the same, but got loss_orig={loss_orig}, loss_bnb={loss_bnb}'''					)







      def 		UpperCAmelCase_  (	self      :List[str]       ,					lowerCamelCase      :str       ,					lowerCamelCase      :Union[str, Any]       ,					lowerCamelCase      :List[str]       ,					lowerCamelCase      :List[Any] = 3e-3       ,					lowerCamelCase      :Dict = "adafactor"       ,					lowerCamelCase      :List[str] = False       ,					lowerCamelCase      :Optional[int] = None       ,					lowerCamelCase      :str = 0       ,					lowerCamelCase      :Any = True       ,					lowerCamelCase      :Any = True       ,					lowerCamelCase      :Dict = True       ,					lowerCamelCase      :Optional[int] = True       ,					lowerCamelCase      :List[Any] = None       ,					)   ->	Optional[Any]:
       UpperCAmelCase__							       =  self.test_file_dir / '../fixtures/tests_samples/wmt_en_ro'
       UpperCAmelCase__							       =  self.get_auto_remove_tmp_dir()
       UpperCAmelCase__							       =  f'''
            --model_name_or_path {model_name}
            --train_file {data_dir}/train.json
            --validation_file {data_dir}/val.json
            --test_file {data_dir}/test.json
            --output_dir {output_dir}
            --overwrite_output_dir
            --max_train_samples 8
            --max_source_length {max_len}
            --max_target_length {max_len}
            --do_train
            --num_train_epochs {str(__UpperCamelCase					)}
            --per_device_train_batch_size 4
            --learning_rate {learning_rate}
            --warmup_steps 8
            --logging_steps 0
            --logging_strategy no
            --save_steps {str(__UpperCamelCase					)}
            --group_by_length
            --label_smoothing_factor 0.1
            --target_lang ro_RO
            --source_lang en_XX
        '''.split()

       UpperCAmelCase__							       =  f'''
            --do_eval
            --per_device_eval_batch_size 4
            --max_eval_samples 8
            --val_max_target_length {max_len}
            --evaluation_strategy steps
            --eval_steps {str(__UpperCamelCase					)}
        '''.split()

       UpperCAmelCase__							       =  '\n            --do_predict\n        '.split()

       UpperCAmelCase__							       =  []
       if do_train:
        args += args_train

       if do_eval:
        args += args_eval

       if do_predict:
        args += args_predict

       if predict_with_generate:
        args += "--predict_with_generate".split()

       if do_train:
        if optim == "adafactor":
         args += "--adafactor".split()
        else:
         args += f'''--optim {optim}'''.split()

       if extra_args_str is not None:
        args += extra_args_str.split()

       if distributed:
        if n_gpus_to_use is None:
         UpperCAmelCase__							       =  get_gpu_count()
        UpperCAmelCase__							       =  get_torch_dist_unique_port()
        UpperCAmelCase__							       =  f'''
                -m torch.distributed.run
                --nproc_per_node={n_gpus_to_use}
                --master_port={master_port}
                {self.examples_dir_str}/pytorch/translation/run_translation.py
            '''.split()
        UpperCAmelCase__							       =  [sys.executable] + distributed_args + args
        # keep for quick debug
        # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
        execute_subprocess_async(__UpperCamelCase       ,					env=self.get_env()					)
       else:
        UpperCAmelCase__							       =  ['run_translation.py'] + args
        with patch.object(__UpperCamelCase       ,					"argv"       ,					__UpperCamelCase					):
         main()

       return output_dir






"""simple docstring"""







import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 torch import nn

       from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
       from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import ViTImageProcessor







class        UpperCamelCase		:
   def __init__(			self     ,__UpperCamelCase     ,__UpperCamelCase=13     ,__UpperCamelCase=30     ,__UpperCamelCase=2     ,__UpperCamelCase=3     ,__UpperCamelCase=True     ,__UpperCamelCase=True     ,__UpperCamelCase=32     ,__UpperCamelCase=5     ,__UpperCamelCase=4     ,__UpperCamelCase=37     ,__UpperCamelCase="gelu"     ,__UpperCamelCase=0.1     ,__UpperCamelCase=0.1     ,__UpperCamelCase=10     ,__UpperCamelCase=0.02     ,__UpperCamelCase=None     ,__UpperCamelCase=2     ,)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				Tuple													=	parent
        lowercase_	:				List[Any]													=	batch_size
        lowercase_	:				Optional[int]													=	image_size
        lowercase_	:				List[str]													=	patch_size
        lowercase_	:				int													=	num_channels
        lowercase_	:				List[str]													=	is_training
        lowercase_	:				Union[str, Any]													=	use_labels
        lowercase_	:				str													=	hidden_size
        lowercase_	:				List[str]													=	num_hidden_layers
        lowercase_	:				List[str]													=	num_attention_heads
        lowercase_	:				Dict													=	intermediate_size
        lowercase_	:				Optional[int]													=	hidden_act
        lowercase_	:				Any													=	hidden_dropout_prob
        lowercase_	:				Any													=	attention_probs_dropout_prob
        lowercase_	:				List[str]													=	type_sequence_label_size
        lowercase_	:				Union[str, Any]													=	initializer_range
        lowercase_	:				int													=	scope
        lowercase_	:				Dict													=	encoder_stride

        # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
        lowercase_	:				Any													=	(image_size // patch_size) ** 2
        lowercase_	:				Optional[int]													=	num_patches + 1
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


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

        lowercase_	:				Tuple													=	None
        if self.use_labels:
             lowercase_	:				Dict													=	ids_tensor([self.batch_size]     ,self.type_sequence_label_size			)

        lowercase_	:				Any													=	self.get_config()

        return config, pixel_values, labels
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        return ViTConfig(
            image_size=self.image_size     ,patch_size=self.patch_size     ,num_channels=self.num_channels     ,hidden_size=self.hidden_size     ,num_hidden_layers=self.num_hidden_layers     ,num_attention_heads=self.num_attention_heads     ,intermediate_size=self.intermediate_size     ,hidden_act=self.hidden_act     ,hidden_dropout_prob=self.hidden_dropout_prob     ,attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,is_decoder=__UpperCamelCase     ,initializer_range=self.initializer_range     ,encoder_stride=self.encoder_stride     ,)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				List[Any]													=	ViTModel(config=__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()
        lowercase_	:				Optional[Any]													=	model(__UpperCamelCase			)
        self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size)			)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Any:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	ViTForMaskedImageModeling(config=__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()
        lowercase_	:				List[str]													=	model(__UpperCamelCase			)
        self.parent.assertEqual(
            result.reconstruction.shape     ,(self.batch_size, self.num_channels, self.image_size, self.image_size)			)

        # test greyscale images
        lowercase_	:				Any													=	1
        lowercase_	:				List[Any]													=	ViTForMaskedImageModeling(__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()

        lowercase_	:				Dict													=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
        lowercase_	:				str													=	model(__UpperCamelCase			)
        self.parent.assertEqual(result.reconstruction.shape     ,(self.batch_size, 1, self.image_size, self.image_size)			)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      str:


        '''simple docstring'''


        lowercase_	:				Dict													=	self.type_sequence_label_size
        lowercase_	:				Dict													=	ViTForImageClassification(__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()
        lowercase_	:				int													=	model(__UpperCamelCase     ,labels=__UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)			)

        # test greyscale images
        lowercase_	:				Dict													=	1
        lowercase_	:				Any													=	ViTForImageClassification(__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()

        lowercase_	:				Dict													=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
        lowercase_	:				Dict													=	model(__UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)			)







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


        '''simple docstring'''


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







@require_torch
class        UpperCamelCase		(			lowercase_						,      lowercase_						,      unittest.TestCase  ):
   lowercase							=  (
       (
           ViTModel,
           ViTForImageClassification,
           ViTForMaskedImageModeling,
       )
       if is_torch_available()
       else ()
   )
   lowercase							=  (
       {'feature-extraction': ViTModel, 'image-classification': ViTForImageClassification}
       if is_torch_available()
       else {}
   )
   lowercase							=  True

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


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	ViTModelTester(self			)
        lowercase_	:				Dict													=	ConfigTester(self     ,config_class=__UpperCamelCase     ,has_text_modality=__UpperCamelCase     ,hidden_size=37			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        self.config_tester.run_common_tests()
   @unittest.skip(reason='ViT does not use inputs_embeds'			)
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


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

        for model_class in self.all_model_classes:
             lowercase_	:				str													=	model_class(__UpperCamelCase			)
             self.assertIsInstance(model.get_input_embeddings()     ,(nn.Module)			)
             lowercase_	:				List[Any]													=	model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(__UpperCamelCase     ,nn.Linear			)			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


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

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

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


        '''simple docstring'''


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


        '''simple docstring'''


        lowercase_	:				str													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      str:


        '''simple docstring'''


        lowercase_	:				str													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)







   @slow
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				List[Any]													=	ViTModel.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			)	->      Any:


        '''simple docstring'''


        return ViTImageProcessor.from_pretrained('google/vit-base-patch16-224'			) if is_vision_available() else None
   @slow
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				str													=	ViTForImageClassification.from_pretrained('google/vit-base-patch16-224'			).to(__UpperCamelCase			)

        lowercase_	:				Any													=	self.default_image_processor
        lowercase_	:				Dict													=	prepare_img()
        lowercase_	:				Tuple													=	image_processor(images=__UpperCamelCase     ,return_tensors='pt'			).to(__UpperCamelCase			)

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

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

        lowercase_	:				Optional[int]													=	torch.tensor([-0.2744, 0.8215, -0.0836]			).to(__UpperCamelCase			)

        self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,__UpperCamelCase     ,atol=1e-4			)			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				str													=	ViTModel.from_pretrained('facebook/dino-vits8'			).to(__UpperCamelCase			)

        lowercase_	:				int													=	ViTImageProcessor.from_pretrained('facebook/dino-vits8'     ,size=480			)
        lowercase_	:				int													=	prepare_img()
        lowercase_	:				Dict													=	image_processor(images=__UpperCamelCase     ,return_tensors='pt'			)
        lowercase_	:				int													=	inputs.pixel_values.to(__UpperCamelCase			)

        # forward pass
        with torch.no_grad():
             lowercase_	:				int													=	model(__UpperCamelCase     ,interpolate_pos_encoding=__UpperCamelCase			)

        # verify the logits
        lowercase_	:				Any													=	torch.Size((1, 3601, 384)			)
        self.assertEqual(outputs.last_hidden_state.shape     ,__UpperCamelCase			)

        lowercase_	:				Any													=	torch.tensor(
            [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]]			).to(__UpperCamelCase			)

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







   @slow
   @require_accelerate
   @require_torch_gpu
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	ViTModel.from_pretrained('facebook/dino-vits8'     ,torch_dtype=torch.floataa     ,device_map='auto'			)
        lowercase_	:				int													=	self.default_image_processor

        lowercase_	:				Optional[int]													=	prepare_img()
        lowercase_	:				Tuple													=	image_processor(images=__UpperCamelCase     ,return_tensors='pt'			)
        lowercase_	:				Union[str, Any]													=	inputs.pixel_values.to(__UpperCamelCase			)

        # forward pass to make sure inference works in fp16
        with torch.no_grad():
             lowercase_	:				Dict													=	model(__UpperCamelCase			)

