
'''simple docstring'''







import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import EfficientNetForImageClassification, EfficientNetModel
							from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor






class 					lowerCAmelCase__  :






					def __init__(  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE=13							,				__SCREAMING_SNAKE_CASE=32							,				__SCREAMING_SNAKE_CASE=3							,				__SCREAMING_SNAKE_CASE=[3, 3, 5]							,				__SCREAMING_SNAKE_CASE=[32, 16, 24]							,				__SCREAMING_SNAKE_CASE=[16, 24, 40]							,				__SCREAMING_SNAKE_CASE=[1, 1, 2]							,				__SCREAMING_SNAKE_CASE=[1, 1, 2]							,				__SCREAMING_SNAKE_CASE=[1, 6, 6]							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=37							,				__SCREAMING_SNAKE_CASE="gelu"							,				__SCREAMING_SNAKE_CASE=10							,				):


											"""simple docstring"""





											lowercase_      :	List[Any]						=			parent
											lowercase_      :	Any						=			batch_size
											lowercase_      :	Optional[int]						=			image_size
											lowercase_      :	int						=			num_channels
											lowercase_      :	Optional[Any]						=			kernel_sizes
											lowercase_      :	Dict						=			in_channels
											lowercase_      :	Any						=			out_channels
											lowercase_      :	Tuple						=			strides
											lowercase_      :	Optional[int]						=			num_block_repeats
											lowercase_      :	Any						=			expand_ratios
											lowercase_      :	Tuple						=			is_training
											lowercase_      :	Tuple						=			hidden_act
											lowercase_      :	int						=			num_labels
											lowercase_      :	List[str]						=			use_labels






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Union[str, Any]						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

											lowercase_      :	Any						=			None
											if self.use_labels:
																	lowercase_      :	List[Any]						=			ids_tensor([self.batch_size]							,				self.num_labels						)

											lowercase_      :	Optional[int]						=			self.get_config()
											return config, pixel_values, labels






					def       _snake_case       (  self						):


											"""simple docstring"""





											return EfficientNetConfig(
											    num_channels=self.num_channels							,				kernel_sizes=self.kernel_sizes							,				in_channels=self.in_channels							,				out_channels=self.out_channels							,				strides=self.strides							,				num_block_repeats=self.num_block_repeats							,				expand_ratios=self.expand_ratios							,				hidden_act=self.hidden_act							,				num_labels=self.num_labels							,				)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	Tuple						=			EfficientNetModel(config=__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	List[Any]						=			model(__SCREAMING_SNAKE_CASE						)
											# expected last hidden states: B, C, H // 4, W // 4
											self.parent.assertEqual(
											    result.last_hidden_state.shape							,				(self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)							,				)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	Dict						=			EfficientNetForImageClassification(__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	Any						=			model(__SCREAMING_SNAKE_CASE							,				labels=__SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_labels)						)






					def       _snake_case       (  self						):


											"""simple docstring"""





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







@require_torch
class 					lowerCAmelCase__  (    lowerCamelCase_       ,		lowerCamelCase_       ,		unittest.TestCase	):
					lowerCAmelCase_	  =	(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
					lowerCAmelCase_	  =	(
					    {'''feature-extraction''': EfficientNetModel, '''image-classification''': EfficientNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Dict						=			EfficientNetModelTester(self						)
											lowercase_      :	List[Any]						=			ConfigTester(
											    self							,				config_class=__SCREAMING_SNAKE_CASE							,				has_text_modality=__SCREAMING_SNAKE_CASE							,				hidden_size=37						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()






					def       _snake_case       (  self						):


											"""simple docstring"""





											return






					@unittest.skip(reason='''EfficientNet does not use inputs_embeds'''						)
					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					@unittest.skip(reason='''EfficientNet does not support input and output embeddings'''						)
					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					@unittest.skip(reason='''EfficientNet does not use feedforward chunking'''						)
					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_		,					lowercase_      :	Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_      :	List[str]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	lowercase_      :	str						=			inspect.signature(model.forward						)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowercase_      :	Optional[Any]						=			[*signature.parameters.keys()]

																	lowercase_      :	Optional[int]						=			['''pixel_values''']
																	self.assertListEqual(arg_names[:1]							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	str						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											def check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):
																	lowercase_      :	str						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.eval()

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

																	lowercase_      :	List[str]						=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
																	lowercase_      :	List[str]						=			sum(config.num_block_repeats						) * 4
																	self.assertEqual(len(__SCREAMING_SNAKE_CASE						)							,				__SCREAMING_SNAKE_CASE						)

																	# EfficientNet's feature maps are of shape (batch_size, num_channels, height, width)
																	self.assertListEqual(
																	    list(hidden_states[0].shape[-2:]						)							,				[self.model_tester.image_size // 2, self.model_tester.image_size // 2]							,				)

											lowercase_		,					lowercase_      :	Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_      :	Optional[int]						=			True
																	check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)

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

																	check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	List[str]						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE						)






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


											"""simple docstring"""





											pass






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase_      :	Any						=			EfficientNetModel.from_pretrained(__SCREAMING_SNAKE_CASE						)
																	self.assertIsNotNone(__SCREAMING_SNAKE_CASE						)






					@is_pipeline_test
					@require_vision
					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											super().test_pipeline_image_classification()







def    snake_case_						(							):



						"""simple docstring"""





						lowercase_      :	Tuple						=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
						return image






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






					@cached_property
					def       _snake_case       (  self						):


											"""simple docstring"""





											return AutoImageProcessor.from_pretrained('''google/efficientnet-b7'''						) if is_vision_available() else None






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Dict						=			EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''						).to(__SCREAMING_SNAKE_CASE						)

											lowercase_      :	Union[str, Any]						=			self.default_image_processor
											lowercase_      :	str						=			prepare_img()
											lowercase_      :	Union[str, Any]						=			image_processor(images=__SCREAMING_SNAKE_CASE							,				return_tensors='''pt'''						).to(__SCREAMING_SNAKE_CASE						)

											# forward pass
											with torch.no_grad():
																	lowercase_      :	str						=			model(**__SCREAMING_SNAKE_CASE						)

											# verify the logits
											lowercase_      :	Any						=			torch.Size((1, 10_00)						)
											self.assertEqual(outputs.logits.shape							,				__SCREAMING_SNAKE_CASE						)

											lowercase_      :	Any						=			torch.tensor([0.0_001, 0.0_002, 0.0_002]						).to(__SCREAMING_SNAKE_CASE						)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]							,				__SCREAMING_SNAKE_CASE							,				atol=1E-4						)						)





'''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__  :






					def __init__(  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE=2							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=10							,				__SCREAMING_SNAKE_CASE=10							,				__SCREAMING_SNAKE_CASE=8							,				__SCREAMING_SNAKE_CASE=[2, 4, 4]							,				__SCREAMING_SNAKE_CASE=3							,				__SCREAMING_SNAKE_CASE=7_68							,				__SCREAMING_SNAKE_CASE=5							,				__SCREAMING_SNAKE_CASE=4							,				__SCREAMING_SNAKE_CASE=37							,				__SCREAMING_SNAKE_CASE="gelu_fast"							,				__SCREAMING_SNAKE_CASE=0.0							,				__SCREAMING_SNAKE_CASE=0.0							,				__SCREAMING_SNAKE_CASE=0.02							,				__SCREAMING_SNAKE_CASE=1E-0_6							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=None							,				):


											"""simple docstring"""





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

											lowercase_      :	Dict						=			(
											    (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       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Tuple						=			floats_tensor(
											    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]						)

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

											lowercase_      :	Union[str, Any]						=			self.get_config()

											return config, pixel_values, labels






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Optional[int]						=			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_      :	Optional[Any]						=			self.num_labels
											return config






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	str						=			VivitModel(config=__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	Union[str, Any]						=			model(__SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.last_hidden_state.shape							,				(self.batch_size, self.seq_length, self.hidden_size)						)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	List[Any]						=			VivitForVideoClassification(__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()

											lowercase_      :	Union[str, Any]						=			model(__SCREAMING_SNAKE_CASE						)

											# verify the logits shape
											lowercase_      :	Union[str, Any]						=			torch.Size((self.batch_size, self.num_labels)						)
											self.parent.assertEqual(result.logits.shape							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	int						=			self.prepare_config_and_inputs()
											lowercase_		,					lowercase_		,					lowercase_      :	Dict						=			config_and_inputs
											lowercase_      :	List[str]						=			{'''pixel_values''': pixel_values}
											return config, inputs_dict







@require_torch
class 					lowerCAmelCase__  (    lowerCamelCase_       ,		unittest.TestCase	):
					lowerCAmelCase_	  =	(VivitModel, VivitForVideoClassification) if is_torch_available() else ()

					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	int						=			VivitModelTester(self						)
											lowercase_      :	Optional[int]						=			ConfigTester(self							,				config_class=__SCREAMING_SNAKE_CASE							,				has_text_modality=__SCREAMING_SNAKE_CASE							,				hidden_size=37						)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE=False						):


											"""simple docstring"""





											lowercase_      :	str						=			copy.deepcopy(__SCREAMING_SNAKE_CASE						)

											if return_labels:
																	if model_class in get_values(__SCREAMING_SNAKE_CASE						):
																							lowercase_      :	List[str]						=			torch.zeros(
																							    self.model_tester.batch_size							,				dtype=torch.long							,				device=__SCREAMING_SNAKE_CASE						)

											return inputs_dict






					def       _snake_case       (  self						):


											"""simple docstring"""





											self.config_tester.run_common_tests()






					@unittest.skip(reason='''Vivit does not use inputs_embeds'''						)
					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					def       _snake_case       (  self						):


											"""simple docstring"""





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

											for model_class in self.all_model_classes:
																	lowercase_      :	Optional[Any]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	self.assertIsInstance(model.get_input_embeddings()							,				(nn.Module)						)
																	lowercase_      :	int						=			model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE							,				nn.Linear						)						)






					def       _snake_case       (  self						):


											"""simple docstring"""





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

											for model_class in self.all_model_classes:
																	lowercase_      :	Optional[int]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	lowercase_      :	Dict						=			inspect.signature(model.forward						)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowercase_      :	Any						=			[*signature.parameters.keys()]

																	lowercase_      :	str						=			['''pixel_values''', '''head_mask''']
																	self.assertListEqual(arg_names[:2]							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Union[str, Any]						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	int						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_video_classification(*__SCREAMING_SNAKE_CASE						)






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase_      :	Union[str, Any]						=			VivitModel.from_pretrained(__SCREAMING_SNAKE_CASE						)
																	self.assertIsNotNone(__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_		,					lowercase_      :	Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()
											lowercase_      :	Union[str, Any]						=			True

											for model_class in self.all_model_classes:
																	lowercase_      :	int						=			self.model_tester.seq_length

																	lowercase_      :	Optional[Any]						=			True
																	lowercase_      :	int						=			False
																	lowercase_      :	Union[str, Any]						=			True
																	lowercase_      :	str						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.eval()
																	with torch.no_grad():
																							lowercase_      :	List[str]						=			model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)						)
																	lowercase_      :	Optional[Any]						=			outputs.attentions
																	self.assertEqual(len(__SCREAMING_SNAKE_CASE						)							,				self.model_tester.num_hidden_layers						)

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

																	self.assertListEqual(
																	    list(attentions[0].shape[-3:]						)							,				[self.model_tester.num_attention_heads, seq_len, seq_len]							,				)
																	lowercase_      :	Dict						=			len(__SCREAMING_SNAKE_CASE						)

																	# Check attention is always last and order is fine
																	lowercase_      :	Any						=			True
																	lowercase_      :	Any						=			True
																	lowercase_      :	int						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.eval()
																	with torch.no_grad():
																							lowercase_      :	Any						=			model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)						)

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

																	lowercase_      :	List[str]						=			outputs.attentions

																	self.assertEqual(len(__SCREAMING_SNAKE_CASE						)							,				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       _snake_case       (  self						):


											"""simple docstring"""





											def check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):
																	lowercase_      :	List[str]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.eval()

																	with torch.no_grad():
																							lowercase_      :	List[Any]						=			model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)						)

																	lowercase_      :	List[str]						=			outputs.hidden_states
																	lowercase_      :	Any						=			self.model_tester.num_hidden_layers + 1
																	self.assertEqual(len(__SCREAMING_SNAKE_CASE						)							,				__SCREAMING_SNAKE_CASE						)

																	lowercase_      :	List[Any]						=			self.model_tester.seq_length

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

											lowercase_		,					lowercase_      :	List[str]						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_      :	int						=			True
																	check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	lowercase_      :	List[Any]						=			True

																	check_hidden_states_output(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)






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


											"""simple docstring"""





											pass







def    snake_case_						(							):



						"""simple docstring"""





						lowercase_      :	List[str]						=			hf_hub_download(
						    repo_id='''hf-internal-testing/spaghetti-video''' , filename='''eating_spaghetti_32_frames.npy''' , repo_type='''dataset'''				)
						lowercase_      :	List[str]						=			np.load(__SCREAMING_SNAKE_CASE				)
						return list(__SCREAMING_SNAKE_CASE				)






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






					@cached_property
					def       _snake_case       (  self						):


											"""simple docstring"""





											return VivitImageProcessor() if is_vision_available() else None






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	List[str]						=			VivitForVideoClassification.from_pretrained('''google/vivit-b-16x2-kinetics400'''						).to(__SCREAMING_SNAKE_CASE						)

											lowercase_      :	Optional[int]						=			self.default_image_processor
											lowercase_      :	Union[str, Any]						=			prepare_video()
											lowercase_      :	str						=			image_processor(__SCREAMING_SNAKE_CASE							,				return_tensors='''pt'''						).to(__SCREAMING_SNAKE_CASE						)

											# forward pass
											with torch.no_grad():
																	lowercase_      :	Any						=			model(**__SCREAMING_SNAKE_CASE						)

											# verify the logits
											lowercase_      :	Any						=			torch.Size((1, 4_00)						)
											self.assertEqual(outputs.logits.shape							,				__SCREAMING_SNAKE_CASE						)

											# taken from original model
											lowercase_      :	Any						=			torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]						).to(__SCREAMING_SNAKE_CASE						)

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



