


import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		DownBlockaD  # noqa F405
			_UpperCamelCase		:					Union[str, Any]    =		'down'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[int]    =		ResnetDownsampleBlockaD  # noqa F405
			_UpperCamelCase		:					str    =		'down'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Tuple    =		AttnDownBlockaD  # noqa F405
			_UpperCamelCase		:					List[Any]    =		'down'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[Any]    =		CrossAttnDownBlockaD  # noqa F405
			_UpperCamelCase		:					Dict    =		'down'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Any    =		SimpleCrossAttnDownBlockaD  # noqa F405
			_UpperCamelCase		:					List[Any]    =		'down'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_encoder_hidden_states=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			@unittest.skipIf(torch_device == "mps"      ,						"MPS result is not consistent"     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Dict    =		SkipDownBlockaD  # noqa F405
			_UpperCamelCase		:					List[Any]    =		'down'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_skip_sample=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[str]    =		AttnSkipDownBlockaD  # noqa F405
			_UpperCamelCase		:					Optional[int]    =		'down'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_skip_sample=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[str]    =		DownEncoderBlockaD  # noqa F405
			_UpperCamelCase		:					str    =		'down'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_temb=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       {
						    "in_channels": 32,
						    "out_channels": 32,
						}
						UpperCamelCase__					=       self.dummy_input
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					str    =		AttnDownEncoderBlockaD  # noqa F405
			_UpperCamelCase		:					Dict    =		'down'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_temb=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       {
						    "in_channels": 32,
						    "out_channels": 32,
						}
						UpperCamelCase__					=       self.dummy_input
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					int    =		UNetMidBlockaD  # noqa F405
			_UpperCamelCase		:					Union[str, Any]    =		'mid'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       {
						    "in_channels": 32,
						    "temb_channels": 128,
						}
						UpperCamelCase__					=       self.dummy_input
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					str    =		UNetMidBlockaDCrossAttn  # noqa F405
			_UpperCamelCase		:					Any    =		'mid'




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Union[str, Any]    =		UNetMidBlockaDSimpleCrossAttn  # noqa F405
			_UpperCamelCase		:					Union[str, Any]    =		'mid'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_encoder_hidden_states=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[Any]    =		UpBlockaD  # noqa F405
			_UpperCamelCase		:					Optional[Any]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					int    =		ResnetUpsampleBlockaD  # noqa F405
			_UpperCamelCase		:					Union[str, Any]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					str    =		CrossAttnUpBlockaD  # noqa F405
			_UpperCamelCase		:					Any    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		SimpleCrossAttnUpBlockaD  # noqa F405
			_UpperCamelCase		:					Union[str, Any]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case      ,						include_encoder_hidden_states=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       super().prepare_init_args_and_inputs_for_common()
						UpperCamelCase__					=       32
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[str]    =		AttnUpBlockaD  # noqa F405
			_UpperCamelCase		:					int    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )







			@unittest.skipIf(torch_device == "mps"      ,						"MPS result is not consistent"     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[str]    =		SkipUpBlockaD  # noqa F405
			_UpperCamelCase		:					Optional[Any]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		AttnSkipUpBlockaD  # noqa F405
			_UpperCamelCase		:					str    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_res_hidden_states_tuple=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[Any]    =		UpDecoderBlockaD  # noqa F405
			_UpperCamelCase		:					Optional[int]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_temb=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       {"in_channels": 32, "out_channels": 32}

						UpperCamelCase__					=       self.dummy_input
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
						super().test_output(snake_case     )







class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[str]    =		AttnUpDecoderBlockaD  # noqa F405
			_UpperCamelCase		:					List[Any]    =		'up'




			@property
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().get_dummy_input(include_temb=snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       {"in_channels": 32, "out_channels": 32}

						UpperCamelCase__					=       self.dummy_input
						return init_dict, inputs_dict







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       [0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
						super().test_output(snake_case     )






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        lowerCamelCase__	:






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=13      ,						snake_case=10      ,						snake_case=3      ,						snake_case=2      ,						snake_case=2      ,						snake_case=2      ,						snake_case=True      ,						snake_case=True      ,						snake_case=32      ,						snake_case=5      ,						snake_case=4      ,						snake_case=37      ,						snake_case="gelu"      ,						snake_case=0.1      ,						snake_case=0.1      ,						snake_case=10      ,						snake_case=0.02      ,						snake_case=0.9      ,						snake_case=None      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       batch_size
						UpperCamelCase__					=       image_size
						UpperCamelCase__					=       num_channels
						UpperCamelCase__					=       patch_size
						UpperCamelCase__					=       tubelet_size
						UpperCamelCase__					=       num_frames
						UpperCamelCase__					=       is_training
						UpperCamelCase__					=       use_labels
						UpperCamelCase__					=       hidden_size
						UpperCamelCase__					=       num_hidden_layers
						UpperCamelCase__					=       num_attention_heads
						UpperCamelCase__					=       intermediate_size
						UpperCamelCase__					=       hidden_act
						UpperCamelCase__					=       hidden_dropout_prob
						UpperCamelCase__					=       attention_probs_dropout_prob
						UpperCamelCase__					=       type_sequence_label_size
						UpperCamelCase__					=       initializer_range
						UpperCamelCase__					=       mask_ratio
						UpperCamelCase__					=       scope

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

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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       floats_tensor(
						    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]     )

						UpperCamelCase__					=       None
						if self.use_labels:
									UpperCamelCase__					=       ids_tensor([self.batch_size]      ,						self.type_sequence_label_size     )

						UpperCamelCase__					=       self.get_config()

						return config, pixel_values, labels




			def 				snake_case__				(							self     ):

						'''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=snake_case      ,						initializer_range=self.initializer_range      ,						)




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       VideoMAEForPreTraining(snake_case     )
						model.to(snake_case     )
						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
						UpperCamelCase__					=       torch.ones((self.num_masks,)     )
						UpperCamelCase__					=       torch.cat([mask, torch.zeros(self.seq_length - mask.size(0     )     )]     )
						UpperCamelCase__					=       mask.expand(self.batch_size      ,						-1     ).bool()

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







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.prepare_config_and_inputs()
						UpperCamelCase__,      UpperCamelCase__,      UpperCamelCase__					=       config_and_inputs
						UpperCamelCase__					=       {"pixel_values": pixel_values}
						return config, inputs_dict







@require_torch
class        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[Any]    =		(
			    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
			)
			_UpperCamelCase		:					Union[str, Any]    =		(
			    {'feature-extraction': VideoMAEModel, 'video-classification': VideoMAEForVideoClassification}
			    if is_torch_available()
			    else {}
			)

			_UpperCamelCase		:					Optional[int]    =		False
			_UpperCamelCase		:					Tuple    =		False
			_UpperCamelCase		:					int    =		False
			_UpperCamelCase		:					Any    =		False




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       VideoMAEModelTester(self     )
						UpperCamelCase__					=       ConfigTester(self      ,						config_class=snake_case      ,						has_text_modality=snake_case      ,						hidden_size=37     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case=False     ):

						'''simple docstring'''


						UpperCamelCase__					=       copy.deepcopy(snake_case     )

						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
									UpperCamelCase__					=       torch.ones((self.model_tester.num_masks,)     )
									UpperCamelCase__					=       torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0     )     )]     )
									UpperCamelCase__					=       mask.expand(self.model_tester.batch_size      ,						-1     ).bool()
									UpperCamelCase__					=       bool_masked_pos.to(snake_case     )

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

						return inputs_dict




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			@unittest.skip(reason="VideoMAE does not use inputs_embeds"     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						pass




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_common()

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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_common()

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

									UpperCamelCase__					=       ["pixel_values"]
									self.assertListEqual(arg_names[:1]      ,						snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_pretraining(*snake_case     )




			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						if not self.has_attentions:
									pass

						else:
									UpperCamelCase__,      UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_common()
									UpperCamelCase__					=       True

									for model_class in self.all_model_classes:
												UpperCamelCase__					=       self.model_tester.seq_length - self.model_tester.num_masks
												UpperCamelCase__					=       (
												    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
												)

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

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

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

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

												UpperCamelCase__					=       outputs.attentions

												self.assertEqual(len(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(snake_case      ,						snake_case      ,						snake_case     ):
									UpperCamelCase__					=       model_class(snake_case     )
									model.to(snake_case     )
									model.eval()

									with torch.no_grad():
												UpperCamelCase__					=       model(**self._prepare_for_class(snake_case      ,						snake_case     )     )

									UpperCamelCase__					=       outputs.hidden_states
									UpperCamelCase__					=       self.model_tester.num_hidden_layers + 1
									self.assertEqual(len(snake_case     )      ,						snake_case     )

									UpperCamelCase__					=       self.model_tester.seq_length - self.model_tester.num_masks
									UpperCamelCase__					=       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]      ,						)

						UpperCamelCase__,      UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									UpperCamelCase__					=       True
									check_hidden_states_output(snake_case      ,						snake_case      ,						snake_case     )

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

									check_hidden_states_output(snake_case      ,						snake_case      ,						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        UpperCamelCase_(				)->		Union[str, Any]:
			UpperCamelCase__					=       hf_hub_download(
			    repo_id="hf-internal-testing/spaghetti-video"				,     filename="eating_spaghetti.npy"				,     repo_type="dataset"  )
			UpperCamelCase__					=       np.load(_A  )
			return list(_A  )







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






			"""simple docstring"""






			@cached_property
			def 				snake_case__				(							self     ):

						'''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 				snake_case__				(							self     ):

						'''simple docstring'''


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

						UpperCamelCase__					=       self.default_image_processor
						UpperCamelCase__					=       prepare_video()
						UpperCamelCase__					=       image_processor(snake_case      ,						return_tensors="pt"     ).to(snake_case     )

						# forward pass
						with torch.no_grad():
									UpperCamelCase__					=       model(**snake_case     )

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

						UpperCamelCase__					=       torch.tensor([0.3669, -0.0688, -0.2421]     ).to(snake_case     )

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







			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short"     ).to(snake_case     )

						UpperCamelCase__					=       self.default_image_processor
						UpperCamelCase__					=       prepare_video()
						UpperCamelCase__					=       image_processor(snake_case      ,						return_tensors="pt"     ).to(snake_case     )

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

						# forward pass
						with torch.no_grad():
									UpperCamelCase__					=       model(**snake_case     )

						# verify the logits
						UpperCamelCase__					=       torch.Size([1, 1408, 1536]     )
						UpperCamelCase__					=       torch.tensor(
						    [[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]      ,						device=snake_case     )
						self.assertEqual(outputs.logits.shape      ,						snake_case     )
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]      ,						snake_case      ,						atol=1E-4     )     )

						# verify the loss (`config.norm_pix_loss` = `True`)
						UpperCamelCase__					=       torch.tensor([0.5142]      ,						device=snake_case     )
						self.assertTrue(torch.allclose(outputs.loss      ,						snake_case      ,						atol=1E-4     )     )

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

						with torch.no_grad():
									UpperCamelCase__					=       model(**snake_case     )

						UpperCamelCase__					=       torch.tensor(torch.tensor([0.6469]     )      ,						device=snake_case     )
						self.assertTrue(torch.allclose(outputs.loss      ,						snake_case      ,						atol=1E-4     )     )


