"""simple docstring"""


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      ,					_lowerCamelCase      ,					_lowerCamelCase=13      ,					_lowerCamelCase=10      ,					_lowerCamelCase=3      ,					_lowerCamelCase=2      ,					_lowerCamelCase=2      ,					_lowerCamelCase=2      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=32      ,					_lowerCamelCase=5      ,					_lowerCamelCase=4      ,					_lowerCamelCase=37      ,					_lowerCamelCase="gelu"      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=10      ,					_lowerCamelCase=0.0_2      ,					_lowerCamelCase=0.9      ,					_lowerCamelCase=None      ,					):
										lowerCamelCase__   =parent
										lowerCamelCase__   =batch_size
										lowerCamelCase__   =image_size
										lowerCamelCase__   =num_channels
										lowerCamelCase__   =patch_size
										lowerCamelCase__   =tubelet_size
										lowerCamelCase__   =num_frames
										lowerCamelCase__   =is_training
										lowerCamelCase__   =use_labels
										lowerCamelCase__   =hidden_size
										lowerCamelCase__   =num_hidden_layers
										lowerCamelCase__   =num_attention_heads
										lowerCamelCase__   =intermediate_size
										lowerCamelCase__   =hidden_act
										lowerCamelCase__   =hidden_dropout_prob
										lowerCamelCase__   =attention_probs_dropout_prob
										lowerCamelCase__   =type_sequence_label_size
										lowerCamelCase__   =initializer_range
										lowerCamelCase__   =mask_ratio
										lowerCamelCase__   =scope

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

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

				def 						_a      ( self ):
										lowerCamelCase__   =floats_tensor(
										    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size] )

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

										lowerCamelCase__   =self.get_config()

										return config, pixel_values, labels

				def 						_a      ( self ):
										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      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =VideoMAEModel(config=_lowerCamelCase )
										model.to(_lowerCamelCase )
										model.eval()
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.hidden_size) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =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
										lowerCamelCase__   =torch.ones((self.num_masks,) )
										lowerCamelCase__   =torch.cat([mask, torch.zeros(self.seq_length - mask.size(0 ) )] )
										lowerCamelCase__   =mask.expand(self.batch_size      ,					-1 ).bool()

										lowerCamelCase__   =model(_lowerCamelCase      ,					_lowerCamelCase )
										# model only returns predictions for masked patches
										lowerCamelCase__   =mask.sum().item()
										lowerCamelCase__   =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 ):
										lowerCamelCase__   =self.prepare_config_and_inputs()
										lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   =config_and_inputs
										lowerCamelCase__   ={"pixel_values": pixel_values}
										return config, inputs_dict






@require_torch
class   __UpperCAmelCase		(      __lowerCAmelCase , __lowerCAmelCase , unittest.TestCase      ):
				A__ :  str    				=			(
				    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
				)
				A__ :  Optional[int]    				=			(
				    {'''feature-extraction''': VideoMAEModel, '''video-classification''': VideoMAEForVideoClassification}
				    if is_torch_available()
				    else {}
				)

				A__ :  List[str]    				=			False
				A__ :  Optional[Any]    				=			False
				A__ :  List[str]    				=			False
				A__ :  str    				=			False

				def 						_a      ( self ):
										lowerCamelCase__   =VideoMAEModelTester(self )
										lowerCamelCase__   =ConfigTester(self      ,					config_class=_lowerCamelCase      ,					has_text_modality=_lowerCamelCase      ,					hidden_size=37 )

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

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

										return inputs_dict

				def 						_a      ( self ):
										self.config_tester.run_common_tests()

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

				def 						_a      ( self ):
										lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_for_common()

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

				def 						_a      ( self ):
										lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__   =["pixel_values"]
																self.assertListEqual(arg_names[:1]      ,					_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*_lowerCamelCase )

				@slow
				def 						_a      ( self ):
										for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowerCamelCase__   =VideoMAEModel.from_pretrained(_lowerCamelCase )
																self.assertIsNotNone(_lowerCamelCase )

				def 						_a      ( self ):
										if not self.has_attentions:
																pass

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

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

																						lowerCamelCase__   =True
																						lowerCamelCase__   =False
																						lowerCamelCase__   =True
																						lowerCamelCase__   =model_class(_lowerCamelCase )
																						model.to(_lowerCamelCase )
																						model.eval()
																						with torch.no_grad():
																												lowerCamelCase__   =model(**self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase ) )
																						lowerCamelCase__   =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"]
																						lowerCamelCase__   =True
																						lowerCamelCase__   =model_class(_lowerCamelCase )
																						model.to(_lowerCamelCase )
																						model.eval()
																						with torch.no_grad():
																												lowerCamelCase__   =model(**self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase ) )
																						lowerCamelCase__   =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]      ,					)
																						lowerCamelCase__   =len(_lowerCamelCase )

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

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

																						lowerCamelCase__   =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 ):
										def check_hidden_states_output(_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
																lowerCamelCase__   =model_class(_lowerCamelCase )
																model.to(_lowerCamelCase )
																model.eval()

																with torch.no_grad():
																						lowerCamelCase__   =model(**self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase ) )

																lowerCamelCase__   =outputs.hidden_states
																lowerCamelCase__   =self.model_tester.num_hidden_layers + 1
																self.assertEqual(len(_lowerCamelCase )      ,					_lowerCamelCase )

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

										lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowerCamelCase__   =True
																check_hidden_states_output(_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																lowerCamelCase__   =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 ):
										pass





def      lowerCamelCase_					(   )				->   List[str]:




						'''simple docstring'''



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






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

				@cached_property
				def 						_a      ( self ):
										# logits were tested with a different mean and std, so we use the same here
										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 ):
										lowerCamelCase__   =VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics" ).to(
										    _lowerCamelCase )

										lowerCamelCase__   =self.default_image_processor
										lowerCamelCase__   =prepare_video()
										lowerCamelCase__   =image_processor(_lowerCamelCase      ,					return_tensors="pt" ).to(_lowerCamelCase )

										# forward pass
										with torch.no_grad():
																lowerCamelCase__   =model(**_lowerCamelCase )

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

										lowerCamelCase__   =torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1] ).to(_lowerCamelCase )

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






				@slow
				def 						_a      ( self ):
										lowerCamelCase__   =VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short" ).to(_lowerCamelCase )

										lowerCamelCase__   =self.default_image_processor
										lowerCamelCase__   =prepare_video()
										lowerCamelCase__   =image_processor(_lowerCamelCase      ,					return_tensors="pt" ).to(_lowerCamelCase )

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

										# forward pass
										with torch.no_grad():
																lowerCamelCase__   =model(**_lowerCamelCase )

										# verify the logits
										lowerCamelCase__   =torch.Size([1, 1408, 1536] )
										lowerCamelCase__   =torch.tensor(
										    [[0.7_9_9_4, 0.9_6_1_2, 0.8_5_0_8], [0.7_4_0_1, 0.8_9_5_8, 0.8_3_0_2], [0.5_8_6_2, 0.7_4_6_8, 0.7_3_2_5]]      ,					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`)
										lowerCamelCase__   =torch.tensor([0.5_1_4_2]      ,					device=_lowerCamelCase )
										self.assertTrue(torch.allclose(outputs.loss      ,					_lowerCamelCase      ,					atol=1E-4 ) )

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

										with torch.no_grad():
																lowerCamelCase__   =model(**_lowerCamelCase )

										lowerCamelCase__   =torch.tensor(torch.tensor([0.6_4_6_9] )      ,					device=_lowerCamelCase )
										self.assertTrue(torch.allclose(outputs.loss      ,					_lowerCamelCase      ,					atol=1E-4 ) )



"""simple docstring"""


def      lowerCamelCase_					(   __lowerCAmelCase							)				->   bool:




						'''simple docstring'''



						return number & 1 == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()


