

import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
   import torch

   from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin






class 	UpperCAmelCase__		:






  """simple docstring"""


  def __init__(							self						:		Optional[int]     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Union[str, Any]=None     ,       __lowerCamelCase						:		Optional[int]=None     ,       __lowerCamelCase						:		Tuple=None     ,       __lowerCamelCase						:		str="resnet50"     ,       __lowerCamelCase						:		Optional[Any]=3     ,       __lowerCamelCase						:		Tuple=32     ,       __lowerCamelCase						:		List[Any]=3     ,       __lowerCamelCase						:		Dict=True     ,       __lowerCamelCase						:		Dict=True     ,       )		->							Tuple:
       SCREAMING_SNAKE_CASE__   =   parent
       SCREAMING_SNAKE_CASE__   =   out_indices if out_indices is not None else [4]
       SCREAMING_SNAKE_CASE__   =   stage_names
       SCREAMING_SNAKE_CASE__   =   out_features
       SCREAMING_SNAKE_CASE__   =   backbone
       SCREAMING_SNAKE_CASE__   =   batch_size
       SCREAMING_SNAKE_CASE__   =   image_size
       SCREAMING_SNAKE_CASE__   =   num_channels
       SCREAMING_SNAKE_CASE__   =   use_pretrained_backbone
       SCREAMING_SNAKE_CASE__   =   is_training






  def 				lowercase_		(							self						:		Dict )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
       SCREAMING_SNAKE_CASE__   =   self.get_config()

       return config, pixel_values






  def 				lowercase_		(							self						:		str )		->							str:
       return TimmBackboneConfig(
           image_size=self.image_size     ,       num_channels=self.num_channels     ,       out_features=self.out_features     ,       out_indices=self.out_indices     ,       stage_names=self.stage_names     ,       use_pretrained_backbone=self.use_pretrained_backbone     ,       backbone=self.backbone     ,       )






  def 				lowercase_		(							self						:		Optional[Any]     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		Dict )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   TimmBackbone(config=__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       with torch.no_grad():
            SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase )
       self.parent.assertEqual(
           result.feature_map[-1].shape     ,       (self.batch_size, model.channels[-1], 14, 14)     ,       )







  def 				lowercase_		(							self						:		Dict )		->							int:
       SCREAMING_SNAKE_CASE__   =   self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   config_and_inputs
       SCREAMING_SNAKE_CASE__   =   {'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_torch
@require_timm
class 	UpperCAmelCase__		(	A__						,					A__						,					A__						,					unittest.TestCase	):






  """simple docstring"""


  a									= (TimmBackbone,) if is_torch_available() else ()
  a									= {"feature-extraction": TimmBackbone} if is_torch_available() else {}
  a									= False
  a									= False
  a									= False
  a									= False






  def 				lowercase_		(							self						:		str )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   TimmBackboneModelTester(self )
       SCREAMING_SNAKE_CASE__   =   ConfigTester(self     ,       config_class=__lowerCamelCase     ,       has_text_modality=__lowerCamelCase )






  def 				lowercase_		(							self						:		Union[str, Any] )		->							List[Any]:
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()






  def 				lowercase_		(							self						:		Any )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   '''resnet18'''
       SCREAMING_SNAKE_CASE__   =   '''microsoft/resnet-18'''

       SCREAMING_SNAKE_CASE__   =   AutoBackbone.from_pretrained(__lowerCamelCase     ,       use_timm_backbone=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   AutoBackbone.from_pretrained(__lowerCamelCase )

       self.assertEqual(len(timm_model.out_features )     ,       len(transformers_model.out_features ) )
       self.assertEqual(len(timm_model.stage_names )     ,       len(transformers_model.stage_names ) )
       self.assertEqual(timm_model.channels     ,       transformers_model.channels )
       # Out indices are set to the last layer by default. For timm models, we don't know
       # the number of layers in advance, so we set it to (-1,), whereas for transformers
       # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
       self.assertEqual(timm_model.out_indices     ,       (-1,) )
       self.assertEqual(transformers_model.out_indices     ,       [len(timm_model.stage_names ) - 1] )

       SCREAMING_SNAKE_CASE__   =   AutoBackbone.from_pretrained(__lowerCamelCase     ,       use_timm_backbone=__lowerCamelCase     ,       out_indices=[1, 2, 3] )
       SCREAMING_SNAKE_CASE__   =   AutoBackbone.from_pretrained(__lowerCamelCase     ,       out_indices=[1, 2, 3] )

       self.assertEqual(timm_model.out_indices     ,       transformers_model.out_indices )
       self.assertEqual(len(timm_model.out_features )     ,       len(transformers_model.out_features ) )
       self.assertEqual(timm_model.channels     ,       transformers_model.channels )






  @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking''' )
  def 				lowercase_		(							self						:		str )		->							int:
       pass






  @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''' )
  def 				lowercase_		(							self						:		Union[str, Any] )		->							int:
       pass






  @unittest.skip('''TimmBackbone initialization is managed on the timm side''' )
  def 				lowercase_		(							self						:		Any )		->							Dict:
       pass






  @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
  def 				lowercase_		(							self						:		int )		->							Dict:
       pass






  @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
  def 				lowercase_		(							self						:		List[Any] )		->							Optional[Any]:
       pass






  @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''' )
  def 				lowercase_		(							self						:		Optional[Any] )		->							int:
       pass






  @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
  def 				lowercase_		(							self						:		Any )		->							List[str]:
       pass






  @unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
  def 				lowercase_		(							self						:		Dict )		->							str:
       pass






  @unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
  def 				lowercase_		(							self						:		Optional[Any] )		->							int:
       pass






  @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
  def 				lowercase_		(							self						:		Dict )		->							List[Any]:
       pass






  @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
  def 				lowercase_		(							self						:		List[Any] )		->							str:
       pass






  @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''' )
  def 				lowercase_		(							self						:		List[str] )		->							List[Any]:
       pass






  @unittest.skip('''TimmBackbone doesn\'t support output_attentions.''' )
  def 				lowercase_		(							self						:		List[str] )		->							Optional[Any]:
       pass






  @unittest.skip('''Safetensors is not supported by timm.''' )
  def 				lowercase_		(							self						:		Tuple )		->							Optional[int]:
       pass






  @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
  def 				lowercase_		(							self						:		Any )		->							List[Any]:
       pass






  def 				lowercase_		(							self						:		Dict )		->							List[str]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()

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

            SCREAMING_SNAKE_CASE__   =   ['''pixel_values''']
            self.assertListEqual(arg_names[:1]     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Dict )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__   =   True
       SCREAMING_SNAKE_CASE__   =   self.has_attentions

       # no need to test all models as different heads yield the same functionality
       SCREAMING_SNAKE_CASE__   =   self.all_model_classes[0]
       SCREAMING_SNAKE_CASE__   =   model_class(__lowerCamelCase )
       model.to(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self._prepare_for_class(__lowerCamelCase     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   model(**__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   outputs[0][-1]

       # Encoder-/Decoder-only models
       SCREAMING_SNAKE_CASE__   =   outputs.hidden_states[0]
       hidden_states.retain_grad()

       if self.has_attentions:
            SCREAMING_SNAKE_CASE__   =   outputs.attentions[0]
            attentions.retain_grad()

       output.flatten()[0].backward(retain_graph=__lowerCamelCase )

       self.assertIsNotNone(hidden_states.grad )

       if self.has_attentions:
            self.assertIsNotNone(attentions.grad )







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

       for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__   =   model_class(__lowerCamelCase )
            model.to(__lowerCamelCase )
            model.eval()
            SCREAMING_SNAKE_CASE__   =   model(**__lowerCamelCase )

            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
            SCREAMING_SNAKE_CASE__   =   copy.deepcopy(__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   None
            SCREAMING_SNAKE_CASE__   =   model_class(__lowerCamelCase )
            model.to(__lowerCamelCase )
            model.eval()
            SCREAMING_SNAKE_CASE__   =   model(**__lowerCamelCase )

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

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





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


_SCREAMING_SNAKE_CASE					:  Any             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      {
    '''google/vivit-b-16x2-kinetics400''': (
        '''https://huggingface.co/google/vivit-b-16x2-kinetics400/resolve/main/config.json'''
    ),
    # See all Vivit models at https://huggingface.co/models?filter=vivit
}






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "vivit"






  def __init__(							self						:		str     ,       __lowerCamelCase						:		List[Any]=224     ,       __lowerCamelCase						:		Optional[int]=32     ,       __lowerCamelCase						:		Tuple=[2, 16, 16]     ,       __lowerCamelCase						:		Union[str, Any]=3     ,       __lowerCamelCase						:		Optional[Any]=768     ,       __lowerCamelCase						:		Any=12     ,       __lowerCamelCase						:		Optional[Any]=12     ,       __lowerCamelCase						:		List[str]=3072     ,       __lowerCamelCase						:		Any="gelu_fast"     ,       __lowerCamelCase						:		Union[str, Any]=0.0     ,       __lowerCamelCase						:		int=0.0     ,       __lowerCamelCase						:		str=0.02     ,       __lowerCamelCase						:		Any=1e-06     ,       __lowerCamelCase						:		Dict=True     ,       **__lowerCamelCase						:		Any     ,       )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   hidden_dropout_prob
       SCREAMING_SNAKE_CASE__   =   attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   layer_norm_eps

       SCREAMING_SNAKE_CASE__   =   image_size
       SCREAMING_SNAKE_CASE__   =   num_frames
       SCREAMING_SNAKE_CASE__   =   tubelet_size
       SCREAMING_SNAKE_CASE__   =   num_channels
       SCREAMING_SNAKE_CASE__   =   qkv_bias

       super().__init__(**__lowerCamelCase )


