


'''simple docstring'''

lowerCamelCase							:     Optional[int]								=			'\n# Transformers installation\n! pip install transformers datasets evaluate\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

lowerCamelCase							:     Optional[int]								=			[{'type': 'code', 'content': INSTALL_CONTENT}]
lowerCamelCase							:     Dict								=			{
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}



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




