
"""simple docstring"""





from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
    from PIL import Image

    from transformers import ConvNextImageProcessor


class A_      :




  '''simple docstring'''







  def __init__(						self							,  lowercase_							,  lowercase_=13							,  lowercase_=32							,  lowercase_=3							,  lowercase_=4							,  lowercase_=[10, 20, 30, 40]							,  lowercase_=[2, 2, 3, 2]							,  lowercase_=True							,  lowercase_=True							,  lowercase_=37							,  lowercase_="gelu"							,  lowercase_=10							,  lowercase_=0.02							,  lowercase_=3							,  lowercase_=None							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       parent
     UpperCAmelCase_   :   int     	=       batch_size
     UpperCAmelCase_   :   int     	=       image_size
     UpperCAmelCase_   :   Union[str, Any]     	=       num_channels
     UpperCAmelCase_   :   Any     	=       num_stages
     UpperCAmelCase_   :   Dict     	=       hidden_sizes
     UpperCAmelCase_   :   List[Any]     	=       depths
     UpperCAmelCase_   :   Tuple     	=       is_training
     UpperCAmelCase_   :   Union[str, Any]     	=       use_labels
     UpperCAmelCase_   :   List[str]     	=       intermediate_size
     UpperCAmelCase_   :   Union[str, Any]     	=       hidden_act
     UpperCAmelCase_   :   Tuple     	=       type_sequence_label_size
     UpperCAmelCase_   :   Any     	=       initializer_range
     UpperCAmelCase_   :   Union[str, Any]     	=       scope







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[str]     	=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

     UpperCAmelCase_   :   Any     	=       None
     if self.use_labels:
        UpperCAmelCase_   :   str     	=       ids_tensor([self.batch_size]							,  self.type_sequence_label_size    )

     UpperCAmelCase_   :   int     	=       self.get_config()

     return config, pixel_values, labels







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return ConvNextConfig(
         num_channels=self.num_channels							,  hidden_sizes=self.hidden_sizes							,  depths=self.depths							,  num_stages=self.num_stages							,  hidden_act=self.hidden_act							,  is_decoder=lowercase_							,  initializer_range=self.initializer_range							,  )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   str     	=       TFConvNextModel(config=lowercase_    )
     UpperCAmelCase_   :   Tuple     	=       model(lowercase_							,  training=lowercase_    )
     # expected last hidden states: B, C, H // 32, W // 32
     self.parent.assertEqual(
         result.last_hidden_state.shape							,  (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)							,  )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   Union[str, Any]     	=       self.type_sequence_label_size
     UpperCAmelCase_   :   int     	=       TFConvNextForImageClassification(lowercase_    )
     UpperCAmelCase_   :   int     	=       model(lowercase_							,  labels=lowercase_							,  training=lowercase_    )
     self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.type_sequence_label_size)    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Any     	=       self.prepare_config_and_inputs()
     UpperCAmelCase_	,  UpperCAmelCase_	,  UpperCAmelCase_   :   Any     	=       config_and_inputs
     UpperCAmelCase_   :   List[Any]     	=       {"pixel_values": pixel_values}
     return config, inputs_dict




@require_tf
class A_      (lowercase__							,lowercase__							,unittest.TestCase ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__     :		str    	=						(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__     :		Dict    	=						(
      {"""feature-extraction""": TFConvNextModel, """image-classification""": TFConvNextForImageClassification}
      if is_tf_available()
      else {}
  )

  SCREAMING_SNAKE_CASE__     :		Tuple    	=						False
  SCREAMING_SNAKE_CASE__     :		Union[str, Any]    	=						False
  SCREAMING_SNAKE_CASE__     :		Union[str, Any]    	=						False
  SCREAMING_SNAKE_CASE__     :		str    	=						False
  SCREAMING_SNAKE_CASE__     :		Any    	=						False







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   str     	=       TFConvNextModelTester(self    )
     UpperCAmelCase_   :   Union[str, Any]     	=       ConfigTester(
         self							,  config_class=lowercase_							,  has_text_modality=lowercase_							,  hidden_size=37							,  )







  @unittest.skip(reason="ConvNext does not use inputs_embeds"    )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     pass







  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices("GPU"    )    ) == 0							,  reason="TF does not support backprop for grouped convolutions on CPU."							,  )
  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     super().test_keras_fit()







  @unittest.skip(reason="ConvNext does not support input and output embeddings"    )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     pass







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[int]     	=       self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        UpperCAmelCase_   :   int     	=       model_class(lowercase_    )
        UpperCAmelCase_   :   Tuple     	=       inspect.signature(model.call    )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        UpperCAmelCase_   :   int     	=       [*signature.parameters.keys()]

        UpperCAmelCase_   :   int     	=       ["pixel_values"]
        self.assertListEqual(arg_names[:1]							,  lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   int     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_    )







  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices("GPU"    )    ) == 0							,  reason="TF does not support backprop for grouped convolutions on CPU."							,  )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     super().test_dataset_conversion()







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     def check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    ):
        UpperCAmelCase_   :   Dict     	=       model_class(lowercase_    )

        UpperCAmelCase_   :   List[str]     	=       model(**self._prepare_for_class(lowercase_							,  lowercase_    )    )
        UpperCAmelCase_   :   List[Any]     	=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        UpperCAmelCase_   :   List[Any]     	=       self.model_tester.num_stages
        self.assertEqual(len(lowercase_    )							,  expected_num_stages + 1    )

        # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
        self.assertListEqual(
            list(hidden_states[0].shape[-2:]    )							,  [self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,  )

     UpperCAmelCase_	,  UpperCAmelCase_   :   str     	=       self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        UpperCAmelCase_   :   Dict     	=       True
        check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        UpperCAmelCase_   :   Any     	=       True

        check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Union[str, Any]     	=       self.model_tester.prepare_config_and_inputs_for_common()

     def check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  lowercase_={}    ):
        UpperCAmelCase_   :   Optional[int]     	=       model(lowercase_							,  return_dict=lowercase_							,  **lowercase_    )
        UpperCAmelCase_   :   Optional[Any]     	=       model(lowercase_							,  return_dict=lowercase_							,  **lowercase_    ).to_tuple()

        def recursive_check(lowercase_							,  lowercase_    ):
           if isinstance(lowercase_							,  (List, Tuple)    ):
              for tuple_iterable_value, dict_iterable_value in zip(lowercase_							,  lowercase_    ):
                 recursive_check(lowercase_							,  lowercase_    )
           elif tuple_object is None:
              return
           else:
              self.assertTrue(
                  all(tf.equal(lowercase_							,  lowercase_    )    )							,  msg=(
                      "Tuple and dict output are not equal. Difference:"
                      F""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object    )    )}"""
                  )							,  )

           recursive_check(lowercase_							,  lowercase_    )

     for model_class in self.all_model_classes:
        UpperCAmelCase_   :   Optional[int]     	=       model_class(lowercase_    )

        UpperCAmelCase_   :   Optional[int]     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        UpperCAmelCase_   :   int     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_    )

        UpperCAmelCase_   :   Optional[Any]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        UpperCAmelCase_   :   List[str]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_    )

        UpperCAmelCase_   :   str     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        UpperCAmelCase_   :   Tuple     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  {"output_hidden_states": True}    )

        UpperCAmelCase_   :   Any     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        UpperCAmelCase_   :   Optional[Any]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  {"output_hidden_states": True}    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowercase_    )







  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       TFConvNextModel.from_pretrained("facebook/convnext-tiny-224"    )
     self.assertIsNotNone(lowercase_    )







def       __a	(						):
   UpperCAmelCase_   :   Tuple     	=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
   return image


@require_tf
@require_vision
class A_      (unittest.TestCase ):




  '''simple docstring'''







  @cached_property
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return ConvNextImageProcessor.from_pretrained("facebook/convnext-tiny-224"    ) if is_vision_available() else None







  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       TFConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"    )

     UpperCAmelCase_   :   str     	=       self.default_image_processor
     UpperCAmelCase_   :   Optional[Any]     	=       prepare_img()
     UpperCAmelCase_   :   Dict     	=       image_processor(images=lowercase_							,  return_tensors="tf"    )

     # forward pass
     UpperCAmelCase_   :   Optional[int]     	=       model(**lowercase_    )

     # verify the logits
     UpperCAmelCase_   :   List[str]     	=       tf.TensorShape((1, 1000)    )
     self.assertEqual(outputs.logits.shape							,  lowercase_    )

     UpperCAmelCase_   :   Any     	=       tf.constant([-0.02_60, -0.47_39, 0.19_11]    )

     tf.debugging.assert_near(outputs.logits[0, :3]							,  lowercase_							,  atol=1E-4    )






'''simple docstring'''
import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor



def 				lowerCAmelCase__	(       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Dict          =					TimesformerConfig()

       if "large" in model_name:
              snake_case__					:	int          =					96

       if "hr" in model_name:
              snake_case__					:	int          =					16
              snake_case__					:	int          =					448

       snake_case__					:	int          =					"""huggingface/label-files"""
       if "k400" in model_name:
              snake_case__					:	List[Any]          =					400
              snake_case__					:	List[str]          =					"""kinetics400-id2label.json"""
       elif "k600" in model_name:
              snake_case__					:	Optional[int]          =					600
              snake_case__					:	int          =					"""kinetics600-id2label.json"""
       elif "ssv2" in model_name:
              snake_case__					:	Any          =					174
              snake_case__					:	Union[str, Any]          =					"""something-something-v2-id2label.json"""
       else:
              raise ValueError("""Model name should either contain 'k400', 'k600' or 'ssv2'."""     )
       snake_case__					:	List[str]          =					json.load(open(hf_hub_download(UpperCAmelCase    ,       UpperCAmelCase    ,       repo_type="""dataset"""     )    ,       """r"""     )     )
       snake_case__					:	Tuple          =					{int(UpperCAmelCase     ): v for k, v in idalabel.items()}
       snake_case__					:	int          =					idalabel
       snake_case__					:	Optional[int]          =					{v: k for k, v in idalabel.items()}

       return config



def 				lowerCAmelCase__	(       UpperCAmelCase     ):






       """simple docstring"""





       if "encoder." in name:
              snake_case__					:	Union[str, Any]          =					name.replace("""encoder."""    ,       """"""     )
       if "cls_token" in name:
              snake_case__					:	Any          =					name.replace("""cls_token"""    ,       """timesformer.embeddings.cls_token"""     )
       if "pos_embed" in name:
              snake_case__					:	Tuple          =					name.replace("""pos_embed"""    ,       """timesformer.embeddings.position_embeddings"""     )
       if "time_embed" in name:
              snake_case__					:	Optional[int]          =					name.replace("""time_embed"""    ,       """timesformer.embeddings.time_embeddings"""     )
       if "patch_embed.proj" in name:
              snake_case__					:	Optional[int]          =					name.replace("""patch_embed.proj"""    ,       """timesformer.embeddings.patch_embeddings.projection"""     )
       if "patch_embed.norm" in name:
              snake_case__					:	Tuple          =					name.replace("""patch_embed.norm"""    ,       """timesformer.embeddings.norm"""     )
       if "blocks" in name:
              snake_case__					:	Optional[int]          =					name.replace("""blocks"""    ,       """timesformer.encoder.layer"""     )
       if "attn.proj" in name:
              snake_case__					:	Optional[int]          =					name.replace("""attn.proj"""    ,       """attention.output.dense"""     )
       if "attn" in name and "bias" not in name and "temporal" not in name:
              snake_case__					:	Any          =					name.replace("""attn"""    ,       """attention.self"""     )
       if "attn" in name and "temporal" not in name:
              snake_case__					:	Optional[Any]          =					name.replace("""attn"""    ,       """attention.attention"""     )
       if "temporal_norm1" in name:
              snake_case__					:	Optional[int]          =					name.replace("""temporal_norm1"""    ,       """temporal_layernorm"""     )
       if "temporal_attn.proj" in name:
              snake_case__					:	Any          =					name.replace("""temporal_attn"""    ,       """temporal_attention.output.dense"""     )
       if "temporal_fc" in name:
              snake_case__					:	Union[str, Any]          =					name.replace("""temporal_fc"""    ,       """temporal_dense"""     )
       if "norm1" in name and "temporal" not in name:
              snake_case__					:	Any          =					name.replace("""norm1"""    ,       """layernorm_before"""     )
       if "norm2" in name:
              snake_case__					:	Union[str, Any]          =					name.replace("""norm2"""    ,       """layernorm_after"""     )
       if "mlp.fc1" in name:
              snake_case__					:	List[str]          =					name.replace("""mlp.fc1"""    ,       """intermediate.dense"""     )
       if "mlp.fc2" in name:
              snake_case__					:	Tuple          =					name.replace("""mlp.fc2"""    ,       """output.dense"""     )
       if "norm.weight" in name and "fc" not in name and "temporal" not in name:
              snake_case__					:	Optional[int]          =					name.replace("""norm.weight"""    ,       """timesformer.layernorm.weight"""     )
       if "norm.bias" in name and "fc" not in name and "temporal" not in name:
              snake_case__					:	Tuple          =					name.replace("""norm.bias"""    ,       """timesformer.layernorm.bias"""     )
       if "head" in name:
              snake_case__					:	str          =					name.replace("""head"""    ,       """classifier"""     )

       return name



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       for key in orig_state_dict.copy().keys():
              snake_case__					:	Any          =					orig_state_dict.pop(UpperCAmelCase     )

              if key.startswith("""model."""     ):
                     snake_case__					:	Tuple          =					key.replace("""model."""    ,       """"""     )

              if "qkv" in key:
                     snake_case__					:	int          =					key.split("""."""     )
                     snake_case__					:	Union[str, Any]          =					int(key_split[1]     )
                     snake_case__					:	int          =					"""timesformer.encoder.layer."""
                     if "temporal" in key:
                            snake_case__					:	Any          =					""".temporal_attention.attention.qkv."""
                     else:
                            snake_case__					:	Any          =					""".attention.attention.qkv."""
                     if "weight" in key:
                            snake_case__					:	Dict          =					val
                     else:
                            snake_case__					:	str          =					val
              else:
                     snake_case__					:	Any          =					val

       return orig_state_dict



def 				lowerCAmelCase__	(       ):






       """simple docstring"""





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



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Any          =					get_timesformer_config(UpperCAmelCase     )

       snake_case__					:	Optional[int]          =					TimesformerForVideoClassification(UpperCAmelCase     )

       # download original checkpoint, hosted on Google Drive
       snake_case__					:	str          =					"""pytorch_model.bin"""
       gdown.cached_download(UpperCAmelCase    ,       UpperCAmelCase    ,       quiet=UpperCAmelCase     )
       snake_case__					:	Dict          =					torch.load(UpperCAmelCase    ,       map_location="""cpu"""     )
       if "model" in files:
              snake_case__					:	Optional[Any]          =					files["""model"""]
       elif "module" in files:
              snake_case__					:	List[str]          =					files["""module"""]
       else:
              snake_case__					:	str          =					files["""model_state"""]
       snake_case__					:	List[Any]          =					convert_state_dict(UpperCAmelCase    ,       UpperCAmelCase     )

       model.load_state_dict(UpperCAmelCase     )
       model.eval()

       # verify model on basic input
       snake_case__					:	Any          =					VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]    ,       image_std=[0.5, 0.5, 0.5]     )
       snake_case__					:	Union[str, Any]          =					prepare_video()
       snake_case__					:	str          =					image_processor(video[:8]    ,       return_tensors="""pt"""     )

       snake_case__					:	int          =					model(**UpperCAmelCase     )
       snake_case__					:	Tuple          =					outputs.logits

       snake_case__					:	List[str]          =					[
           # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-k400""",
           """timesformer-large-finetuned-k400""",
           """timesformer-hr-finetuned-k400""",
           # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-k600""",
           """timesformer-large-finetuned-k600""",
           """timesformer-hr-finetuned-k600""",
           # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-ssv2""",
           """timesformer-large-finetuned-ssv2""",
           """timesformer-hr-finetuned-ssv2""",
       ]

       # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
       if model_name == "timesformer-base-finetuned-k400":
              snake_case__					:	str          =					torch.Size([1, 400]     )
              snake_case__					:	str          =					torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]     )
       elif model_name == "timesformer-base-finetuned-k600":
              snake_case__					:	Dict          =					torch.Size([1, 600]     )
              snake_case__					:	str          =					torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]     )
       elif model_name == "timesformer-base-finetuned-ssv2":
              snake_case__					:	List[Any]          =					torch.Size([1, 174]     )
              snake_case__					:	Union[str, Any]          =					torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]     )
       elif model_name == "timesformer-large-finetuned-k400":
              snake_case__					:	Optional[Any]          =					torch.Size([1, 400]     )
              snake_case__					:	Tuple          =					torch.tensor([0, 0, 0]     )
       elif model_name == "timesformer-large-finetuned-k600":
              snake_case__					:	Optional[int]          =					torch.Size([1, 600]     )
              snake_case__					:	int          =					torch.tensor([0, 0, 0]     )
       elif model_name == "timesformer-large-finetuned-ssv2":
              snake_case__					:	Union[str, Any]          =					torch.Size([1, 174]     )
              snake_case__					:	List[Any]          =					torch.tensor([0, 0, 0]     )
       elif model_name == "timesformer-hr-finetuned-k400":
              snake_case__					:	str          =					torch.Size([1, 400]     )
              snake_case__					:	List[Any]          =					torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]     )
       elif model_name == "timesformer-hr-finetuned-k600":
              snake_case__					:	Optional[int]          =					torch.Size([1, 600]     )
              snake_case__					:	str          =					torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]     )
       elif model_name == "timesformer-hr-finetuned-ssv2":
              snake_case__					:	int          =					torch.Size([1, 174]     )
              snake_case__					:	Optional[Any]          =					torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]     )
       else:
              raise ValueError(f"""Model name not supported. Should be one of {model_names}"""     )

       # verify logits
       assert logits.shape == expected_shape
       assert torch.allclose(logits[0, :3]    ,       UpperCAmelCase    ,       atol=1E-4     )
       print("""Logits ok!"""     )

       if pytorch_dump_folder_path is not None:
              print(f"""Saving model and image processor to {pytorch_dump_folder_path}"""     )
              image_processor.save_pretrained(UpperCAmelCase     )
              model.save_pretrained(UpperCAmelCase     )

       if push_to_hub:
              print("""Pushing to the hub..."""     )
              model.push_to_hub(f"""fcakyon/{model_name}"""     )


if __name__ == "__main__":
     lowerCAmelCase__  =     argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--checkpoint_url',
         default='https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download',
         type=str,
         help=(
             'URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'
             ' download link.'
         ),
     )
     parser.add_argument(
         '--pytorch_dump_folder_path',
         default='',
         type=str,
         help='Path to the output PyTorch model directory.',
     )
     parser.add_argument('--model_name', default='timesformer-base-finetuned-k400', type=str, help='Name of the model.')
     parser.add_argument(
         '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
     )

     lowerCAmelCase__  =     parser.parse_args()
     convert_timesformer_checkpoint(
         args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
     )




