


'''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				)








'''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				)				)




