





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







	'''simple docstring'''

	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     ,)							->							List[Any]:







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







				'''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 						_UpperCAmelCase     (self )							->							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 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase     ,_lowerCamelCase )							->							Dict:







				'''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 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase     ,_lowerCamelCase )							->							Dict:







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







				'''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 							__lowercase       (      lowerCAmelCase__ ,      lowerCAmelCase__ ,      unittest.TestCase						):







	'''simple docstring'''

	a    :				List[str]											=       (
	    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
	)
	a    :				Optional[int]											=       (
	    {"feature-extraction": VideoMAEModel, "video-classification": VideoMAEForVideoClassification}
	    if is_torch_available()
	    else {}
	)

	a    :				Tuple											=       False
	a    :				Tuple											=       False
	a    :				Any											=       False
	a    :				Any											=       False


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase     ,_lowerCamelCase=False )							->							Optional[Any]:







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







				'''simple docstring'''





				self.config_tester.run_common_tests()


	@unittest.skip(reason='''VideoMAE does not use inputs_embeds''' )
	def 						_UpperCAmelCase     (self )							->							Union[str, Any]:







				'''simple docstring'''





				pass


	def 						_UpperCAmelCase     (self )							->							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 						_UpperCAmelCase     (self )							->							Dict:







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







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self )							->							int:







				'''simple docstring'''





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


	@slow
	def 						_UpperCAmelCase     (self )							->							Tuple:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self )							->							Tuple:







				'''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 						_UpperCAmelCase     (self )							->							List[str]:







				'''simple docstring'''





				def check_hidden_states_output(_lowerCamelCase     ,_lowerCamelCase     ,_lowerCamelCase ):
							__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 						_UpperCAmelCase     (self )							->							str:







				'''simple docstring'''





				pass





def    _lowerCAmelCase						(				):
			__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 							__lowercase       (      unittest.TestCase						):







	'''simple docstring'''

	@cached_property
	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''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 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''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_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 						_UpperCAmelCase     (self )							->							Union[str, Any]:







				'''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_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`)
				__lowercase										=							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`)
				__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_4_6_9] )     ,device=_lowerCamelCase )
				self.assertTrue(torch.allclose(outputs.loss     ,_lowerCamelCase     ,atol=1E-4 ) )












'''simple docstring'''



import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing






class 							__lowercase       (      lowerCAmelCase__						):







	'''simple docstring'''

	def __init__(self     ,_lowerCamelCase = "▁"     ,_lowerCamelCase = True     ,_lowerCamelCase = "<unk>"     ,_lowerCamelCase = "</s>"     ,_lowerCamelCase = "<pad>"     ,)							->							List[Any]:







				'''simple docstring'''





				__lowercase										=							{
				    '''pad''': {'''id''': 0, '''token''': pad_token},
				    '''eos''': {'''id''': 1, '''token''': eos_token},
				    '''unk''': {'''id''': 2, '''token''': unk_token},
				}

				__lowercase										=							[None] * len(self.special_tokens )
				for token_dict in self.special_tokens.values():
							__lowercase										=							token_dict['''token''']

				__lowercase										=							Tokenizer(Unigram() )

				__lowercase										=							normalizers.Sequence(
				    [
				        normalizers.Nmt(),
				        normalizers.NFKC(),
				        normalizers.Replace(Regex(''' {2,}''' )     ,''' ''' ),
				        normalizers.Lowercase(),
				    ] )
				__lowercase										=							pre_tokenizers.Sequence(
				    [
				        pre_tokenizers.Metaspace(replacement=_lowerCamelCase     ,add_prefix_space=_lowerCamelCase ),
				        pre_tokenizers.Digits(individual_digits=_lowerCamelCase ),
				        pre_tokenizers.Punctuation(),
				    ] )
				__lowercase										=							decoders.Metaspace(replacement=_lowerCamelCase     ,add_prefix_space=_lowerCamelCase )

				__lowercase										=							TemplateProcessing(
				    single=f"$A {self.special_tokens['eos']['token']}"     ,special_tokens=[(self.special_tokens['''eos''']['''token'''], self.special_tokens['''eos''']['''id'''])]     ,)

				__lowercase										=							{
				    '''model''': '''SentencePieceUnigram''',
				    '''replacement''': replacement,
				    '''add_prefix_space''': add_prefix_space,
				}

				super().__init__(_lowerCamelCase     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase = 8000     ,_lowerCamelCase = True     ,)							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase										=							trainers.UnigramTrainer(
				    vocab_size=_lowerCamelCase     ,special_tokens=self.special_tokens_list     ,show_progress=_lowerCamelCase     ,)

				if isinstance(_lowerCamelCase     ,_lowerCamelCase ):
							__lowercase										=							[files]
				self._tokenizer.train(_lowerCamelCase     ,trainer=_lowerCamelCase )

				self.add_unk_id()


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase = 8000     ,_lowerCamelCase = True     ,)							->							List[str]:







				'''simple docstring'''





				__lowercase										=							trainers.UnigramTrainer(
				    vocab_size=_lowerCamelCase     ,special_tokens=self.special_tokens_list     ,show_progress=_lowerCamelCase     ,)

				self._tokenizer.train_from_iterator(_lowerCamelCase     ,trainer=_lowerCamelCase )

				self.add_unk_id()


	def 						_UpperCAmelCase     (self )							->							Tuple:







				'''simple docstring'''





				__lowercase										=							json.loads(self._tokenizer.to_str() )

				__lowercase										=							self.special_tokens['''unk''']['''id''']

				__lowercase										=							Tokenizer.from_str(json.dumps(_lowerCamelCase ) )





