





import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class 						_lowerCAmelCase:

  """simple docstring"""







  lowerCamelCase__      					=   ()
  lowerCamelCase__      					=   True

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Optional[int]:
     __A				 =       self.config_class

     # test default config
     __A				 =       config_class()
     self.assertIsNotNone(UpperCAmelCase     )
     __A				 =       ['''stem'''] + [f"stage{idx}" for idx in range(1  ,    len(config.depths     ) + 1     )]
     self.assertEqual(config.stage_names  ,    UpperCAmelCase     )
     self.assertTrue(set(config.out_features     ).issubset(set(config.stage_names     )     )     )

     # Test out_features and out_indices are correctly set
     # out_features and out_indices both None
     __A				 =       config_class(out_features=UpperCAmelCase  ,    out_indices=UpperCAmelCase     )
     self.assertEqual(config.out_features  ,    [config.stage_names[-1]]     )
     self.assertEqual(config.out_indices  ,    [len(config.stage_names     ) - 1]     )

     # out_features and out_indices both set
     __A				 =       config_class(out_features=['''stem''', '''stage1''']  ,    out_indices=[0, 1]     )
     self.assertEqual(config.out_features  ,    ['''stem''', '''stage1''']     )
     self.assertEqual(config.out_indices  ,    [0, 1]     )

     # Only out_features set
     __A				 =       config_class(out_features=['''stage1''', '''stage3''']     )
     self.assertEqual(config.out_features  ,    ['''stage1''', '''stage3''']     )
     self.assertEqual(config.out_indices  ,    [1, 3]     )

     # Only out_indices set
     __A				 =       config_class(out_indices=[0, 2]     )
     self.assertEqual(config.out_features  ,    [config.stage_names[0], config.stage_names[2]]     )
     self.assertEqual(config.out_indices  ,    [0, 2]     )

     # Error raised when out_indices do not correspond to out_features
     with self.assertRaises(UpperCAmelCase     ):
        __A				 =       config_class(out_features=['''stage1''', '''stage2''']  ,    out_indices=[0, 2]     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
     __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 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
     __A ,						__A				 =       self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __A				 =       model_class(UpperCAmelCase     )
        self.assertEqual(len(model.channels     )  ,    len(config.out_features     )     )
        __A				 =       model.num_features
        __A				 =       [config.stage_names.index(UpperCAmelCase     ) for feat in config.out_features]
        __A				 =       [num_features[idx] for idx in out_indices]
        self.assertListEqual(model.channels  ,    UpperCAmelCase     )

        __A				 =       copy.deepcopy(UpperCAmelCase     )
        __A				 =       None
        __A				 =       model_class(UpperCAmelCase     )
        self.assertEqual(len(model.channels     )  ,    1     )
        self.assertListEqual(model.channels  ,    [num_features[-1]]     )

        __A				 =       copy.deepcopy(UpperCAmelCase     )
        __A				 =       None
        __A				 =       model_class(UpperCAmelCase     )
        self.assertEqual(len(model.channels     )  ,    1     )
        self.assertListEqual(model.channels  ,    [num_features[-1]]     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Union[str, Any]:
     __A ,						__A				 =       self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __A				 =       model_class(UpperCAmelCase     )
        model.to(UpperCAmelCase     )
        model.eval()
        __A				 =       model(**UpperCAmelCase     )

        self.assertEqual(len(result.feature_maps     )  ,    len(config.out_features     )     )
        self.assertEqual(len(model.channels     )  ,    len(config.out_features     )     )
        self.assertEqual(len(result.feature_maps     )  ,    len(config.out_indices     )     )
        self.assertEqual(len(model.channels     )  ,    len(config.out_indices     )     )

        # Check output of last stage is taken if out_features=None, out_indices=None
        __A				 =       copy.deepcopy(UpperCAmelCase     )
        __A				 =       None
        __A				 =       model_class(UpperCAmelCase     )
        model.to(UpperCAmelCase     )
        model.eval()
        __A				 =       model(**UpperCAmelCase     )

        self.assertEqual(len(result.feature_maps     )  ,    1     )
        self.assertEqual(len(model.channels     )  ,    1     )

        __A				 =       copy.deepcopy(UpperCAmelCase     )
        __A				 =       None
        __A				 =       model_class(UpperCAmelCase     )
        model.to(UpperCAmelCase     )
        model.eval()
        __A				 =       model(**UpperCAmelCase     )

        self.assertEqual(len(result.feature_maps     )  ,    1     )
        self.assertEqual(len(model.channels     )  ,    1     )

        # Check backbone can be initialized with fresh weights
        __A				 =       copy.deepcopy(UpperCAmelCase     )
        __A				 =       False
        __A				 =       model_class(UpperCAmelCase     )
        model.to(UpperCAmelCase     )
        model.eval()
        __A				 =       model(**UpperCAmelCase     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Tuple:
     __A ,						__A				 =       self.model_tester.prepare_config_and_inputs_for_common()

     for backbone_class in self.all_model_classes:
        __A				 =       backbone_class(UpperCAmelCase     )

        self.assertTrue(hasattr(UpperCAmelCase  ,    '''backbone_type'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''stage_names'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''num_features'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''out_indices'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''out_features'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''out_feature_channels'''     )     )
        self.assertTrue(hasattr(UpperCAmelCase  ,    '''channels'''     )     )

        self.assertIsInstance(backbone.backbone_type  ,    UpperCAmelCase     )
        # Verify num_features has been initialized in the backbone init
        self.assertIsNotNone(backbone.num_features     )
        self.assertTrue(len(backbone.channels     ) == len(backbone.out_indices     )     )
        self.assertTrue(len(backbone.stage_names     ) == len(backbone.num_features     )     )
        self.assertTrue(len(backbone.channels     ) <= len(backbone.num_features     )     )
        self.assertTrue(len(backbone.out_feature_channels     ) == len(backbone.stage_names     )     )





  def 		SCREAMING_SNAKE_CASE__	( self     )-> List[Any]:
     __A ,						__A				 =       self.model_tester.prepare_config_and_inputs_for_common()
     __A				 =       inputs_dict['''pixel_values'''].shape[0]

     for backbone_class in self.all_model_classes:
        __A				 =       backbone_class(UpperCAmelCase     )
        backbone.to(UpperCAmelCase     )
        backbone.eval()

        __A				 =       backbone(**UpperCAmelCase     )

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps  ,    UpperCAmelCase     )
        self.assertTrue(len(outputs.feature_maps     ) == len(backbone.channels     )     )
        for feature_map, n_channels in zip(outputs.feature_maps  ,    backbone.channels     ):
           self.assertTrue(feature_map.shape[:2]  ,    (batch_size, n_channels)     )
        self.assertIsNone(outputs.hidden_states     )
        self.assertIsNone(outputs.attentions     )

        # Test output_hidden_states=True
        __A				 =       backbone(**UpperCAmelCase  ,    output_hidden_states=UpperCAmelCase     )
        self.assertIsNotNone(outputs.hidden_states     )
        self.assertTrue(len(outputs.hidden_states     )  ,    len(backbone.stage_names     )     )
        for hidden_state, n_channels in zip(outputs.hidden_states  ,    backbone.channels     ):
           self.assertTrue(hidden_state.shape[:2]  ,    (batch_size, n_channels)     )

        # Test output_attentions=True
        if self.has_attentions:
           __A				 =       backbone(**UpperCAmelCase  ,    output_attentions=UpperCAmelCase     )
           self.assertIsNotNone(outputs.attentions     )








from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCamelCase   :							Dict     =	logging.get_logger(__name__)

_UpperCamelCase   :							Optional[int]     =	{
    """MCG-NJU/videomae-base""": """https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json""",
}







class 						_lowerCAmelCase(						_a):

  """simple docstring"""







  lowerCamelCase__      					=   '''videomae'''

  def __init__( self  ,    UpperCAmelCase=2_24  ,    UpperCAmelCase=16  ,    UpperCAmelCase=3  ,    UpperCAmelCase=16  ,    UpperCAmelCase=2  ,    UpperCAmelCase=7_68  ,    UpperCAmelCase=12  ,    UpperCAmelCase=12  ,    UpperCAmelCase=30_72  ,    UpperCAmelCase="gelu"  ,    UpperCAmelCase=0.0  ,    UpperCAmelCase=0.0  ,    UpperCAmelCase=0.02  ,    UpperCAmelCase=1e-12  ,    UpperCAmelCase=True  ,    UpperCAmelCase=True  ,    UpperCAmelCase=6  ,    UpperCAmelCase=3_84  ,    UpperCAmelCase=4  ,    UpperCAmelCase=15_36  ,    UpperCAmelCase=True  ,    **UpperCAmelCase  ,    )-> Any:
     super().__init__(**UpperCAmelCase     )

     __A				 =       image_size
     __A				 =       patch_size
     __A				 =       num_channels
     __A				 =       num_frames
     __A				 =       tubelet_size

     __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				 =       initializer_range
     __A				 =       layer_norm_eps
     __A				 =       qkv_bias
     __A				 =       use_mean_pooling

     __A				 =       decoder_num_attention_heads
     __A				 =       decoder_hidden_size
     __A				 =       decoder_num_hidden_layers
     __A				 =       decoder_intermediate_size
     __A				 =       norm_pix_loss

