

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



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__=13						,			UpperCamelCase__=10						,			UpperCamelCase__=3						,			UpperCamelCase__=2						,			UpperCamelCase__=2						,			UpperCamelCase__=2						,			UpperCamelCase__=True						,			UpperCamelCase__=True						,			UpperCamelCase__=32						,			UpperCamelCase__=5						,			UpperCamelCase__=4						,			UpperCamelCase__=37						,			UpperCamelCase__="gelu"						,			UpperCamelCase__=0.1						,			UpperCamelCase__=0.1						,			UpperCamelCase__=10						,			UpperCamelCase__=0.02						,			UpperCamelCase__=0.9						,			UpperCamelCase__=None						,			)  -> Optional[Any]:





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

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

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



    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           A_		   = floats_tensor(
               [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]    )

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

           A_		   = self.get_config()

           return config, pixel_values, labels



    def    snake_case_     (   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=UpperCamelCase__						,			initializer_range=self.initializer_range						,			)



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> List[str]:





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



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> List[str]:





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

           A_		   = model(UpperCamelCase__						,			UpperCamelCase__    )
           # model only returns predictions for masked patches
           A_		   = mask.sum().item()
           A_		   = 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    )  -> str:





           '''simple docstring'''
           A_		   = self.prepare_config_and_inputs()
           A_   ,     A_   ,     A_		   = config_and_inputs
           A_		   = {"""pixel_values""": pixel_values}
           return config, inputs_dict


@require_torch
class    A__ ( _snake_case  ,  _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						(
        (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
    )
    lowercase		   =						(
        {"feature-extraction": VideoMAEModel, "video-classification": VideoMAEForVideoClassification}
        if is_torch_available()
        else {}
    )

    lowercase		   =						False
    lowercase		   =						False
    lowercase		   =						False
    lowercase		   =						False



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = VideoMAEModelTester(self    )
           A_		   = ConfigTester(self						,			config_class=UpperCamelCase__						,			has_text_modality=UpperCamelCase__						,			hidden_size=37    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__=False    )  -> int:





           '''simple docstring'''
           A_		   = copy.deepcopy(UpperCamelCase__    )

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

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

           return inputs_dict



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





           '''simple docstring'''
           self.config_tester.run_common_tests()



    @unittest.skip(reason="""VideoMAE does not use inputs_embeds"""    )
    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           pass



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_   ,     A_		   = self.model_tester.prepare_config_and_inputs_for_common()

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



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_   ,     A_		   = self.model_tester.prepare_config_and_inputs_for_common()

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

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



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__    )



    @slow
    def    snake_case_     (   self    )  -> Optional[int]:





           '''simple docstring'''
           for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_		   = VideoMAEModel.from_pretrained(UpperCamelCase__    )
                  self.assertIsNotNone(UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           if not self.has_attentions:
                  pass

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

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

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

                         # check that output_attentions also work using config
                         del inputs_dict["output_attentions"]
                         A_		   = True
                         A_		   = model_class(UpperCamelCase__    )
                         model.to(UpperCamelCase__    )
                         model.eval()
                         with torch.no_grad():
                                A_		   = model(**self._prepare_for_class(UpperCamelCase__						,			UpperCamelCase__    )    )
                         A_		   = outputs.attentions
                         self.assertEqual(len(UpperCamelCase__    )						,			self.model_tester.num_hidden_layers    )

                         self.assertListEqual(
                             list(attentions[0].shape[-3:]    )						,			[self.model_tester.num_attention_heads, seq_len, seq_len]						,			)
                         A_		   = len(UpperCamelCase__    )

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

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

                         A_		   = outputs.attentions

                         self.assertEqual(len(UpperCamelCase__    )						,			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    )  -> Optional[int]:





           '''simple docstring'''
           def check_hidden_states_output(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = model_class(UpperCamelCase__    )
                  model.to(UpperCamelCase__    )
                  model.eval()

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

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

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

           A_   ,     A_		   = self.model_tester.prepare_config_and_inputs_for_common()

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

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

                  check_hidden_states_output(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )







    @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""    )
    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           pass

def  UpperCAmelCase__      ( )     ->     Tuple:
       A_		   = hf_hub_download(
           repo_id="""hf-internal-testing/spaghetti-video""",    filename="""eating_spaghetti.npy""",    repo_type="""dataset"""			)
       A_		   = np.load(UpperCAmelCase__			)
       return list(UpperCAmelCase__			)







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



    @cached_property
    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           # 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    snake_case_     (   self    )  -> List[Any]:





           '''simple docstring'''
           A_		   = VideoMAEForVideoClassification.from_pretrained("""MCG-NJU/videomae-base-finetuned-kinetics"""    ).to(
               UpperCamelCase__    )

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

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

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

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

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







    @slow
    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short"""    ).to(UpperCamelCase__    )

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

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

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

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

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

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

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

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



'''simple docstring'''







def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     float:

       if edge <= 0 or not isinstance(UpperCAmelCase__,    UpperCAmelCase__			):
              raise ValueError("""Length must be a positive."""			)
       return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2)
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     float:

       if edge <= 0 or not isinstance(UpperCAmelCase__,    UpperCAmelCase__			):
              raise ValueError("""Length must be a positive."""			)
       return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
