code: 
  
  
  '''simple docstring'''
  
  from typing import List, Optional, Tuple
  
  from tokenizers import pre_tokenizers
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_clip import CLIPTokenizer
  
  
  lowerCamelCase							:     Dict								=			logging.get_logger(__name__)
  
  lowerCamelCase							:     Tuple								=			{'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}
  
  lowerCamelCase							:     str								=			{
      'vocab_file': {
          'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json',
      },
      'merges_file': {
          'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt',
      },
      'tokenizer_file': {
          'openai/clip-vit-base-patch32': (
              'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json'
          ),
      },
  }
  
  lowerCamelCase							:     Optional[int]								=			{
      'openai/clip-vit-base-patch32': 77,
  }
  class 						__lowerCAmelCase		(lowercase_  ):
  
  
  
  
  
        '''simple docstring'''
  
  
  
  
  
  
        lowerCAmelCase__      :  str						      =							VOCAB_FILES_NAMES
        lowerCAmelCase__      :  List[Any]						      =							PRETRAINED_VOCAB_FILES_MAP
        lowerCAmelCase__      :  Optional[int]						      =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
        lowerCAmelCase__      :  Dict						      =							["""input_ids""", """attention_mask"""]
        lowerCAmelCase__      :  int						      =							CLIPTokenizer
  
  
  
        def __init__(self					:					Any     ,		UpperCamelCase					:					Dict=None     ,		UpperCamelCase					:					List[str]=None     ,		UpperCamelCase					:					str=None     ,		UpperCamelCase					:					Any="<|endoftext|>"     ,		UpperCamelCase					:					int="<|startoftext|>"     ,		UpperCamelCase					:					Dict="<|endoftext|>"     ,		UpperCamelCase					:					Any="<|endoftext|>"     ,		**UpperCamelCase					:					List[str]     ,		):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               super().__init__(
                   UpperCamelCase     ,		UpperCamelCase     ,		tokenizer_file=UpperCamelCase     ,		unk_token=UpperCamelCase     ,		bos_token=UpperCamelCase     ,		eos_token=UpperCamelCase     ,		pad_token=UpperCamelCase     ,		**UpperCamelCase     ,		)
  
               if not isinstance(self.backend_tokenizer.pre_tokenizer     ,		pre_tokenizers.Sequence				):
                      raise ValueError(
                          '''The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'''
                          ''' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'''
                          ''' to be compatible with this version.The easiest way to do so is'''
                          ''' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'''
                          ''' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'''
                          ''' transformers.'''				)
  
               self._wrap_decode_method_backend_tokenizer()
  
  
  
        def    UpperCamelCase__	(self					:					int				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				self.backend_tokenizer.decode
  
               def new_decode_method(*UpperCamelCase					:					Optional[int]     ,		**UpperCamelCase					:					List[Any]				):
                      lowercase__       =				orig_decode_method(*UpperCamelCase     ,		**UpperCamelCase				)
                      lowercase__       =				text.replace(self.backend_tokenizer.model.end_of_word_suffix     ,		''' '''				).strip()
                      return text
  
               lowercase__       =				new_decode_method
  
  
  
        def    UpperCamelCase__	(self					:					Union[str, Any]     ,		UpperCamelCase					:					List[int]     ,		UpperCamelCase					:					Optional[List[int]] = None				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				[self.bos_token_id]
               lowercase__       =				[self.eos_token_id]
  
               if token_ids_a is None:
                      return bos_token + token_ids_a + eos_token
               return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token
  
  
  
        def    UpperCamelCase__	(self					:					Dict     ,		UpperCamelCase					:					List[int]     ,		UpperCamelCase					:					Optional[List[int]] = None				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				[self.bos_token_id]
               lowercase__       =				[self.eos_token_id]
  
               if token_ids_a is None:
                      return len(bos_token + token_ids_a + eos_token				) * [0]
               return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token				) * [0]
  
  
  
  
  
  
        def    UpperCamelCase__	(self					:					int     ,		UpperCamelCase					:					str     ,		UpperCamelCase					:					Optional[str] = None				):
  
               '''simple docstring'''
  
  
  
  
  
  
  
               lowercase__       =				self._tokenizer.model.save(UpperCamelCase     ,		name=UpperCamelCase				)
               return tuple(UpperCamelCase				)
  
  
  
  
  
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				)				)
  
  
  
  
  