code: 
  
  
  '''simple docstring'''
  
  from copy import deepcopy
  from pathlib import Path
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
  
  import torch
  from torch import nn
  from torch.utils.data import Dataset
  
  from .deepspeed import is_deepspeed_zeroa_enabled
  from .generation.configuration_utils import GenerationConfig
  from .trainer import Trainer
  from .utils import logging
  
  
  if TYPE_CHECKING:
   from .data.data_collator import DataCollator
   from .modeling_utils import PreTrainedModel
   from .tokenization_utils_base import PreTrainedTokenizerBase
   from .trainer_callback import TrainerCallback
   from .trainer_utils import EvalPrediction, PredictionOutput
   from .training_args import TrainingArguments
  
  
  lowerCamelCase							:     Tuple								=			logging.get_logger(__name__)
  class 						__lowerCAmelCase		(UpperCamelCase_  ):
  
  
  
  
  
        '''simple docstring'''
  
  
  
  
  
  
        def __init__(self					:					List[str]     ,		UpperCamelCase					:					Dict = None     ,		UpperCamelCase					:					int = None     ,		UpperCamelCase					:					Tuple = None     ,		UpperCamelCase					:					Optional[int] = None     ,		UpperCamelCase					:					Tuple = None     ,		UpperCamelCase					:					Any = None     ,		UpperCamelCase					:					Optional[int] = None     ,		UpperCamelCase					:					Dict = None     ,		UpperCamelCase					:					Any = None     ,		UpperCamelCase					:					List[Any] = (None, None)     ,		UpperCamelCase					:					Tuple = None     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               super().__init__(
                   model=__SCREAMING_SNAKE_CASE     ,		args=__SCREAMING_SNAKE_CASE     ,		data_collator=__SCREAMING_SNAKE_CASE     ,		train_dataset=__SCREAMING_SNAKE_CASE     ,		eval_dataset=__SCREAMING_SNAKE_CASE     ,		tokenizer=__SCREAMING_SNAKE_CASE     ,		model_init=__SCREAMING_SNAKE_CASE     ,		compute_metrics=__SCREAMING_SNAKE_CASE     ,		callbacks=__SCREAMING_SNAKE_CASE     ,		optimizers=__SCREAMING_SNAKE_CASE     ,		preprocess_logits_for_metrics=__SCREAMING_SNAKE_CASE     ,		)
  
               # Override self.model.generation_config if a GenerationConfig is specified in args.
               # Priority: args.generation_config > model.generation_config > default GenerationConfig.
               if self.args.generation_config is not None:
                      lowercase__       =				self.load_generation_config(self.args.generation_config				)
                      lowercase__       =				gen_config
  
  
  
        @staticmethod
        def    UpperCamelCase__	(UpperCamelCase					:					List[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               if isinstance(__SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE				):
                      return deepcopy(__SCREAMING_SNAKE_CASE				)
  
               # str or Path
               lowercase__       =				Path(__SCREAMING_SNAKE_CASE				) if isinstance(__SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE				) else gen_config_arg
               lowercase__       =				None
  
               # Figuring if it is path pointing to a file, pointing to a directory or else a model id or URL
               # This step is required in order to determine config_file_name
               if pretrained_model_name.is_file():
                      lowercase__       =				pretrained_model_name.name
                      lowercase__       =				pretrained_model_name.parent
               # dir path
               elif pretrained_model_name.is_dir():
                      pass
               # model id or URL
               else:
                      lowercase__       =				gen_config_arg
  
               lowercase__       =				GenerationConfig.from_pretrained(__SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE				)
               return gen_config
  
  
  
        def    UpperCamelCase__	(self					:					List[Any]     ,		UpperCamelCase					:					str = None     ,		UpperCamelCase					:					Union[str, Any] = None     ,		UpperCamelCase					:					Optional[int] = "eval"     ,		**UpperCamelCase					:					str     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				gen_kwargs.copy()
               if gen_kwargs.get('''max_length'''				) is None and gen_kwargs.get('''max_new_tokens'''				) is None:
                      lowercase__       =				self.args.generation_max_length
               lowercase__       =				(
                   gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''				) is not None else self.args.generation_num_beams
               )
               lowercase__       =				gen_kwargs
  
               return super().evaluate(__SCREAMING_SNAKE_CASE     ,		ignore_keys=__SCREAMING_SNAKE_CASE     ,		metric_key_prefix=__SCREAMING_SNAKE_CASE				)
  
  
  
        def    UpperCamelCase__	(self					:					List[Any]     ,		UpperCamelCase					:					Any     ,		UpperCamelCase					:					Union[str, Any] = None     ,		UpperCamelCase					:					Dict = "test"     ,		**UpperCamelCase					:					Union[str, Any]     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				gen_kwargs.copy()
               if gen_kwargs.get('''max_length'''				) is None and gen_kwargs.get('''max_new_tokens'''				) is None:
                      lowercase__       =				self.args.generation_max_length
               lowercase__       =				(
                   gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''				) is not None else self.args.generation_num_beams
               )
               lowercase__       =				gen_kwargs
  
               return super().predict(__SCREAMING_SNAKE_CASE     ,		ignore_keys=__SCREAMING_SNAKE_CASE     ,		metric_key_prefix=__SCREAMING_SNAKE_CASE				)
  
  
  
        def    UpperCamelCase__	(self					:					List[str]     ,		UpperCamelCase					:					Any     ,		UpperCamelCase					:					Any     ,		UpperCamelCase					:					int     ,		UpperCamelCase					:					Dict = None     ,		**UpperCamelCase					:					Tuple     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               if not self.args.predict_with_generate or prediction_loss_only:
                      return super().prediction_step(
                          __SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE     ,		prediction_loss_only=__SCREAMING_SNAKE_CASE     ,		ignore_keys=__SCREAMING_SNAKE_CASE				)
  
               lowercase__       =				'''labels''' in inputs
               lowercase__       =				self._prepare_inputs(__SCREAMING_SNAKE_CASE				)
  
               # XXX: adapt synced_gpus for fairscale as well
               # Priority (handled in generate):
               # gen_kwargs > model.generation_config > default GenerationConfig()
  
               if len(__SCREAMING_SNAKE_CASE				) == 0 and hasattr(self     ,		'''_gen_kwargs'''				):
                      lowercase__       =				self._gen_kwargs.copy()
  
               if gen_kwargs.get('''max_length'''				) is None and gen_kwargs.get('''max_new_tokens'''				) is None:
                      lowercase__       =				self.model.config.max_length
               lowercase__       =				(
                   gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''				) is not None else self.model.config.num_beams
               )
               lowercase__       =				True if is_deepspeed_zeroa_enabled() else False
               lowercase__       =				(
                   gen_kwargs['''synced_gpus'''] if gen_kwargs.get('''synced_gpus'''				) is not None else default_synced_gpus
               )
  
               # If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
               # (otherwise, it would continue generating from the padded `decoder_input_ids`)
               if (
                   "labels" in inputs
                   and "decoder_input_ids" in inputs
                   and inputs["labels"].shape == inputs["decoder_input_ids"].shape
               ):
                      lowercase__       =				{k: v for k, v in inputs.items() if k != '''decoder_input_ids'''}
               lowercase__       =				self.model.generate(**__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE				)
  
               # Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
               # TODO: remove this hack when the legacy code that initializes generation_config from a model config is
               # removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
               if self.model.generation_config._from_model_config:
                      lowercase__       =				False
  
               # Retrieves GenerationConfig from model.generation_config
               lowercase__       =				self.model.generation_config
               # in case the batch is shorter than max length, the output should be padded
               if generated_tokens.shape[-1] < gen_config.max_length:
                      lowercase__       =				self._pad_tensors_to_max_len(__SCREAMING_SNAKE_CASE     ,		gen_config.max_length				)
               elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
                      lowercase__       =				self._pad_tensors_to_max_len(__SCREAMING_SNAKE_CASE     ,		gen_config.max_new_tokens + 1				)
  
               with torch.no_grad():
                      if has_labels:
                             with self.compute_loss_context_manager():
                                    lowercase__       =				model(**__SCREAMING_SNAKE_CASE				)
                             if self.label_smoother is not None:
                                    lowercase__       =				self.label_smoother(__SCREAMING_SNAKE_CASE     ,		inputs['''labels''']				).mean().detach()
                             else:
                                    lowercase__       =				(outputs['''loss'''] if isinstance(__SCREAMING_SNAKE_CASE     ,		__SCREAMING_SNAKE_CASE				) else outputs[0]).mean().detach()
                      else:
                             lowercase__       =				None
  
               if self.args.prediction_loss_only:
                      return loss, None, None
  
               if has_labels:
                      lowercase__       =				inputs['''labels''']
                      if labels.shape[-1] < gen_config.max_length:
                             lowercase__       =				self._pad_tensors_to_max_len(__SCREAMING_SNAKE_CASE     ,		gen_config.max_length				)
                      elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
                             lowercase__       =				self._pad_tensors_to_max_len(__SCREAMING_SNAKE_CASE     ,		gen_config.max_new_tokens + 1				)
               else:
                      lowercase__       =				None
  
               return loss, generated_tokens, labels
  
  
  
  
  
  
        def    UpperCamelCase__	(self					:					str     ,		UpperCamelCase					:					Any     ,		UpperCamelCase					:					Optional[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               if self.tokenizer is not None and hasattr(self.tokenizer     ,		'''pad_token_id'''				):
                      # If PAD token is not defined at least EOS token has to be defined
                      lowercase__       =				(
                          self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
                      )
               else:
                      if self.model.config.pad_token_id is not None:
                             lowercase__       =				self.model.config.pad_token_id
                      else:
                             raise ValueError('''Pad_token_id must be set in the configuration of the model, in order to pad tensors'''				)
  
               lowercase__       =				pad_token_id * torch.ones(
                   (tensor.shape[0], max_length)     ,		dtype=tensor.dtype     ,		device=tensor.device				)
               lowercase__       =				tensor
               return padded_tensor
style_context: 
  
  
  '''simple docstring'''
  
  import copy
  import inspect
  import unittest
  
  import numpy as np
  from huggingface_hub import hf_hub_download
  
  from transformers import VivitConfig
  from transformers.models.auto import get_values
  from transformers.testing_utils import require_torch, 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
  
  
  if is_torch_available():
   import torch
   from torch import nn
  
   from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
   from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  if is_vision_available():
   from transformers import VivitImageProcessor
  class 						__lowerCAmelCase		:
  
  
  
  
  
        '''simple docstring'''
  
  
  
  
  
  
        def __init__(self					:					int     ,		UpperCamelCase					:					str     ,		UpperCamelCase					:					str=2     ,		UpperCamelCase					:					Union[str, Any]=True     ,		UpperCamelCase					:					Dict=True     ,		UpperCamelCase					:					List[Any]=10     ,		UpperCamelCase					:					Optional[Any]=10     ,		UpperCamelCase					:					Optional[int]=8     ,		UpperCamelCase					:					int=[2, 4, 4]     ,		UpperCamelCase					:					Dict=3     ,		UpperCamelCase					:					Union[str, Any]=768     ,		UpperCamelCase					:					Any=5     ,		UpperCamelCase					:					List[str]=4     ,		UpperCamelCase					:					Optional[int]=37     ,		UpperCamelCase					:					List[Any]="gelu_fast"     ,		UpperCamelCase					:					List[Any]=0.0     ,		UpperCamelCase					:					str=0.0     ,		UpperCamelCase					:					Tuple=0.02     ,		UpperCamelCase					:					Any=1E-06     ,		UpperCamelCase					:					str=True     ,		UpperCamelCase					:					List[str]=None     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				parent
               lowercase__       =				batch_size
               lowercase__       =				is_training
               lowercase__       =				use_labels
               lowercase__       =				num_labels
               lowercase__       =				image_size
               lowercase__       =				num_frames
               lowercase__       =				tubelet_size
               lowercase__       =				num_channels
               lowercase__       =				hidden_size
               lowercase__       =				num_hidden_layers
               lowercase__       =				num_attention_heads
               lowercase__       =				intermediate_size
               lowercase__       =				hidden_act
               lowercase__       =				hidden_dropout_prob
               lowercase__       =				attention_probs_dropout_prob
               lowercase__       =				initializer_range
               lowercase__       =				layer_norm_eps
               lowercase__       =				qkv_bias
               lowercase__       =				scope
  
               lowercase__       =				(
                   (self.image_size // self.tubelet_size[2])
                   * (self.image_size // self.tubelet_size[1])
                   * (self.num_frames // self.tubelet_size[0])
               ) + 1  # CLS token
  
  
  
        def    UpperCamelCase__	(self					:					int				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				floats_tensor(
                   [self.batch_size, self.num_frames, 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    UpperCamelCase__	(self					:					List[str]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				VivitConfig(
                   num_frames=self.num_frames     ,		image_size=self.image_size     ,		tubelet_size=self.tubelet_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     ,		initializer_range=self.initializer_range     ,		layer_norm_eps=self.layer_norm_eps     ,		qkv_bias=self.qkv_bias     ,		)
               lowercase__       =				self.num_labels
               return config
  
  
  
        def    UpperCamelCase__	(self					:					Optional[int]     ,		UpperCamelCase					:					Optional[Any]     ,		UpperCamelCase					:					List[str]     ,		UpperCamelCase					:					Dict				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				VivitModel(config=UpperCamelCase				)
               model.to(UpperCamelCase				)
               model.eval()
               lowercase__       =				model(UpperCamelCase				)
               self.parent.assertEqual(result.last_hidden_state.shape     ,		(self.batch_size, self.seq_length, self.hidden_size)				)
  
  
  
        def    UpperCamelCase__	(self					:					int     ,		UpperCamelCase					:					Union[str, Any]     ,		UpperCamelCase					:					Any     ,		UpperCamelCase					:					Optional[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				VivitForVideoClassification(UpperCamelCase				)
               model.to(UpperCamelCase				)
               model.eval()
  
               lowercase__       =				model(UpperCamelCase				)
  
               # verify the logits shape
               lowercase__       =				torch.Size((self.batch_size, self.num_labels)				)
               self.parent.assertEqual(result.logits.shape     ,		UpperCamelCase				)
  
  
  
  
  
  
        def    UpperCamelCase__	(self					:					Dict				):
  
               '''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 						__lowerCAmelCase		(lowercase_						,  unittest.TestCase  ):
  
  
  
  
  
        '''simple docstring'''
  
  
  
  
  
  
        lowerCAmelCase__      :  List[str]						      =							(VivitModel, VivitForVideoClassification) if is_torch_available() else ()
  
        lowerCAmelCase__      :  Tuple						      =							False
        lowerCAmelCase__      :  Optional[Any]						      =							False
        lowerCAmelCase__      :  str						      =							False
        lowerCAmelCase__      :  Any						      =							False
  
  
  
        def    UpperCamelCase__	(self					:					Dict				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				VivitModelTester(self				)
               lowercase__       =				ConfigTester(self     ,		config_class=UpperCamelCase     ,		has_text_modality=UpperCamelCase     ,		hidden_size=37				)
  
  
  
        def    UpperCamelCase__	(self					:					List[str]     ,		UpperCamelCase					:					List[Any]     ,		UpperCamelCase					:					List[str]     ,		UpperCamelCase					:					Tuple=False				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				copy.deepcopy(UpperCamelCase				)
  
               if return_labels:
                      if model_class in get_values(UpperCamelCase				):
                             lowercase__       =				torch.zeros(
                                 self.model_tester.batch_size     ,		dtype=torch.long     ,		device=UpperCamelCase				)
  
               return inputs_dict
  
  
  
        def    UpperCamelCase__	(self					:					int				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               self.config_tester.run_common_tests()
  
  
  
        @unittest.skip(reason='''Vivit does not use inputs_embeds'''				)
        def    UpperCamelCase__	(self					:					Optional[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               pass
  
  
  
        def    UpperCamelCase__	(self					:					Optional[int]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__    ,lowercase__       =				self.model_tester.prepare_config_and_inputs_for_common()
  
               for model_class in self.all_model_classes:
                      lowercase__       =				model_class(UpperCamelCase				)
                      self.assertIsInstance(model.get_input_embeddings()     ,		(nn.Module)				)
                      lowercase__       =				model.get_output_embeddings()
                      self.assertTrue(x is None or isinstance(UpperCamelCase     ,		nn.Linear				)				)
  
  
  
        def    UpperCamelCase__	(self					:					Optional[int]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__    ,lowercase__       =				self.model_tester.prepare_config_and_inputs_for_common()
  
               for model_class in self.all_model_classes:
                      lowercase__       =				model_class(UpperCamelCase				)
                      lowercase__       =				inspect.signature(model.forward				)
                      # signature.parameters is an OrderedDict => so arg_names order is deterministic
                      lowercase__       =				[*signature.parameters.keys()]
  
                      lowercase__       =				['''pixel_values''', '''head_mask''']
                      self.assertListEqual(arg_names[:2]     ,		UpperCamelCase				)
  
  
  
        def    UpperCamelCase__	(self					:					str				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_model(*UpperCamelCase				)
  
  
  
        def    UpperCamelCase__	(self					:					List[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_for_video_classification(*UpperCamelCase				)
  
  
  
        @slow
        def    UpperCamelCase__	(self					:					Union[str, Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                      lowercase__       =				VivitModel.from_pretrained(UpperCamelCase				)
                      self.assertIsNotNone(UpperCamelCase				)
  
  
  
        def    UpperCamelCase__	(self					:					Tuple				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__    ,lowercase__       =				self.model_tester.prepare_config_and_inputs_for_common()
               lowercase__       =				True
  
               for model_class in self.all_model_classes:
                      lowercase__       =				self.model_tester.seq_length
  
                      lowercase__       =				True
                      lowercase__       =				False
                      lowercase__       =				True
                      lowercase__       =				model_class(UpperCamelCase				)
                      model.to(UpperCamelCase				)
                      model.eval()
                      with torch.no_grad():
                             lowercase__       =				model(**self._prepare_for_class(UpperCamelCase     ,		UpperCamelCase				)				)
                      lowercase__       =				outputs.attentions
                      self.assertEqual(len(UpperCamelCase				)     ,		self.model_tester.num_hidden_layers				)
  
                      # check that output_attentions also work using config
                      del inputs_dict["output_attentions"]
                      lowercase__       =				True
                      lowercase__       =				model_class(UpperCamelCase				)
                      model.to(UpperCamelCase				)
                      model.eval()
                      with torch.no_grad():
                             lowercase__       =				model(**self._prepare_for_class(UpperCamelCase     ,		UpperCamelCase				)				)
                      lowercase__       =				outputs.attentions
                      self.assertEqual(len(UpperCamelCase				)     ,		self.model_tester.num_hidden_layers				)
  
                      self.assertListEqual(
                          list(attentions[0].shape[-3:]				)     ,		[self.model_tester.num_attention_heads, seq_len, seq_len]     ,		)
                      lowercase__       =				len(UpperCamelCase				)
  
                      # Check attention is always last and order is fine
                      lowercase__       =				True
                      lowercase__       =				True
                      lowercase__       =				model_class(UpperCamelCase				)
                      model.to(UpperCamelCase				)
                      model.eval()
                      with torch.no_grad():
                             lowercase__       =				model(**self._prepare_for_class(UpperCamelCase     ,		UpperCamelCase				)				)
  
                      self.assertEqual(out_len + 1     ,		len(UpperCamelCase				)				)
  
                      lowercase__       =				outputs.attentions
  
                      self.assertEqual(len(UpperCamelCase				)     ,		self.model_tester.num_hidden_layers				)
  
                      self.assertListEqual(
                          list(self_attentions[0].shape[-3:]				)     ,		[self.model_tester.num_attention_heads, seq_len, seq_len]     ,		)
  
  
  
        def    UpperCamelCase__	(self					:					List[Any]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               def check_hidden_states_output(UpperCamelCase					:					Dict     ,		UpperCamelCase					:					Optional[int]     ,		UpperCamelCase					:					Any				):
                      lowercase__       =				model_class(UpperCamelCase				)
                      model.to(UpperCamelCase				)
                      model.eval()
  
                      with torch.no_grad():
                             lowercase__       =				model(**self._prepare_for_class(UpperCamelCase     ,		UpperCamelCase				)				)
  
                      lowercase__       =				outputs.hidden_states
                      lowercase__       =				self.model_tester.num_hidden_layers + 1
                      self.assertEqual(len(UpperCamelCase				)     ,		UpperCamelCase				)
  
                      lowercase__       =				self.model_tester.seq_length
  
                      self.assertListEqual(
                          list(hidden_states[0].shape[-2:]				)     ,		[seq_length, self.model_tester.hidden_size]     ,		)
  
               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(UpperCamelCase     ,		UpperCamelCase     ,		UpperCamelCase				)
  
                      # check that output_hidden_states also work using config
                      del inputs_dict["output_hidden_states"]
                      lowercase__       =				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					:					str				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               pass
  
  
  
  
  
  
  def _SCREAMING_SNAKE_CASE   () -> List[Any]:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				hf_hub_download(
             repo_id='''hf-internal-testing/spaghetti-video'''						,				filename='''eating_spaghetti_32_frames.npy'''						,				repo_type='''dataset''' )
         lowercase__       =				np.load(A )
         return list(A )
  
  @require_torch
  @require_vision
  class 						__lowerCAmelCase		(unittest.TestCase  ):
  
  
  
  
  
        '''simple docstring'''
  
  
  
  
  
  
        @cached_property
        def    UpperCamelCase__	(self					:					Optional[int]				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               return VivitImageProcessor() if is_vision_available() else None
  
  
  
  
  
  
        @slow
        def    UpperCamelCase__	(self					:					int				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				VivitForVideoClassification.from_pretrained('''google/vivit-b-16x2-kinetics400'''				).to(UpperCamelCase				)
  
               lowercase__       =				self.default_image_processor
               lowercase__       =				prepare_video()
               lowercase__       =				image_processor(UpperCamelCase     ,		return_tensors='''pt'''				).to(UpperCamelCase				)
  
               # forward pass
               with torch.no_grad():
                      lowercase__       =				model(**UpperCamelCase				)
  
               # verify the logits
               lowercase__       =				torch.Size((1, 400)				)
               self.assertEqual(outputs.logits.shape     ,		UpperCamelCase				)
  
               # taken from original model
               lowercase__       =				torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]				).to(UpperCamelCase				)
  
               self.assertTrue(torch.allclose(outputs.logits[0, :5]     ,		UpperCamelCase     ,		atol=1E-4				)				)
  
  
  
  
  