


"""simple docstring"""






import math
import warnings
from dataclasses import dataclass
from typing import List, Optional, Tuple, Union

import numpy as np
import torch
from scipy import integrate

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin


@dataclass
# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->LMSDiscrete
class 			SCREAMING_SNAKE_CASE_  (   _lowercase):




							'''simple docstring'''





							__magic_name__					:     torch.FloatTensor
							__magic_name__					:     Optional[torch.FloatTensor]				  =  None



def 			A__		(					_UpperCAmelCase    :      List[str]				,    _UpperCAmelCase    :      str=0.9_9_9				,    _UpperCAmelCase    :      List[Any]="cosine"				,    )							->	Tuple:

	'''simple docstring'''


	if alpha_transform_type == "cosine":

		def alpha_bar_fn(_UpperCAmelCase    :      List[str]	):
			return math.cos((t + 0.0_0_8) / 1.0_0_8 * math.pi / 2	) ** 2

	elif alpha_transform_type == "exp":

		def alpha_bar_fn(_UpperCAmelCase    :      Optional[int]	):
			return math.exp(t * -1_2.0	)

	else:
		raise ValueError(F"""Unsupported alpha_tranform_type: {alpha_transform_type}"""	)

	snake_case__  :						Any		=      []
	for i in range(_UpperCAmelCase	):
		snake_case__  :						Optional[Any]		=      i / num_diffusion_timesteps
		snake_case__  :						Dict		=      (i + 1) / num_diffusion_timesteps
		betas.append(min(1 - alpha_bar_fn(_UpperCAmelCase	) / alpha_bar_fn(_UpperCAmelCase	)				,    _UpperCAmelCase	)	)
	return torch.tensor(_UpperCAmelCase				,    dtype=torch.floataa	)



class 			SCREAMING_SNAKE_CASE_  (   _lowercase	,      _lowercase):




							'''simple docstring'''





							__magic_name__					:     Any				  =  [e.name for e in KarrasDiffusionSchedulers]
							__magic_name__					:     Optional[Any]				  =  1




							@register_to_config
							def __init__(						self	,					lowerCamelCase__ = 1_000	,					lowerCamelCase__ = 0.00_01	,					lowerCamelCase__ = 0.02	,					lowerCamelCase__ = "linear"	,					lowerCamelCase__ = None	,					lowerCamelCase__ = False	,					lowerCamelCase__ = "epsilon"	,					lowerCamelCase__ = "linspace"	,					lowerCamelCase__ = 0	,					)   ->	Any:







								'''simple docstring'''




								if trained_betas is not None:
									snake_case__  :						List[Any]		=      torch.tensor(lowerCamelCase__	,					dtype=torch.floataa)
								elif beta_schedule == "linear":
									snake_case__  :						Union[str, Any]		=      torch.linspace(lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__	,					dtype=torch.floataa)
								elif beta_schedule == "scaled_linear":
									# this schedule is very specific to the latent diffusion model.
									snake_case__  :						Optional[int]		=      (
									    torch.linspace(beta_start**0.5	,					beta_end**0.5	,					lowerCamelCase__	,					dtype=torch.floataa) ** 2
									)
								elif beta_schedule == "squaredcos_cap_v2":
									# Glide cosine schedule
									snake_case__  :						Tuple		=      betas_for_alpha_bar(lowerCamelCase__)
								else:
									raise NotImplementedError(f"""{beta_schedule} does is not implemented for {self.__class__}""")

								snake_case__  :						Union[str, Any]		=      1.0 - self.betas
								snake_case__  :						Optional[int]		=      torch.cumprod(self.alphas	,					dim=0)

								snake_case__  :						Any		=      np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
								snake_case__  :						Union[str, Any]		=      np.concatenate([sigmas[::-1], [0.0]]).astype(np.floataa)
								snake_case__  :						str		=      torch.from_numpy(lowerCamelCase__)

								# setable values
								snake_case__  :						str		=      None
								snake_case__  :						Dict		=      use_karras_sigmas
								self.set_timesteps(lowerCamelCase__	,					lowerCamelCase__)
								snake_case__  :						Dict		=      []
								snake_case__  :						int		=      False




							@property
							def        UpperCAmelCase (						self)   ->	int:







								'''simple docstring'''




								if self.config.timestep_spacing in ["linspace", "trailing"]:
									return self.sigmas.max()

								return (self.sigmas.max() ** 2 + 1) ** 0.5




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__)   ->	torch.FloatTensor:







								'''simple docstring'''




								if isinstance(lowerCamelCase__	,					torch.Tensor):
									snake_case__  :						int		=      timestep.to(self.timesteps.device)
								snake_case__  :						Dict		=      (self.timesteps == timestep).nonzero().item()
								snake_case__  :						int		=      self.sigmas[step_index]
								snake_case__  :						Any		=      sample / ((sigma**2 + 1) ** 0.5)
								snake_case__  :						int		=      True
								return sample




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__)   ->	Optional[int]:







								'''simple docstring'''




								def lms_derivative(lowerCamelCase__):
									snake_case__  :						Any		=      1.0
									for k in range(lowerCamelCase__):
										if current_order == k:
											continue
										prod *= (tau - self.sigmas[t - k]) / (self.sigmas[t - current_order] - self.sigmas[t - k])
									return prod

								snake_case__  :						List[str]		=      integrate.quad(lowerCamelCase__	,					self.sigmas[t]	,					self.sigmas[t + 1]	,					epsrel=1E-4)[0]

								return integrated_coeff




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__ = None)   ->	Union[str, Any]:







								'''simple docstring'''




								snake_case__  :						Union[str, Any]		=      num_inference_steps

								# "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
								if self.config.timestep_spacing == "linspace":
									snake_case__  :						int		=      np.linspace(0	,					self.config.num_train_timesteps - 1	,					lowerCamelCase__	,					dtype=lowerCamelCase__)[
									    ::-1
									].copy()
								elif self.config.timestep_spacing == "leading":
									snake_case__  :						Tuple		=      self.config.num_train_timesteps // self.num_inference_steps
									# creates integer timesteps by multiplying by ratio
									# casting to int to avoid issues when num_inference_step is power of 3
									snake_case__  :						Tuple		=      (np.arange(0	,					lowerCamelCase__) * step_ratio).round()[::-1].copy().astype(lowerCamelCase__)
									timesteps += self.config.steps_offset
								elif self.config.timestep_spacing == "trailing":
									snake_case__  :						Union[str, Any]		=      self.config.num_train_timesteps / self.num_inference_steps
									# creates integer timesteps by multiplying by ratio
									# casting to int to avoid issues when num_inference_step is power of 3
									snake_case__  :						Optional[int]		=      (np.arange(self.config.num_train_timesteps	,					0	,					-step_ratio)).round().copy().astype(lowerCamelCase__)
									timesteps -= 1
								else:
									raise ValueError(
									    f"""{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'.""")

								snake_case__  :						Optional[int]		=      np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
								snake_case__  :						List[str]		=      np.log(lowerCamelCase__)
								snake_case__  :						int		=      np.interp(lowerCamelCase__	,					np.arange(0	,					len(lowerCamelCase__))	,					lowerCamelCase__)

								if self.use_karras_sigmas:
									snake_case__  :						Optional[Any]		=      self._convert_to_karras(in_sigmas=lowerCamelCase__)
									snake_case__  :						int		=      np.array([self._sigma_to_t(lowerCamelCase__	,					lowerCamelCase__) for sigma in sigmas])

								snake_case__  :						int		=      np.concatenate([sigmas, [0.0]]).astype(np.floataa)

								snake_case__  :						Any		=      torch.from_numpy(lowerCamelCase__).to(device=lowerCamelCase__)
								if str(lowerCamelCase__).startswith("mps"):
									# mps does not support float64
									snake_case__  :						int		=      torch.from_numpy(lowerCamelCase__).to(lowerCamelCase__	,					dtype=torch.floataa)
								else:
									snake_case__  :						Optional[int]		=      torch.from_numpy(lowerCamelCase__).to(device=lowerCamelCase__)

								snake_case__  :						List[Any]		=      []




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__)   ->	Optional[Any]:







								'''simple docstring'''




								snake_case__  :						List[str]		=      np.log(lowerCamelCase__)

								# get distribution
								snake_case__  :						int		=      log_sigma - log_sigmas[:, np.newaxis]

								# get sigmas range
								snake_case__  :						Any		=      np.cumsum((dists >= 0)	,					axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2)
								snake_case__  :						Union[str, Any]		=      low_idx + 1

								snake_case__  :						List[str]		=      log_sigmas[low_idx]
								snake_case__  :						int		=      log_sigmas[high_idx]

								# interpolate sigmas
								snake_case__  :						List[str]		=      (low - log_sigma) / (low - high)
								snake_case__  :						int		=      np.clip(lowerCamelCase__	,					0	,					1)

								# transform interpolation to time range
								snake_case__  :						Tuple		=      (1 - w) * low_idx + w * high_idx
								snake_case__  :						str		=      t.reshape(sigma.shape)
								return t




							def        UpperCAmelCase (						self	,					lowerCamelCase__)   ->	torch.FloatTensor:







								'''simple docstring'''




								snake_case__  :						float		=      in_sigmas[-1].item()
								snake_case__  :						float		=      in_sigmas[0].item()

								snake_case__  :						Optional[Any]		=      7.0  # 7.0 is the value used in the paper
								snake_case__  :						Tuple		=      np.linspace(0	,					1	,					self.num_inference_steps)
								snake_case__  :						Union[str, Any]		=      sigma_min ** (1 / rho)
								snake_case__  :						Dict		=      sigma_max ** (1 / rho)
								snake_case__  :						int		=      (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
								return sigmas




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__ = 4	,					lowerCamelCase__ = True	,					)   ->	Union[LMSDiscreteSchedulerOutput, Tuple]:







								'''simple docstring'''




								if not self.is_scale_input_called:
									warnings.warn(
									    "The `scale_model_input` function should be called before `step` to ensure correct denoising. "
									    "See `StableDiffusionPipeline` for a usage example.")

								if isinstance(lowerCamelCase__	,					torch.Tensor):
									snake_case__  :						List[Any]		=      timestep.to(self.timesteps.device)
								snake_case__  :						Dict		=      (self.timesteps == timestep).nonzero().item()
								snake_case__  :						str		=      self.sigmas[step_index]

								# 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
								if self.config.prediction_type == "epsilon":
									snake_case__  :						Optional[int]		=      sample - sigma * model_output
								elif self.config.prediction_type == "v_prediction":
									# * c_out + input * c_skip
									snake_case__  :						Optional[Any]		=      model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
								elif self.config.prediction_type == "sample":
									snake_case__  :						Tuple		=      model_output
								else:
									raise ValueError(
									    f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`""")

								# 2. Convert to an ODE derivative
								snake_case__  :						List[Any]		=      (sample - pred_original_sample) / sigma
								self.derivatives.append(lowerCamelCase__)
								if len(self.derivatives) > order:
									self.derivatives.pop(0)

								# 3. Compute linear multistep coefficients
								snake_case__  :						Any		=      min(step_index + 1	,					lowerCamelCase__)
								snake_case__  :						Union[str, Any]		=      [self.get_lms_coefficient(lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__) for curr_order in range(lowerCamelCase__)]

								# 4. Compute previous sample based on the derivatives path
								snake_case__  :						List[Any]		=      sample + sum(
								    coeff * derivative for coeff, derivative in zip(lowerCamelCase__	,					reversed(self.derivatives)))

								if not return_dict:
									return (prev_sample,)

								return LMSDiscreteSchedulerOutput(prev_sample=lowerCamelCase__	,					pred_original_sample=lowerCamelCase__)




							def        UpperCAmelCase (						self	,					lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__	,					)   ->	torch.FloatTensor:







								'''simple docstring'''




								snake_case__  :						Union[str, Any]		=      self.sigmas.to(device=original_samples.device	,					dtype=original_samples.dtype)
								if original_samples.device.type == "mps" and torch.is_floating_point(lowerCamelCase__):
									# mps does not support float64
									snake_case__  :						str		=      self.timesteps.to(original_samples.device	,					dtype=torch.floataa)
									snake_case__  :						int		=      timesteps.to(original_samples.device	,					dtype=torch.floataa)
								else:
									snake_case__  :						List[str]		=      self.timesteps.to(original_samples.device)
									snake_case__  :						Any		=      timesteps.to(original_samples.device)

								snake_case__  :						Dict		=      [(schedule_timesteps == t).nonzero().item() for t in timesteps]

								snake_case__  :						Optional[int]		=      sigmas[step_indices].flatten()
								while len(sigma.shape) < len(original_samples.shape):
									snake_case__  :						Tuple		=      sigma.unsqueeze(-1)

								snake_case__  :						Tuple		=      original_samples + noise * sigma
								return noisy_samples







							def __len__(						self)   ->	Any:







								'''simple docstring'''




								return self.config.num_train_timesteps







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



