
'''simple docstring'''
from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor







class  __A				:
 def __init__(   self			:    List[str]				,   lowerCamelCase			:    Dict				,   lowerCamelCase			:    Tuple=3				,   lowerCamelCase			:    List[Any]=32				,   lowerCamelCase			:    Optional[Any]=3				,   lowerCamelCase			:    Optional[int]=10				,   lowerCamelCase			:    Optional[int]=[10, 20, 30, 40]				,   lowerCamelCase			:    Optional[Any]=[1, 1, 2, 1]				,   lowerCamelCase			:    Tuple=True				,   lowerCamelCase			:    Optional[Any]=True				,   lowerCamelCase			:    Optional[int]="relu"				,   lowerCamelCase			:    Tuple=3				,   lowerCamelCase			:    Optional[Any]=None				,   ):



   """simple docstring"""





   __A		:     int												=		parent
   __A		:     Union[str, Any]												=		batch_size
   __A		:     int												=		image_size
   __A		:     Union[str, Any]												=		num_channels
   __A		:     int												=		embeddings_size
   __A		:     Optional[Any]												=		hidden_sizes
   __A		:     List[Any]												=		depths
   __A		:     Optional[int]												=		is_training
   __A		:     Tuple												=		use_labels
   __A		:     str												=		hidden_act
   __A		:     Tuple												=		num_labels
   __A		:     Union[str, Any]												=		scope
   __A		:     Optional[Any]												=		len(snake_case__       )
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     str												=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

   __A		:     Dict												=		None
   if self.use_labels:
     __A		:     Tuple												=		ids_tensor([self.batch_size]				,   self.num_labels       )

   __A		:     str												=		self.get_config()
   return config, pixel_values, labels
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   return RegNetConfig(
       num_channels=self.num_channels				,   embeddings_size=self.embeddings_size				,   hidden_sizes=self.hidden_sizes				,   depths=self.depths				,   hidden_act=self.hidden_act				,   num_labels=self.num_labels				,   )
 def 		lowercase_(   self			:    List[str]				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    Optional[Any]				,   lowerCamelCase			:    Any       ):



   """simple docstring"""





   __A		:     List[str]												=		TFRegNetModel(config=snake_case__       )
   __A		:     Union[str, Any]												=		model(snake_case__				,   training=snake_case__       )
   # 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 		lowercase_(   self			:    List[str]				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    Any       ):



   """simple docstring"""





   __A		:     str												=		self.num_labels
   __A		:     str												=		TFRegNetForImageClassification(snake_case__       )
   __A		:     List[str]												=		model(snake_case__				,   labels=snake_case__				,   training=snake_case__       )
   self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.num_labels)       )






 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





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







@require_tf
class  __A				( SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						unittest.TestCase			):
 lowerCamelCase				       =(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
 lowerCamelCase				       =(
     {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification}
     if is_tf_available()
     else {}
 )

 lowerCamelCase				       =False
 lowerCamelCase				       =False
 lowerCamelCase				       =False
 lowerCamelCase				       =False
 lowerCamelCase				       =False
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   __A		:     Tuple												=		TFRegNetModelTester(self       )
   __A		:     List[Any]												=		ConfigTester(self				,   config_class=snake_case__				,   has_text_modality=snake_case__       )
 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





   return
 @unittest.skip(reason="""RegNet does not use inputs_embeds"""       )
 def 		lowercase_(   self			:    Any       ):



   """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 		lowercase_(   self			:    Optional[Any]       ):



   """simple docstring"""





   super().test_keras_fit()
 @unittest.skip(reason="""RegNet does not support input and output embeddings"""       )
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   pass
 def 		lowercase_(   self			:    Optional[Any]       ):



   """simple docstring"""





   __A		:     List[Any]												=		self.model_tester.prepare_config_and_inputs_for_common()

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

     __A		:     Tuple												=		["pixel_values"]
     self.assertListEqual(arg_names[:1]				,   snake_case__       )
 def 		lowercase_(   self			:    Optional[Any]       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*snake_case__       )
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   def check_hidden_states_output(lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Dict				,   lowerCamelCase			:    Optional[Any]       ):
     __A		:     Optional[Any]												=		model_class(snake_case__       )
     __A		:     str												=		model(**self._prepare_for_class(snake_case__				,   snake_case__       )				,   training=snake_case__       )

     __A		:     Optional[int]												=		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

     __A		:     Any												=		self.model_tester.num_stages
     self.assertEqual(len(snake_case__       )				,   expected_num_stages + 1       )

     # RegNet'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 // 2, self.model_tester.image_size // 2]				,   )

   __A		:     Any												=		self.model_tester.prepare_config_and_inputs_for_common()
   __A		:     int												=		["basic", "bottleneck"]
   for model_class in self.all_model_classes:
     for layer_type in layers_type:
       __A		:     int												=		layer_type
       __A		:     List[Any]												=		True
       check_hidden_states_output(snake_case__				,   snake_case__				,   snake_case__       )

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

       check_hidden_states_output(snake_case__				,   snake_case__				,   snake_case__       )
 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





   __A		:     List[Any]												=		self.model_tester.prepare_config_and_inputs_for_common()

   def check_equivalence(lowerCamelCase			:    str				,   lowerCamelCase			:    int				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    str={}       ):
     __A		:     int												=		model(snake_case__				,   return_dict=snake_case__				,   **snake_case__       )
     __A		:     List[str]												=		model(snake_case__				,   return_dict=snake_case__				,   **snake_case__       ).to_tuple()

     def recursive_check(lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Optional[int]       ):
       if isinstance(snake_case__				,   (List, Tuple)       ):
         for tuple_iterable_value, dict_iterable_value in zip(snake_case__				,   snake_case__       ):
           recursive_check(snake_case__				,   snake_case__       )
       elif tuple_object is None:
         return
       else:
         self.assertTrue(
             all(tf.equal(snake_case__				,   snake_case__       )       )				,   msg=(
                 """Tuple and dict output are not equal. Difference:"""
                 f" {tf.math.reduce_max(tf.abs(tuple_object - dict_object       )       )}"
             )				,   )

       recursive_check(snake_case__				,   snake_case__       )

   for model_class in self.all_model_classes:
     __A		:     int												=		model_class(snake_case__       )

     __A		:     str												=		self._prepare_for_class(snake_case__				,   snake_case__       )
     __A		:     List[Any]												=		self._prepare_for_class(snake_case__				,   snake_case__       )
     check_equivalence(snake_case__				,   snake_case__				,   snake_case__       )

     __A		:     Optional[Any]												=		self._prepare_for_class(snake_case__				,   snake_case__				,   return_labels=snake_case__       )
     __A		:     Any												=		self._prepare_for_class(snake_case__				,   snake_case__				,   return_labels=snake_case__       )
     check_equivalence(snake_case__				,   snake_case__				,   snake_case__       )

     __A		:     Union[str, Any]												=		self._prepare_for_class(snake_case__				,   snake_case__       )
     __A		:     List[str]												=		self._prepare_for_class(snake_case__				,   snake_case__       )
     check_equivalence(snake_case__				,   snake_case__				,   snake_case__				,   {"""output_hidden_states""": True}       )

     __A		:     int												=		self._prepare_for_class(snake_case__				,   snake_case__				,   return_labels=snake_case__       )
     __A		:     Dict												=		self._prepare_for_class(snake_case__				,   snake_case__				,   return_labels=snake_case__       )
     check_equivalence(snake_case__				,   snake_case__				,   snake_case__				,   {"""output_hidden_states""": True}       )
 def 		lowercase_(   self			:    Optional[int]       ):



   """simple docstring"""





   __A		:     List[str]												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*snake_case__       )






 @slow
 def 		lowercase_(   self			:    Union[str, Any]       ):



   """simple docstring"""





   for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __A		:     Dict												=		TFRegNetModel.from_pretrained(snake_case__       )
     self.assertIsNotNone(snake_case__       )







def        A_     (						):





  """simple docstring"""

  __A		:     Union[str, Any]												=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
  return image







@require_tf
@require_vision
class  __A				( unittest.TestCase			):
 @cached_property
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   return (
       AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
       if is_vision_available()
       else None
   )






 @slow
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   __A		:     List[Any]												=		TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

   __A		:     List[str]												=		self.default_image_processor
   __A		:     Any												=		prepare_img()
   __A		:     List[str]												=		image_processor(images=snake_case__				,   return_tensors="""tf"""       )

   # forward pass
   __A		:     Dict												=		model(**snake_case__				,   training=snake_case__       )

   # verify the logits
   __A		:     Tuple												=		tf.TensorShape((1, 10_00)       )
   self.assertEqual(outputs.logits.shape				,   snake_case__       )

   __A		:     str												=		tf.constant([-0.4_180, -1.5_051, -3.4_836]       )

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





'''simple docstring'''
import argparse

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

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)







def        A_     (						__SCREAMING_SNAKE_CASE						:  List[Any]			,     __SCREAMING_SNAKE_CASE						:  Tuple )				->       Any:





  """simple docstring"""

  __A		:     str												=		XCLIPTextConfig()

  # derive patch size from model name
  __A		:     List[str]												=		model_name.find("""patch""" )
  __A		:     int												=		int(model_name[start_idx + len("""patch""" ) : start_idx + len("""patch""" ) + 2] )
  __A		:     Union[str, Any]												=		XCLIPVisionConfig(patch_size=__SCREAMING_SNAKE_CASE			,     num_frames=__SCREAMING_SNAKE_CASE )

  if "large" in model_name:
    __A		:     Optional[int]												=		768
    __A		:     Tuple												=		3072
    __A		:     Tuple												=		12

    __A		:     int												=		1024
    __A		:     Optional[int]												=		4096
    __A		:     Union[str, Any]												=		16
    __A		:     Union[str, Any]												=		24
    __A		:     Dict												=		768
    __A		:     str												=		3072

  if model_name == "xclip-large-patch14-16-frames":
    __A		:     Optional[Any]												=		336

  __A		:     int												=		XCLIPConfig.from_text_vision_configs(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  if "large" in model_name:
    __A		:     int												=		768

  return config







def        A_     (						__SCREAMING_SNAKE_CASE						:  Dict )				->       Any:





  """simple docstring"""

  if name == "token_embedding.weight":
    __A		:     Optional[int]												=		name.replace("""token_embedding.weight"""			,     """text_model.embeddings.token_embedding.weight""" )
  if name == "positional_embedding":
    __A		:     Optional[int]												=		name.replace("""positional_embedding"""			,     """text_model.embeddings.position_embedding.weight""" )
  if "ln_1" in name:
    __A		:     Optional[Any]												=		name.replace("""ln_1"""			,     """layer_norm1""" )
  if "ln_2" in name:
    __A		:     Union[str, Any]												=		name.replace("""ln_2"""			,     """layer_norm2""" )
  if "c_fc" in name:
    __A		:     int												=		name.replace("""c_fc"""			,     """fc1""" )
  if "c_proj" in name:
    __A		:     Any												=		name.replace("""c_proj"""			,     """fc2""" )
  if name.startswith("""transformer.resblocks""" ):
    __A		:     List[str]												=		name.replace("""transformer.resblocks"""			,     """text_model.encoder.layers""" )
  if "attn.out_proj" in name and "message" not in name:
    __A		:     List[str]												=		name.replace("""attn.out_proj"""			,     """self_attn.out_proj""" )
  if "ln_final" in name:
    __A		:     int												=		name.replace("""ln_final"""			,     """text_model.final_layer_norm""" )
  # visual encoder
  if name == "visual.class_embedding":
    __A		:     Any												=		name.replace("""visual.class_embedding"""			,     """vision_model.embeddings.class_embedding""" )
  if name == "visual.positional_embedding":
    __A		:     Any												=		name.replace("""visual.positional_embedding"""			,     """vision_model.embeddings.position_embedding.weight""" )
  if name.startswith("""visual.transformer.resblocks""" ):
    __A		:     List[Any]												=		name.replace("""visual.transformer.resblocks"""			,     """vision_model.encoder.layers""" )
  if "visual.conv1" in name:
    __A		:     Union[str, Any]												=		name.replace("""visual.conv1"""			,     """vision_model.embeddings.patch_embedding""" )
  if "visual.ln_pre" in name:
    __A		:     int												=		name.replace("""visual.ln_pre"""			,     """vision_model.pre_layernorm""" )
  if "visual.ln_post" in name:
    __A		:     Dict												=		name.replace("""visual.ln_post"""			,     """vision_model.post_layernorm""" )
  if "visual.proj" in name:
    __A		:     Optional[int]												=		name.replace("""visual.proj"""			,     """visual_projection.weight""" )
  if "text_projection" in name:
    __A		:     Dict												=		name.replace("""text_projection"""			,     """text_projection.weight""" )
  # things on top
  if "prompts_visual_proj" in name:
    __A		:     Tuple												=		name.replace("""prompts_visual_proj"""			,     """prompts_visual_projection""" )
  if "prompts_visual_ln" in name:
    __A		:     Union[str, Any]												=		name.replace("""prompts_visual_ln"""			,     """prompts_visual_layernorm""" )
  # mit
  if name == "mit.positional_embedding":
    __A		:     List[str]												=		name.replace("""positional"""			,     """position""" )
  if name.startswith("""mit.resblocks""" ):
    __A		:     Tuple												=		name.replace("""mit.resblocks"""			,     """mit.encoder.layers""" )
  # prompts generator
  if name.startswith("""prompts_generator.norm""" ):
    __A		:     Optional[int]												=		name.replace("""prompts_generator.norm"""			,     """prompts_generator.layernorm""" )

  return name







def        A_     (						__SCREAMING_SNAKE_CASE						:  List[Any]			,     __SCREAMING_SNAKE_CASE						:  Tuple )				->       Optional[Any]:





  """simple docstring"""

  for key in orig_state_dict.copy().keys():
    __A		:     int												=		orig_state_dict.pop(__SCREAMING_SNAKE_CASE )

    if "attn.in_proj" in key:
      __A		:     Dict												=		key.split(""".""" )
      if key.startswith("""visual""" ):
        __A		:     List[str]												=		key_split[3]
        __A		:     List[str]												=		config.vision_config.hidden_size
        if "message_attn" in key:
          if "weight" in key:
            __A		:     str												=		val[
                :dim, :
            ]
            __A		:     str												=		val[
                dim : dim * 2, :
            ]
            __A		:     int												=		val[
                -dim:, :
            ]
          else:
            __A		:     int												=		val[
                :dim
            ]
            __A		:     Optional[Any]												=		val[
                dim : dim * 2
            ]
            __A		:     Any												=		val[
                -dim:
            ]
        else:
          if "weight" in key:
            __A		:     Union[str, Any]												=		val[
                :dim, :
            ]
            __A		:     Optional[Any]												=		val[
                dim : dim * 2, :
            ]
            __A		:     str												=		val[
                -dim:, :
            ]
          else:
            __A		:     Dict												=		val[:dim]
            __A		:     Union[str, Any]												=		val[
                dim : dim * 2
            ]
            __A		:     List[str]												=		val[-dim:]
      elif key.startswith("""mit""" ):
        __A		:     Union[str, Any]												=		key_split[2]
        __A		:     List[Any]												=		config.vision_config.mit_hidden_size
        if "weight" in key:
          __A		:     Dict												=		val[:dim, :]
          __A		:     Any												=		val[dim : dim * 2, :]
          __A		:     int												=		val[-dim:, :]
        else:
          __A		:     Any												=		val[:dim]
          __A		:     Union[str, Any]												=		val[dim : dim * 2]
          __A		:     Union[str, Any]												=		val[-dim:]
      else:
        __A		:     int												=		key_split[2]
        __A		:     Dict												=		config.text_config.hidden_size
        if "weight" in key:
          __A		:     int												=		val[:dim, :]
          __A		:     List[Any]												=		val[
              dim : dim * 2, :
          ]
          __A		:     Tuple												=		val[-dim:, :]
        else:
          __A		:     str												=		val[:dim]
          __A		:     Dict												=		val[
              dim : dim * 2
          ]
          __A		:     Optional[Any]												=		val[-dim:]
    else:
      __A		:     Union[str, Any]												=		rename_key(__SCREAMING_SNAKE_CASE )
      if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
        __A		:     Union[str, Any]												=		val.T
      __A		:     List[Any]												=		val

  return orig_state_dict







def        A_     (						__SCREAMING_SNAKE_CASE						:  Any )				->       List[str]:





  """simple docstring"""

  if num_frames == 8:
    __A		:     str												=		"""eating_spaghetti_8_frames.npy"""
  elif num_frames == 16:
    __A		:     Optional[int]												=		"""eating_spaghetti.npy"""
  elif num_frames == 32:
    __A		:     Dict												=		"""eating_spaghetti_32_frames.npy"""
  __A		:     int												=		hf_hub_download(
      repo_id="""hf-internal-testing/spaghetti-video"""			,     filename=__SCREAMING_SNAKE_CASE			,     repo_type="""dataset"""			,     )
  __A		:     List[Any]												=		np.load(__SCREAMING_SNAKE_CASE )
  return list(__SCREAMING_SNAKE_CASE )







def        A_     (						__SCREAMING_SNAKE_CASE						:  str			,     __SCREAMING_SNAKE_CASE						:  Dict=None			,     __SCREAMING_SNAKE_CASE						:  List[Any]=False )				->       Optional[Any]:





  """simple docstring"""

  __A		:     Optional[int]												=		{
      # fully supervised kinetics-400 checkpoints
      """xclip-base-patch32""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth""",
      """xclip-base-patch32-16-frames""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"""
      ),
      """xclip-base-patch16""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth""",
      """xclip-base-patch16-16-frames""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"""
      ),
      """xclip-large-patch14""": """https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb""",
      """xclip-large-patch14-16-frames""": """https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f""",
      # fully supervised kinetics-600 checkpoints
      """xclip-base-patch16-kinetics-600""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"""
      ),
      """xclip-base-patch16-kinetics-600-16-frames""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"""
      ),
      """xclip-large-patch14-kinetics-600""": """https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be""",
      # few shot
      """xclip-base-patch16-hmdb-2-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"""
      ),
      """xclip-base-patch16-hmdb-4-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"""
      ),
      """xclip-base-patch16-hmdb-8-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"""
      ),
      """xclip-base-patch16-hmdb-16-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"""
      ),
      """xclip-base-patch16-ucf-2-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"""
      ),
      """xclip-base-patch16-ucf-4-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"""
      ),
      """xclip-base-patch16-ucf-8-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"""
      ),
      """xclip-base-patch16-ucf-16-shot""": (
          """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"""
      ),
      # zero shot
      """xclip-base-patch16-zero-shot""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth""",
  }

  __A		:     Tuple												=		model_to_url[model_name]
  __A		:     Optional[int]												=		8
  if "16-frames" in model_name:
    __A		:     Optional[Any]												=		16
  elif "shot" in model_name:
    __A		:     int												=		32

  __A		:     Any												=		get_xclip_config(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )
  __A		:     Any												=		XCLIPModel(__SCREAMING_SNAKE_CASE )
  model.eval()

  if "drive" in checkpoint_url:
    __A		:     Optional[int]												=		"""pytorch_model.bin"""
    gdown.cached_download(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     quiet=__SCREAMING_SNAKE_CASE )
    __A		:     int												=		torch.load(__SCREAMING_SNAKE_CASE			,     map_location="""cpu""" )["""model"""]
  else:
    __A		:     str												=		torch.hub.load_state_dict_from_url(__SCREAMING_SNAKE_CASE )["""model"""]

  __A		:     int												=		convert_state_dict(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  __A		:     Optional[int]												=		XCLIPModel(__SCREAMING_SNAKE_CASE )
  __A							,					__A		:     Any												=		model.load_state_dict(__SCREAMING_SNAKE_CASE			,     strict=__SCREAMING_SNAKE_CASE )
  assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
  model.eval()

  __A		:     List[Any]												=		336 if model_name == """xclip-large-patch14-16-frames""" else 224
  __A		:     Any												=		VideoMAEImageProcessor(size=__SCREAMING_SNAKE_CASE )
  __A		:     Any												=		CLIPTokenizer.from_pretrained("""openai/clip-vit-base-patch32""" )
  __A		:     List[Any]												=		CLIPTokenizerFast.from_pretrained("""openai/clip-vit-base-patch32""" )
  __A		:     int												=		XCLIPProcessor(image_processor=__SCREAMING_SNAKE_CASE			,     tokenizer=__SCREAMING_SNAKE_CASE )

  __A		:     Optional[int]												=		prepare_video(__SCREAMING_SNAKE_CASE )
  __A		:     Union[str, Any]												=		processor(
      text=["""playing sports""", """eating spaghetti""", """go shopping"""]			,     videos=__SCREAMING_SNAKE_CASE			,     return_tensors="""pt"""			,     padding=__SCREAMING_SNAKE_CASE )

  print("""Shape of pixel values:"""			,     inputs.pixel_values.shape )

  with torch.no_grad():
    __A		:     str												=		model(**__SCREAMING_SNAKE_CASE )

  # Verify outputs
  __A		:     Union[str, Any]												=		outputs.logits_per_video
  __A		:     Optional[int]												=		logits_per_video.softmax(dim=1 )
  print("""Probs:"""			,     __SCREAMING_SNAKE_CASE )
  # kinetics-400
  if model_name == "xclip-base-patch32":
    __A		:     Optional[Any]												=		torch.tensor([[0.0_019, 0.9_951, 0.0_030]] )
  elif model_name == "xclip-base-patch32-16-frames":
    __A		:     Dict												=		torch.tensor([[7.0_999e-04, 9.9_883e-01, 4.5_580e-04]] )
  elif model_name == "xclip-base-patch16":
    __A		:     Optional[int]												=		torch.tensor([[0.0_083, 0.9_681, 0.0_236]] )
  elif model_name == "xclip-base-patch16-16-frames":
    __A		:     Optional[Any]												=		torch.tensor([[7.6_937e-04, 9.9_728e-01, 1.9_473e-03]] )
  elif model_name == "xclip-large-patch14":
    __A		:     List[Any]												=		torch.tensor([[0.0_062, 0.9_864, 0.0_075]] )
  elif model_name == "xclip-large-patch14-16-frames":
    __A		:     Dict												=		torch.tensor([[3.3_877e-04, 9.9_937e-01, 2.8_888e-04]] )
  # kinetics-600
  elif model_name == "xclip-base-patch16-kinetics-600":
    __A		:     List[Any]												=		torch.tensor([[0.0_555, 0.8_914, 0.0_531]] )
  elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
    __A		:     Optional[int]												=		torch.tensor([[3.8_554e-04, 9.9_929e-01, 3.2_754e-04]] )
  elif model_name == "xclip-large-patch14-kinetics-600":
    __A		:     Optional[Any]												=		torch.tensor([[0.0_036, 0.9_920, 0.0_045]] )
  # few shot
  elif model_name == "xclip-base-patch16-hmdb-2-shot":
    __A		:     Optional[Any]												=		torch.tensor([[7.1_890e-06, 9.9_994e-01, 5.6_559e-05]] )
  elif model_name == "xclip-base-patch16-hmdb-4-shot":
    __A		:     Optional[int]												=		torch.tensor([[1.0_320e-05, 9.9_993e-01, 6.2_435e-05]] )
  elif model_name == "xclip-base-patch16-hmdb-8-shot":
    __A		:     List[str]												=		torch.tensor([[4.1_377e-06, 9.9_990e-01, 9.8_386e-05]] )
  elif model_name == "xclip-base-patch16-hmdb-16-shot":
    __A		:     List[str]												=		torch.tensor([[4.1_347e-05, 9.9_962e-01, 3.3_411e-04]] )
  elif model_name == "xclip-base-patch16-ucf-2-shot":
    __A		:     Any												=		torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]] )
  elif model_name == "xclip-base-patch16-ucf-4-shot":
    __A		:     Dict												=		torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]] )
  elif model_name == "xclip-base-patch16-ucf-8-shot":
    __A		:     int												=		torch.tensor([[0.0_027, 0.9_904, 0.0_070]] )
  elif model_name == "xclip-base-patch16-ucf-16-shot":
    __A		:     List[Any]												=		torch.tensor([[9.8_219e-04, 9.9_593e-01, 3.0_863e-03]] )
  # zero shot
  elif model_name == "xclip-base-patch16-zero-shot":
    __A		:     Any												=		torch.tensor([[3.5_082e-04, 9.9_785e-01, 1.7_966e-03]] )
  else:
    raise ValueError(F"Model name {model_name} not supported" )
  assert torch.allclose(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     atol=1e-3 )
  print("""Looks ok!""" )

  if pytorch_dump_folder_path is not None:
    print(F"Saving model {model_name} to {pytorch_dump_folder_path}" )
    model.save_pretrained(__SCREAMING_SNAKE_CASE )

  if push_to_hub:
    print("""Pushing model, processor and slow tokenizer files to the hub...""" )
    model.push_to_hub(__SCREAMING_SNAKE_CASE			,     organization="""nielsr""" )
    processor.push_to_hub(__SCREAMING_SNAKE_CASE			,     organization="""nielsr""" )
    slow_tokenizer.push_to_hub(__SCREAMING_SNAKE_CASE			,     organization="""nielsr""" )


if __name__ == "__main__":
     A__   :		Optional[int] 		=argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--model_name',
         default='xclip-base-patch32',
         type=str,
         help='Name of the model.',
     )
     parser.add_argument(
         '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
     )
     parser.add_argument(
         '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
     )

     A__   :		List[str] 		=parser.parse_args()
     convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



