






import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VideoMAEConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import (
						    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
						    VideoMAEForPreTraining,
						    VideoMAEForVideoClassification,
						    VideoMAEModel,
						)
						from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from transformers import VideoMAEImageProcessor


class        __UpperCamelCase    :







	def __init__(  self      :							Optional[Any]       ,				_lowerCAmelCase      :							Tuple       ,				_lowerCAmelCase      :							Optional[int]=13       ,				_lowerCAmelCase      :							Dict=10       ,				_lowerCAmelCase      :							Optional[Any]=3       ,				_lowerCAmelCase      :							str=2       ,				_lowerCAmelCase      :							Tuple=2       ,				_lowerCAmelCase      :							Any=2       ,				_lowerCAmelCase      :							Any=True       ,				_lowerCAmelCase      :							int=True       ,				_lowerCAmelCase      :							List[str]=32       ,				_lowerCAmelCase      :							Any=5       ,				_lowerCAmelCase      :							int=4       ,				_lowerCAmelCase      :							int=37       ,				_lowerCAmelCase      :							List[str]="gelu"       ,				_lowerCAmelCase      :							Dict=0.1       ,				_lowerCAmelCase      :							Dict=0.1       ,				_lowerCAmelCase      :							Union[str, Any]=10       ,				_lowerCAmelCase      :							str=0.02       ,				_lowerCAmelCase      :							List[Any]=0.9       ,				_lowerCAmelCase      :							List[Any]=None       ,				)		-> Tuple:
		"""simple docstring"""







		__lowercase             =  parent
		__lowercase             =  batch_size
		__lowercase             =  image_size
		__lowercase             =  num_channels
		__lowercase             =  patch_size
		__lowercase             =  tubelet_size
		__lowercase             =  num_frames
		__lowercase             =  is_training
		__lowercase             =  use_labels
		__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             =  type_sequence_label_size
		__lowercase             =  initializer_range
		__lowercase             =  mask_ratio
		__lowercase             =  scope

		# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
		__lowercase             =  (image_size // patch_size) ** 2
		__lowercase             =  (num_frames // tubelet_size) * self.num_patches_per_frame

		# use this variable to define bool_masked_pos
		__lowercase             =  int(mask_ratio * self.seq_length			)







	def  _a   (  self      :							Union[str, Any]			)		-> List[str]:
		"""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.type_sequence_label_size			)

		__lowercase             =  self.get_config()

		return config, pixel_values, labels







	def  _a   (  self      :							Optional[int]			)		-> Any:
		"""simple docstring"""







		return VideoMAEConfig(
		    image_size=self.image_size       ,				patch_size=self.patch_size       ,				num_channels=self.num_channels       ,				num_frames=self.num_frames       ,				tubelet_size=self.tubelet_size       ,				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       ,				is_decoder=_lowerCAmelCase       ,				initializer_range=self.initializer_range       ,				)







	def  _a   (  self      :							Optional[Any]       ,				_lowerCAmelCase      :							Dict       ,				_lowerCAmelCase      :							Tuple       ,				_lowerCAmelCase      :							List[Any]			)		-> Optional[int]:
		"""simple docstring"""







		__lowercase             =  VideoMAEModel(config=_lowerCAmelCase			)
		model.to(_lowerCAmelCase			)
		model.eval()
		__lowercase             =  model(_lowerCAmelCase			)
		self.parent.assertEqual(result.last_hidden_state.shape       ,				(self.batch_size, self.seq_length, self.hidden_size)			)







	def  _a   (  self      :							Tuple       ,				_lowerCAmelCase      :							int       ,				_lowerCAmelCase      :							str       ,				_lowerCAmelCase      :							Dict			)		-> Optional[int]:
		"""simple docstring"""







		__lowercase             =  VideoMAEForPreTraining(_lowerCAmelCase			)
		model.to(_lowerCAmelCase			)
		model.eval()
		# important: each video needs to have the same number of masked patches
		# hence we define a single mask, which we then repeat for each example in the batch
		__lowercase             =  torch.ones((self.num_masks,)			)
		__lowercase             =  torch.cat([mask, torch.zeros(self.seq_length - mask.size(0			)			)]			)
		__lowercase             =  mask.expand(self.batch_size       ,				-1			).bool()

		__lowercase             =  model(_lowerCAmelCase       ,				_lowerCAmelCase			)
		# model only returns predictions for masked patches
		__lowercase             =  mask.sum().item()
		__lowercase             =  3 * self.tubelet_size * self.patch_size**2
		self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, num_masked_patches, decoder_num_labels)			)







	def  _a   (  self      :							Optional[int]			)		-> Optional[int]:
		"""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        __UpperCamelCase    (     _lowerCAmelCase   ,			_lowerCAmelCase   ,			unittest.TestCase   ):
	__snake_case	:str   =       (
	    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
	)
	__snake_case	:Any   =       (
	    {'feature-extraction': VideoMAEModel, 'video-classification': VideoMAEForVideoClassification}
	    if is_torch_available()
	    else {}
	)

	__snake_case	:List[Any]   =       False
	__snake_case	:List[Any]   =       False
	__snake_case	:List[Any]   =       False
	__snake_case	:Union[str, Any]   =       False







	def  _a   (  self      :							List[str]			)		-> Optional[int]:
		"""simple docstring"""







		__lowercase             =  VideoMAEModelTester(self			)
		__lowercase             =  ConfigTester(self       ,				config_class=_lowerCAmelCase       ,				has_text_modality=_lowerCAmelCase       ,				hidden_size=37			)







	def  _a   (  self      :							Any       ,				_lowerCAmelCase      :							int       ,				_lowerCAmelCase      :							Optional[Any]       ,				_lowerCAmelCase      :							Tuple=False			)		-> int:
		"""simple docstring"""







		__lowercase             =  copy.deepcopy(_lowerCAmelCase			)

		if model_class == VideoMAEForPreTraining:
			# important: each video needs to have the same number of masked patches
			# hence we define a single mask, which we then repeat for each example in the batch
			__lowercase             =  torch.ones((self.model_tester.num_masks,)			)
			__lowercase             =  torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0			)			)]			)
			__lowercase             =  mask.expand(self.model_tester.batch_size       ,				-1			).bool()
			__lowercase             =  bool_masked_pos.to(_lowerCAmelCase			)

		if return_labels:
			if model_class in [
			    *get_values(_lowerCAmelCase			),
			]:
				__lowercase             =  torch.zeros(
				    self.model_tester.batch_size       ,				dtype=torch.long       ,				device=_lowerCAmelCase			)

		return inputs_dict







	def  _a   (  self      :							int			)		-> int:
		"""simple docstring"""







		self.config_tester.run_common_tests()







	@unittest.skip(reason="""VideoMAE does not use inputs_embeds"""			)
	def  _a   (  self      :							List[Any]			)		-> Any:
		"""simple docstring"""







		pass







	def  _a   (  self      :							Any			)		-> List[Any]:
		"""simple docstring"""







		__lowercase       ,						__lowercase             =  self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			__lowercase             =  model_class(_lowerCAmelCase			)
			self.assertIsInstance(model.get_input_embeddings()       ,				(nn.Module)			)
			__lowercase             =  model.get_output_embeddings()
			self.assertTrue(x is None or isinstance(_lowerCAmelCase       ,				nn.Linear			)			)







	def  _a   (  self      :							Optional[int]			)		-> Tuple:
		"""simple docstring"""







		__lowercase       ,						__lowercase             =  self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			__lowercase             =  model_class(_lowerCAmelCase			)
			__lowercase             =  inspect.signature(model.forward			)
			# signature.parameters is an OrderedDict => so arg_names order is deterministic
			__lowercase             =  [*signature.parameters.keys()]

			__lowercase             =  ["""pixel_values"""]
			self.assertListEqual(arg_names[:1]       ,				_lowerCAmelCase			)







	def  _a   (  self      :							List[Any]			)		-> List[Any]:
		"""simple docstring"""







		__lowercase             =  self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*_lowerCAmelCase			)







	def  _a   (  self      :							Optional[Any]			)		-> List[Any]:
		"""simple docstring"""







		__lowercase             =  self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase			)







	@slow
	def  _a   (  self      :							List[Any]			)		-> Union[str, Any]:
		"""simple docstring"""







		for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			__lowercase             =  VideoMAEModel.from_pretrained(_lowerCAmelCase			)
			self.assertIsNotNone(_lowerCAmelCase			)







	def  _a   (  self      :							Optional[int]			)		-> Union[str, Any]:
		"""simple docstring"""







		if not self.has_attentions:
			pass

		else:
			__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 - self.model_tester.num_masks
				__lowercase             =  (
				    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
				)

				__lowercase             =  True
				__lowercase             =  False
				__lowercase             =  True
				__lowercase             =  model_class(_lowerCAmelCase			)
				model.to(_lowerCAmelCase			)
				model.eval()
				with torch.no_grad():
					__lowercase             =  model(**self._prepare_for_class(_lowerCAmelCase       ,				_lowerCAmelCase			)			)
				__lowercase             =  outputs.attentions
				self.assertEqual(len(_lowerCAmelCase			)       ,				self.model_tester.num_hidden_layers			)

				# check that output_attentions also work using config
				del inputs_dict["output_attentions"]
				__lowercase             =  True
				__lowercase             =  model_class(_lowerCAmelCase			)
				model.to(_lowerCAmelCase			)
				model.eval()
				with torch.no_grad():
					__lowercase             =  model(**self._prepare_for_class(_lowerCAmelCase       ,				_lowerCAmelCase			)			)
				__lowercase             =  outputs.attentions
				self.assertEqual(len(_lowerCAmelCase			)       ,				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(_lowerCAmelCase			)

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

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

				__lowercase             =  outputs.attentions

				self.assertEqual(len(_lowerCAmelCase			)       ,				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  _a   (  self      :							Optional[Any]			)		-> Tuple:
		"""simple docstring"""







		def check_hidden_states_output(_lowerCAmelCase      :							Dict       ,				_lowerCAmelCase      :							Union[str, Any]       ,				_lowerCAmelCase      :							List[Any]			):
			__lowercase             =  model_class(_lowerCAmelCase			)
			model.to(_lowerCAmelCase			)
			model.eval()

			with torch.no_grad():
				__lowercase             =  model(**self._prepare_for_class(_lowerCAmelCase       ,				_lowerCAmelCase			)			)

			__lowercase             =  outputs.hidden_states
			__lowercase             =  self.model_tester.num_hidden_layers + 1
			self.assertEqual(len(_lowerCAmelCase			)       ,				_lowerCAmelCase			)

			__lowercase             =  self.model_tester.seq_length - self.model_tester.num_masks
			__lowercase             =  num_visible_patches if model_class == VideoMAEForPreTraining else 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(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase			)

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			__lowercase             =  True

			check_hidden_states_output(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase			)







	@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""			)
	def  _a   (  self      :							Optional[int]			)		-> Any:
		"""simple docstring"""







		pass





def 				snake_case  (     ):




	'''simple docstring'''







	__lowercase             =  hf_hub_download(
	    repo_id="""hf-internal-testing/spaghetti-video"""				,  filename="""eating_spaghetti.npy"""				,  repo_type="""dataset"""					)
	__lowercase             =  np.load(lowerCamelCase					)
	return list(lowerCamelCase					)




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







	@cached_property
	def  _a   (  self      :							Tuple			)		-> Any:
		"""simple docstring"""







		return (
		    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]       ,				image_std=[0.5, 0.5, 0.5]			)
		    if is_vision_available()
		    else None
		)







	@slow
	def  _a   (  self      :							List[Any]			)		-> Any:
		"""simple docstring"""







		__lowercase             =  VideoMAEForVideoClassification.from_pretrained("""MCG-NJU/videomae-base-finetuned-kinetics"""			).to(
		    _lowerCAmelCase			)

		__lowercase             =  self.default_image_processor
		__lowercase             =  prepare_video()
		__lowercase             =  image_processor(_lowerCAmelCase       ,				return_tensors="""pt"""			).to(_lowerCAmelCase			)

		# forward pass
		with torch.no_grad():
			__lowercase             =  model(**_lowerCAmelCase			)

		# verify the logits
		__lowercase             =  torch.Size((1, 400)			)
		self.assertEqual(outputs.logits.shape       ,				_lowerCAmelCase			)

		__lowercase             =  torch.tensor([0.3_669, -0.0_688, -0.2_421]			).to(_lowerCAmelCase			)

		self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,				_lowerCAmelCase       ,				atol=1e-4			)			)







	@slow
	def  _a   (  self      :							List[Any]			)		-> Dict:
		"""simple docstring"""







		__lowercase             =  VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short"""			).to(_lowerCAmelCase			)

		__lowercase             =  self.default_image_processor
		__lowercase             =  prepare_video()
		__lowercase             =  image_processor(_lowerCAmelCase       ,				return_tensors="""pt"""			).to(_lowerCAmelCase			)

		# add boolean mask, indicating which patches to mask
		__lowercase             =  hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos"""       ,				filename="""bool_masked_pos.pt"""			)
		__lowercase             =  torch.load(_lowerCAmelCase			)

		# forward pass
		with torch.no_grad():
			__lowercase             =  model(**_lowerCAmelCase			)

		# verify the logits
		__lowercase             =  torch.Size([1, 1408, 1536]			)
		__lowercase             =  torch.tensor(
		    [[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]]       ,				device=_lowerCAmelCase			)
		self.assertEqual(outputs.logits.shape       ,				_lowerCAmelCase			)
		self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]       ,				_lowerCAmelCase       ,				atol=1e-4			)			)

		# verify the loss (`config.norm_pix_loss` = `True`)
		__lowercase             =  torch.tensor([0.5_142]       ,				device=_lowerCAmelCase			)
		self.assertTrue(torch.allclose(outputs.loss       ,				_lowerCAmelCase       ,				atol=1e-4			)			)

		# verify the loss (`config.norm_pix_loss` = `False`)
		__lowercase             =  VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short"""       ,				norm_pix_loss=_lowerCAmelCase			).to(
		    _lowerCAmelCase			)

		with torch.no_grad():
			__lowercase             =  model(**_lowerCAmelCase			)

		__lowercase             =  torch.tensor(torch.tensor([0.6_469]			)       ,				device=_lowerCAmelCase			)
		self.assertTrue(torch.allclose(outputs.loss       ,				_lowerCAmelCase       ,				atol=1e-4			)			)









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__UpperCamelCase      :      Tuple     						=						{
    """configuration_swiftformer""": [
        """SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """SwiftFormerConfig""",
        """SwiftFormerOnnxConfig""",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase      :      Optional[Any]     						=						[
						    """SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """SwiftFormerForImageClassification""",
						    """SwiftFormerModel""",
						    """SwiftFormerPreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_swiftformer import (
						    SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    SwiftFormerConfig,
						    SwiftFormerOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_swiftformer import (
												    SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SwiftFormerForImageClassification,
												    SwiftFormerModel,
												    SwiftFormerPreTrainedModel,
												)

else:
						import sys

						__UpperCamelCase      :      List[Any]     						=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

