


"""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 _lowerCAmelCase							:







   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		,      )      ->						int:

       '''simple docstring'''




       snake_case       : Optional[int]    =       parent
       snake_case       : Dict    =       batch_size
       snake_case       : List[str]    =       image_size
       snake_case       : Union[str, Any]    =       num_channels
       snake_case       : Any    =       patch_size
       snake_case       : Any    =       tubelet_size
       snake_case       : Dict    =       num_frames
       snake_case       : Union[str, Any]    =       is_training
       snake_case       : List[str]    =       use_labels
       snake_case       : int    =       hidden_size
       snake_case       : List[Any]    =       num_hidden_layers
       snake_case       : List[Any]    =       num_attention_heads
       snake_case       : Optional[Any]    =       intermediate_size
       snake_case       : Optional[int]    =       hidden_act
       snake_case       : Dict    =       hidden_dropout_prob
       snake_case       : str    =       attention_probs_dropout_prob
       snake_case       : Optional[int]    =       type_sequence_label_size
       snake_case       : Optional[int]    =       initializer_range
       snake_case       : Tuple    =       mask_ratio
       snake_case       : Union[str, Any]    =       scope

       # in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
       snake_case       : Optional[int]    =       (image_size // patch_size) ** 2
       snake_case       : int    =       (num_frames // tubelet_size) * self.num_patches_per_frame

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







   def 					lowerCamelCase						(      self		)      ->						List[Any]:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       floats_tensor(
           [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]		)

       snake_case       : str    =       None
       if self.use_labels:
           snake_case       : Optional[int]    =       ids_tensor([self.batch_size]		,      self.type_sequence_label_size		)

       snake_case       : Optional[Any]    =       self.get_config()

       return config, pixel_values, labels







   def 					lowerCamelCase						(      self		)      ->						List[str]:

       '''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 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)      ->						str:

       '''simple docstring'''




       snake_case       : int    =       VideoMAEModel(config=UpperCamelCase__		)
       model.to(UpperCamelCase__		)
       model.eval()
       snake_case       : Optional[Any]    =       model(UpperCamelCase__		)
       self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size)		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)      ->						Tuple:

       '''simple docstring'''




       snake_case       : Optional[Any]    =       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
       snake_case       : Any    =       torch.ones((self.num_masks,)		)
       snake_case       : List[Any]    =       torch.cat([mask, torch.zeros(self.seq_length - mask.size(0		)		)]		)
       snake_case       : Union[str, Any]    =       mask.expand(self.batch_size		,      -1		).bool()

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







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

       '''simple docstring'''




       snake_case       : Tuple    =       self.prepare_config_and_inputs()
       snake_case   ,snake_case   ,snake_case       : int    =       config_and_inputs
       snake_case       : List[Any]    =       {"pixel_values": pixel_values}
       return config, inputs_dict







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

   __UpperCAmelCase					:			Union[str, Any]				    =    False
   __UpperCAmelCase					:			Dict				    =    False
   __UpperCAmelCase					:			Tuple				    =    False
   __UpperCAmelCase					:			int				    =    False







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

       '''simple docstring'''




       snake_case       : Dict    =       VideoMAEModelTester(self		)
       snake_case       : Optional[int]    =       ConfigTester(self		,      config_class=UpperCamelCase__		,      has_text_modality=UpperCamelCase__		,      hidden_size=37		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__=False		)      ->						Optional[Any]:

       '''simple docstring'''




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

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

       return inputs_dict







   def 					lowerCamelCase						(      self		)      ->						List[str]:

       '''simple docstring'''




       self.config_tester.run_common_tests()







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

       '''simple docstring'''




       pass







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

       '''simple docstring'''




       snake_case   ,snake_case       : int    =       self.model_tester.prepare_config_and_inputs_for_common()

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







   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




       snake_case   ,snake_case       : Optional[Any]    =       self.model_tester.prepare_config_and_inputs_for_common()

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

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







   def 					lowerCamelCase						(      self		)      ->						List[Any]:

       '''simple docstring'''




       snake_case       : List[str]    =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCamelCase__		)







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

       '''simple docstring'''




       snake_case       : List[str]    =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__		)







   @slow
   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




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







   def 					lowerCamelCase						(      self		)      ->						Union[str, Any]:

       '''simple docstring'''




       if not self.has_attentions:
           pass

       else:
           snake_case   ,snake_case       : Dict    =       self.model_tester.prepare_config_and_inputs_for_common()
           snake_case       : Tuple    =       True

           for model_class in self.all_model_classes:
               snake_case       : Any    =       self.model_tester.seq_length - self.model_tester.num_masks
               snake_case       : Union[str, Any]    =       (
                   num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
               )

               snake_case       : List[Any]    =       True
               snake_case       : Tuple    =       False
               snake_case       : str    =       True
               snake_case       : int    =       model_class(UpperCamelCase__		)
               model.to(UpperCamelCase__		)
               model.eval()
               with torch.no_grad():
                   snake_case       : str    =       model(**self._prepare_for_class(UpperCamelCase__		,      UpperCamelCase__		)		)
               snake_case       : Optional[int]    =       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"]
               snake_case       : Optional[int]    =       True
               snake_case       : Optional[Any]    =       model_class(UpperCamelCase__		)
               model.to(UpperCamelCase__		)
               model.eval()
               with torch.no_grad():
                   snake_case       : str    =       model(**self._prepare_for_class(UpperCamelCase__		,      UpperCamelCase__		)		)
               snake_case       : Optional[Any]    =       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]		,      )
               snake_case       : Any    =       len(UpperCamelCase__		)

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

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

               snake_case       : Dict    =       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 					lowerCamelCase						(      self		)      ->						List[str]:

       '''simple docstring'''




       def check_hidden_states_output(UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		):
           snake_case       : List[Any]    =       model_class(UpperCamelCase__		)
           model.to(UpperCamelCase__		)
           model.eval()

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

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

           snake_case       : List[Any]    =       self.model_tester.seq_length - self.model_tester.num_masks
           snake_case       : Any    =       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]		,      )

       snake_case   ,snake_case       : Optional[Any]    =       self.model_tester.prepare_config_and_inputs_for_common()

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

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           snake_case       : Any    =       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 					lowerCamelCase						(      self		)      ->						List[Any]:

       '''simple docstring'''




       pass







def     __lowerCAmelCase		(		)      ->		int:


    """simple docstring"""





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







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







   @cached_property
   def 					lowerCamelCase						(      self		)      ->						List[str]:

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

       '''simple docstring'''




       snake_case       : Optional[int]    =       VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics"		).to(
           UpperCamelCase__		)

       snake_case       : Optional[int]    =       self.default_image_processor
       snake_case       : int    =       prepare_video()
       snake_case       : str    =       image_processor(UpperCamelCase__		,      return_tensors="pt"		).to(UpperCamelCase__		)

       # forward pass
       with torch.no_grad():
           snake_case       : Optional[int]    =       model(**UpperCamelCase__		)

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

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

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







   @slow
   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




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

       snake_case       : str    =       self.default_image_processor
       snake_case       : Tuple    =       prepare_video()
       snake_case       : Any    =       image_processor(UpperCamelCase__		,      return_tensors="pt"		).to(UpperCamelCase__		)

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

       # forward pass
       with torch.no_grad():
           snake_case       : Optional[int]    =       model(**UpperCamelCase__		)

       # verify the logits
       snake_case       : List[str]    =       torch.Size([1, 1408, 1536]		)
       snake_case       : Union[str, Any]    =       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`)
       snake_case       : int    =       torch.tensor([0.5142]		,      device=UpperCamelCase__		)
       self.assertTrue(torch.allclose(outputs.loss		,      UpperCamelCase__		,      atol=1e-4		)		)

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

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

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









"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__snake_case       =       {
    """configuration_bigbird_pegasus""": [
        """BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BigBirdPegasusConfig""",
        """BigBirdPegasusOnnxConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __snake_case       =       [
      """BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """BigBirdPegasusForCausalLM""",
      """BigBirdPegasusForConditionalGeneration""",
      """BigBirdPegasusForQuestionAnswering""",
      """BigBirdPegasusForSequenceClassification""",
      """BigBirdPegasusModel""",
      """BigBirdPegasusPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_bigbird_pegasus import (
      BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
      BigBirdPegasusConfig,
      BigBirdPegasusOnnxConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_bigbird_pegasus import (
        BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
        BigBirdPegasusForCausalLM,
        BigBirdPegasusForConditionalGeneration,
        BigBirdPegasusForQuestionAnswering,
        BigBirdPegasusForSequenceClassification,
        BigBirdPegasusModel,
        BigBirdPegasusPreTrainedModel,
    )


else:
  import sys

  __snake_case       =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





