






"""simple docstring"""


import os
from typing import List, Union

import tensorflow as tf
from tensorflow_text import BertTokenizer as BertTokenizerLayer
from tensorflow_text import FastBertTokenizer, ShrinkLongestTrimmer, case_fold_utfa, combine_segments, pad_model_inputs

from .tokenization_bert import BertTokenizer


class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	List[str],			_lowerCamelCase					:	List,			_lowerCamelCase					:	bool,			_lowerCamelCase					:	int = None,			_lowerCamelCase					:	int = None,			_lowerCamelCase					:	int = None,			_lowerCamelCase					:	str = "longest",			_lowerCamelCase					:	bool = True,			_lowerCamelCase					:	int = 5_12,			_lowerCamelCase					:	int = None,			_lowerCamelCase					:	bool = True,			_lowerCamelCase					:	bool = True,			_lowerCamelCase					:	bool = True,			**_lowerCamelCase					:	int,			):

     '''simple docstring'''
     super().__init__()
     if use_fast_bert_tokenizer:
       __A		     =					FastBertTokenizer(
           _lowerCamelCase,			token_out_type=tf.intaa,			lower_case_nfd_strip_accents=_lowerCamelCase,			**_lowerCamelCase    )
     else:
       __A		     =					tf.lookup.StaticVocabularyTable(
           tf.lookup.KeyValueTensorInitializer(
               keys=_lowerCamelCase,			key_dtype=tf.string,			values=tf.range(tf.size(_lowerCamelCase,			out_type=tf.intaa    ),			dtype=tf.intaa    ),			value_dtype=tf.intaa,			),			num_oov_buckets=1,			)
       __A		     =					BertTokenizerLayer(
           _lowerCamelCase,			token_out_type=tf.intaa,			lower_case=_lowerCamelCase,			**_lowerCamelCase    )

     __A		     =					vocab_list
     __A		     =					do_lower_case
     __A		     =					cls_token_id or vocab_list.index('''[CLS]'''    )
     __A		     =					sep_token_id or vocab_list.index('''[SEP]'''    )
     __A		     =					pad_token_id or vocab_list.index('''[PAD]'''    )
     __A		     =					ShrinkLongestTrimmer(max_length - 3,			axis=1    )  # Allow room for special tokens
     __A		     =					max_length
     __A		     =					padding
     __A		     =					truncation
     __A		     =					pad_to_multiple_of
     __A		     =					return_token_type_ids
     __A		     =					return_attention_mask


   @classmethod
   def 							_SCREAMING_SNAKE_CASE							(      cls					:	int,			_lowerCamelCase					:	"PreTrainedTokenizerBase",			**_lowerCamelCase					:	List[Any]    ):  # noqa: F821

     '''simple docstring'''
     __A		     =					kwargs.pop('''do_lower_case''',			_lowerCamelCase    )
     __A		     =					tokenizer.do_lower_case if do_lower_case is None else do_lower_case
     __A		     =					kwargs.pop('''cls_token_id''',			_lowerCamelCase    )
     __A		     =					tokenizer.cls_token_id if cls_token_id is None else cls_token_id
     __A		     =					kwargs.pop('''sep_token_id''',			_lowerCamelCase    )
     __A		     =					tokenizer.sep_token_id if sep_token_id is None else sep_token_id
     __A		     =					kwargs.pop('''pad_token_id''',			_lowerCamelCase    )
     __A		     =					tokenizer.pad_token_id if pad_token_id is None else pad_token_id

     __A		     =					tokenizer.get_vocab()
     __A		     =					sorted([(wordpiece, idx) for wordpiece, idx in vocab.items()],			key=lambda _lowerCamelCase    : x[1]    )
     __A		     =					[entry[0] for entry in vocab]
     return cls(
         vocab_list=_lowerCamelCase,			do_lower_case=_lowerCamelCase,			cls_token_id=_lowerCamelCase,			sep_token_id=_lowerCamelCase,			pad_token_id=_lowerCamelCase,			**_lowerCamelCase,			)


   @classmethod
   def 							_SCREAMING_SNAKE_CASE							(      cls					:	Optional[Any],			_lowerCamelCase					:	Union[str, os.PathLike],			*_lowerCamelCase					:	Any,			**_lowerCamelCase					:	List[str]    ):

     '''simple docstring'''
     try:
       __A		     =					BertTokenizer.from_pretrained(_lowerCamelCase,			*_lowerCamelCase,			**_lowerCamelCase    )
     except:  # noqa: E722
       from .tokenization_bert_fast import BertTokenizerFast

       __A		     =					BertTokenizerFast.from_pretrained(_lowerCamelCase,			*_lowerCamelCase,			**_lowerCamelCase    )
     return cls.from_tokenizer(_lowerCamelCase,			**_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     if self.do_lower_case:
       __A		     =					case_fold_utfa(_lowerCamelCase    )
     __A		     =					self.tf_tokenizer.tokenize(_lowerCamelCase    )
     return tokens.merge_dims(1,			-1    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	Any,			_lowerCamelCase					:	Dict=None,			_lowerCamelCase					:	Optional[int]=None,			_lowerCamelCase					:	Union[str, Any]=None,			_lowerCamelCase					:	Any=None,			_lowerCamelCase					:	List[Any]=None,			_lowerCamelCase					:	str=None,			_lowerCamelCase					:	Dict=None,			):

     '''simple docstring'''
     if padding is None:
       __A		     =					self.padding
     if padding not in ("longest", "max_length"):
       raise ValueError('''Padding must be either \'longest\' or \'max_length\'!'''    )
     if max_length is not None and text_pair is not None:
       # Because we have to instantiate a Trimmer to do it properly
       raise ValueError('''max_length cannot be overridden at call time when truncating paired texts!'''    )
     if max_length is None:
       __A		     =					self.max_length
     if truncation is None:
       __A		     =					self.truncation
     if pad_to_multiple_of is None:
       __A		     =					self.pad_to_multiple_of
     if return_token_type_ids is None:
       __A		     =					self.return_token_type_ids
     if return_attention_mask is None:
       __A		     =					self.return_attention_mask
     if not isinstance(_lowerCamelCase,			tf.Tensor    ):
       __A		     =					tf.convert_to_tensor(_lowerCamelCase    )
     if text_pair is not None and not isinstance(_lowerCamelCase,			tf.Tensor    ):
       __A		     =					tf.convert_to_tensor(_lowerCamelCase    )
     if text_pair is not None:
       if text.shape.rank > 1:
         raise ValueError('''text argument should not be multidimensional when a text pair is supplied!'''    )
       if text_pair.shape.rank > 1:
         raise ValueError('''text_pair should not be multidimensional!'''    )
     if text.shape.rank == 2:
       __A     ,       __A		     =					text[:, 0], text[:, 1]
     __A		     =					self.unpaired_tokenize(_lowerCamelCase    )
     if text_pair is None:  # Unpaired text
       if truncation:
         __A		     =					text[:, : max_length - 2]  # Allow room for special tokens
       __A     ,       __A		     =					combine_segments(
           (text,),			start_of_sequence_id=self.cls_token_id,			end_of_segment_id=self.sep_token_id    )
     else:  # Paired text
       __A		     =					self.unpaired_tokenize(_lowerCamelCase    )
       if truncation:
         __A     ,       __A		     =					self.paired_trimmer.trim([text, text_pair]    )
       __A     ,       __A		     =					combine_segments(
           (text, text_pair),			start_of_sequence_id=self.cls_token_id,			end_of_segment_id=self.sep_token_id    )
     if padding == "longest":
       __A		     =					input_ids.bounding_shape(axis=1    )
       if pad_to_multiple_of is not None:
         # No ceiling division in tensorflow, so we negate floordiv instead
         __A		     =					pad_to_multiple_of * (-tf.math.floordiv(-pad_length,			_lowerCamelCase    ))
     else:
       __A		     =					max_length

     __A     ,       __A		     =					pad_model_inputs(_lowerCamelCase,			max_seq_length=_lowerCamelCase,			pad_value=self.pad_token_id    )
     __A		     =					{'''input_ids''': input_ids}
     if return_attention_mask:
       __A		     =					attention_mask
     if return_token_type_ids:
       __A     ,       __A		     =					pad_model_inputs(
           _lowerCamelCase,			max_seq_length=_lowerCamelCase,			pad_value=self.pad_token_id    )
       __A		     =					token_type_ids
     return output






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     return {
         "vocab_list": self.vocab_list,
         "do_lower_case": self.do_lower_case,
         "cls_token_id": self.cls_token_id,
         "sep_token_id": self.sep_token_id,
         "pad_token_id": self.pad_token_id,
     }








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      _lowercase					:


       """simple docstring"""




       def __init__(  self				:     Union[str, Any]   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     int=2   , __lowerCamelCase				:     Any=True   , __lowerCamelCase				:     Union[str, Any]=True   , __lowerCamelCase				:     int=10   , __lowerCamelCase				:     str=10   , __lowerCamelCase				:     int=8   , __lowerCamelCase				:     Optional[int]=[2, 4, 4]   , __lowerCamelCase				:     List[Any]=3   , __lowerCamelCase				:     str=768   , __lowerCamelCase				:     int=5   , __lowerCamelCase				:     Any=4   , __lowerCamelCase				:     int=37   , __lowerCamelCase				:     int="gelu_fast"   , __lowerCamelCase				:     int=0.0   , __lowerCamelCase				:     Optional[int]=0.0   , __lowerCamelCase				:     Union[str, Any]=0.0_2   , __lowerCamelCase				:     Any=1E-0_6   , __lowerCamelCase				:     Optional[int]=True   , __lowerCamelCase				:     Tuple=None   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    parent
             lowerCamelCase__						:							int       =    batch_size
             lowerCamelCase__						:							List[Any]       =    is_training
             lowerCamelCase__						:							Optional[Any]       =    use_labels
             lowerCamelCase__						:							List[str]       =    num_labels
             lowerCamelCase__						:							Union[str, Any]       =    image_size
             lowerCamelCase__						:							Tuple       =    num_frames
             lowerCamelCase__						:							Union[str, Any]       =    tubelet_size
             lowerCamelCase__						:							Optional[int]       =    num_channels
             lowerCamelCase__						:							Any       =    hidden_size
             lowerCamelCase__						:							Optional[Any]       =    num_hidden_layers
             lowerCamelCase__						:							List[str]       =    num_attention_heads
             lowerCamelCase__						:							List[Any]       =    intermediate_size
             lowerCamelCase__						:							Union[str, Any]       =    hidden_act
             lowerCamelCase__						:							Any       =    hidden_dropout_prob
             lowerCamelCase__						:							Union[str, Any]       =    attention_probs_dropout_prob
             lowerCamelCase__						:							List[Any]       =    initializer_range
             lowerCamelCase__						:							Optional[int]       =    layer_norm_eps
             lowerCamelCase__						:							Tuple       =    qkv_bias
             lowerCamelCase__						:							List[Any]       =    scope

             lowerCamelCase__						:							Union[str, Any]       =    (
                 (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 		lowerCAmelCase	(  self				:     List[Any]			):


             '''simple docstring'''



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

             lowerCamelCase__						:							Optional[int]       =    None
             if self.use_labels:
                   lowerCamelCase__						:							Optional[Any]       =    ids_tensor([self.batch_size]   , self.num_labels			)

             lowerCamelCase__						:							Any       =    self.get_config()

             return config, pixel_values, labels





       def 		lowerCAmelCase	(  self				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    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   , )
             lowerCamelCase__						:							Union[str, Any]       =    self.num_labels
             return config





       def 		lowerCAmelCase	(  self				:     Optional[int]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    VivitModel(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Any       =    model(__lowerCamelCase			)
             self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)			)





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Optional[int]			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    VivitForVideoClassification(__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()

             lowerCamelCase__						:							List[str]       =    model(__lowerCamelCase			)

             # verify the logits shape
             lowerCamelCase__						:							Optional[int]       =    torch.Size((self.batch_size, self.num_labels)			)
             self.parent.assertEqual(result.logits.shape   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Optional[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[int]       =    self.prepare_config_and_inputs()
             lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__						:							Any       =    config_and_inputs
             lowerCamelCase__						:							int       =    {"pixel_values": pixel_values}
             return config, inputs_dict







@require_torch
class      _lowercase					(				lowercase__				,    unittest.TestCase):


       """simple docstring"""




       A__   		=     (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

       A__   		=     False
       A__   		=     False
       A__   		=     False
       A__   		=     False





       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    VivitModelTester(self			)
             lowerCamelCase__						:							Any       =    ConfigTester(self   , config_class=__lowerCamelCase   , has_text_modality=__lowerCamelCase   , hidden_size=37			)





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Union[str, Any]=False			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    copy.deepcopy(__lowerCamelCase			)

             if return_labels:
                   if model_class in get_values(__lowerCamelCase			):
                         lowerCamelCase__						:							List[Any]       =    torch.zeros(
                             self.model_tester.batch_size   , dtype=torch.long   , device=__lowerCamelCase			)

             return inputs_dict





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       @unittest.skip(reason="Vivit does not use inputs_embeds"			)
       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             pass





       def 		lowerCAmelCase	(  self				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							int       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							str       =    model_class(__lowerCamelCase			)
                   self.assertIsInstance(model.get_input_embeddings()   , (nn.Module)			)
                   lowerCamelCase__						:							Dict       =    model.get_output_embeddings()
                   self.assertTrue(x is None or isinstance(__lowerCamelCase   , nn.Linear			)			)





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



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

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

                   lowerCamelCase__						:							Any       =    ["pixel_values", "head_mask"]
                   self.assertListEqual(arg_names[:2]   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_video_classification(*__lowerCamelCase			)





       @slow
       def 		lowerCAmelCase	(  self				:     List[Any]			):


             '''simple docstring'''



             for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   lowerCamelCase__						:							str       =    VivitModel.from_pretrained(__lowerCamelCase			)
                   self.assertIsNotNone(__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs_for_common()
             lowerCamelCase__						:							List[str]       =    True

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							Any       =    self.model_tester.seq_length

                   lowerCamelCase__						:							List[str]       =    True
                   lowerCamelCase__						:							List[str]       =    False
                   lowerCamelCase__						:							Tuple       =    True
                   lowerCamelCase__						:							Dict       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							str       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)
                   lowerCamelCase__						:							Dict       =    outputs.attentions
                   self.assertEqual(len(__lowerCamelCase			)   , self.model_tester.num_hidden_layers			)

                   # check that output_attentions also work using config
                   del inputs_dict["output_attentions"]
                   lowerCamelCase__						:							List[str]       =    True
                   lowerCamelCase__						:							Union[str, Any]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							List[str]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)
                   lowerCamelCase__						:							Optional[int]       =    outputs.attentions
                   self.assertEqual(len(__lowerCamelCase			)   , self.model_tester.num_hidden_layers			)

                   self.assertListEqual(
                       list(attentions[0].shape[-3:]			)   , [self.model_tester.num_attention_heads, seq_len, seq_len]   , )
                   lowerCamelCase__						:							int       =    len(__lowerCamelCase			)

                   # Check attention is always last and order is fine
                   lowerCamelCase__						:							Optional[int]       =    True
                   lowerCamelCase__						:							str       =    True
                   lowerCamelCase__						:							Optional[int]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							Union[str, Any]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)

                   self.assertEqual(out_len + 1   , len(__lowerCamelCase			)			)

                   lowerCamelCase__						:							Any       =    outputs.attentions

                   self.assertEqual(len(__lowerCamelCase			)   , 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 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             def check_hidden_states_output(__lowerCamelCase				:     str   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Tuple			):
                   lowerCamelCase__						:							Union[str, Any]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()

                   with torch.no_grad():
                         lowerCamelCase__						:							Optional[Any]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)

                   lowerCamelCase__						:							List[Any]       =    outputs.hidden_states
                   lowerCamelCase__						:							Optional[int]       =    self.model_tester.num_hidden_layers + 1
                   self.assertEqual(len(__lowerCamelCase			)   , __lowerCamelCase			)

                   lowerCamelCase__						:							Optional[int]       =    self.model_tester.seq_length

                   self.assertListEqual(
                       list(hidden_states[0].shape[-2:]			)   , [seq_length, self.model_tester.hidden_size]   , )

             lowerCamelCase__       ,  lowerCamelCase__						:							Optional[Any]       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							Tuple       =    True
                   check_hidden_states_output(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase			)

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   lowerCamelCase__						:							int       =    True

                   check_hidden_states_output(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase			)





       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."			)
       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             pass



def  lowercase_						(						):

      """simple docstring"""




      lowerCamelCase__						:							str       =    hf_hub_download(
          repo_id="hf-internal-testing/spaghetti-video"       ,   filename="eating_spaghetti_32_frames.npy"       ,   repo_type="dataset"		)
      lowerCamelCase__						:							Union[str, Any]       =    np.load(_A		)
      return list(_A		)







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


       """simple docstring"""




       @cached_property
       def 		lowerCAmelCase	(  self				:     str			):


             '''simple docstring'''



             return VivitImageProcessor() if is_vision_available() else None





       @slow
       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[int]       =    VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400"			).to(__lowerCamelCase			)

             lowerCamelCase__						:							Tuple       =    self.default_image_processor
             lowerCamelCase__						:							List[str]       =    prepare_video()
             lowerCamelCase__						:							Optional[int]       =    image_processor(__lowerCamelCase   , return_tensors="pt"			).to(__lowerCamelCase			)

             # forward pass
             with torch.no_grad():
                   lowerCamelCase__						:							Optional[int]       =    model(**__lowerCamelCase			)

             # verify the logits
             lowerCamelCase__						:							str       =    torch.Size((1, 400)			)
             self.assertEqual(outputs.logits.shape   , __lowerCamelCase			)

             # taken from original model
             lowerCamelCase__						:							str       =    torch.tensor([-1.0_5_4_3, 2.0_7_6_4, -0.2_1_0_4, 0.4_4_3_9, -0.9_6_5_8]			).to(__lowerCamelCase			)

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


