
'''simple docstring'''
import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


A__   :		str 		=logging.get_logger(__name__)

A__   :		Union[str, Any] 		=OrderedDict(
    [
        ('audio-spectrogram-transformer', 'ASTFeatureExtractor'),
        ('beit', 'BeitFeatureExtractor'),
        ('chinese_clip', 'ChineseCLIPFeatureExtractor'),
        ('clap', 'ClapFeatureExtractor'),
        ('clip', 'CLIPFeatureExtractor'),
        ('clipseg', 'ViTFeatureExtractor'),
        ('conditional_detr', 'ConditionalDetrFeatureExtractor'),
        ('convnext', 'ConvNextFeatureExtractor'),
        ('cvt', 'ConvNextFeatureExtractor'),
        ('data2vec-audio', 'Wav2Vec2FeatureExtractor'),
        ('data2vec-vision', 'BeitFeatureExtractor'),
        ('deformable_detr', 'DeformableDetrFeatureExtractor'),
        ('deit', 'DeiTFeatureExtractor'),
        ('detr', 'DetrFeatureExtractor'),
        ('dinat', 'ViTFeatureExtractor'),
        ('donut-swin', 'DonutFeatureExtractor'),
        ('dpt', 'DPTFeatureExtractor'),
        ('encodec', 'EncodecFeatureExtractor'),
        ('flava', 'FlavaFeatureExtractor'),
        ('glpn', 'GLPNFeatureExtractor'),
        ('groupvit', 'CLIPFeatureExtractor'),
        ('hubert', 'Wav2Vec2FeatureExtractor'),
        ('imagegpt', 'ImageGPTFeatureExtractor'),
        ('layoutlmv2', 'LayoutLMv2FeatureExtractor'),
        ('layoutlmv3', 'LayoutLMv3FeatureExtractor'),
        ('levit', 'LevitFeatureExtractor'),
        ('maskformer', 'MaskFormerFeatureExtractor'),
        ('mctct', 'MCTCTFeatureExtractor'),
        ('mobilenet_v1', 'MobileNetV1FeatureExtractor'),
        ('mobilenet_v2', 'MobileNetV2FeatureExtractor'),
        ('mobilevit', 'MobileViTFeatureExtractor'),
        ('nat', 'ViTFeatureExtractor'),
        ('owlvit', 'OwlViTFeatureExtractor'),
        ('perceiver', 'PerceiverFeatureExtractor'),
        ('poolformer', 'PoolFormerFeatureExtractor'),
        ('regnet', 'ConvNextFeatureExtractor'),
        ('resnet', 'ConvNextFeatureExtractor'),
        ('segformer', 'SegformerFeatureExtractor'),
        ('sew', 'Wav2Vec2FeatureExtractor'),
        ('sew-d', 'Wav2Vec2FeatureExtractor'),
        ('speech_to_text', 'Speech2TextFeatureExtractor'),
        ('speecht5', 'SpeechT5FeatureExtractor'),
        ('swiftformer', 'ViTFeatureExtractor'),
        ('swin', 'ViTFeatureExtractor'),
        ('swinv2', 'ViTFeatureExtractor'),
        ('table-transformer', 'DetrFeatureExtractor'),
        ('timesformer', 'VideoMAEFeatureExtractor'),
        ('tvlt', 'TvltFeatureExtractor'),
        ('unispeech', 'Wav2Vec2FeatureExtractor'),
        ('unispeech-sat', 'Wav2Vec2FeatureExtractor'),
        ('van', 'ConvNextFeatureExtractor'),
        ('videomae', 'VideoMAEFeatureExtractor'),
        ('vilt', 'ViltFeatureExtractor'),
        ('vit', 'ViTFeatureExtractor'),
        ('vit_mae', 'ViTFeatureExtractor'),
        ('vit_msn', 'ViTFeatureExtractor'),
        ('wav2vec2', 'Wav2Vec2FeatureExtractor'),
        ('wav2vec2-conformer', 'Wav2Vec2FeatureExtractor'),
        ('wavlm', 'Wav2Vec2FeatureExtractor'),
        ('whisper', 'WhisperFeatureExtractor'),
        ('xclip', 'CLIPFeatureExtractor'),
        ('yolos', 'YolosFeatureExtractor'),
    ]
)

A__   :		List[Any] 		=_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)







def        A_     (						__SCREAMING_SNAKE_CASE						:  str )				->       int:





  """simple docstring"""

  for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
    if class_name in extractors:
      __A		:     List[str]												=		model_type_to_module_name(__SCREAMING_SNAKE_CASE )

      __A		:     Tuple												=		importlib.import_module(F".{module_name}"			,     """transformers.models""" )
      try:
        return getattr(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )
      except AttributeError:
        continue

  for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
    if getattr(__SCREAMING_SNAKE_CASE			,     """__name__"""			,     __SCREAMING_SNAKE_CASE ) == class_name:
      return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
  __A		:     Any												=		importlib.import_module("""transformers""" )
  if hasattr(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE ):
    return getattr(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  return None







def        A_     (						__SCREAMING_SNAKE_CASE						:  Union[str, os.PathLike]			,     __SCREAMING_SNAKE_CASE						:  Optional[Union[str, os.PathLike]] = None			,     __SCREAMING_SNAKE_CASE						:  bool = False			,     __SCREAMING_SNAKE_CASE						:  bool = False			,     __SCREAMING_SNAKE_CASE						:  Optional[Dict[str, str]] = None			,     __SCREAMING_SNAKE_CASE						:  Optional[Union[bool, str]] = None			,     __SCREAMING_SNAKE_CASE						:  Optional[str] = None			,     __SCREAMING_SNAKE_CASE						:  bool = False			,     **__SCREAMING_SNAKE_CASE						:  List[Any]			,     )				->       int:





  """simple docstring"""

  __A		:     Any												=		get_file_from_repo(
      __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     cache_dir=__SCREAMING_SNAKE_CASE			,     force_download=__SCREAMING_SNAKE_CASE			,     resume_download=__SCREAMING_SNAKE_CASE			,     proxies=__SCREAMING_SNAKE_CASE			,     use_auth_token=__SCREAMING_SNAKE_CASE			,     revision=__SCREAMING_SNAKE_CASE			,     local_files_only=__SCREAMING_SNAKE_CASE			,     )
  if resolved_config_file is None:
    logger.info(
        """Could not locate the feature extractor configuration file, will try to use the model config instead.""" )
    return {}

  with open(__SCREAMING_SNAKE_CASE			,     encoding="""utf-8""" ) as reader:
    return json.load(__SCREAMING_SNAKE_CASE )







class  __A				:
 def __init__(   self			:    Union[str, Any]       ):



   """simple docstring"""





   raise EnvironmentError(
       """AutoFeatureExtractor is designed to be instantiated """
       """using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method."""       )
 @classmethod
 @replace_list_option_in_docstrings(lowerCamelCase       )
 def 		lowercase_(   cls			:    Dict				,   lowerCamelCase			:    Tuple				,   **lowerCamelCase			:    str       ):



   """simple docstring"""





   __A		:     int												=		kwargs.pop("""config"""				,   lowerCamelCase       )
   __A		:     Any												=		kwargs.pop("""trust_remote_code"""				,   lowerCamelCase       )
   __A		:     Dict												=		True

   __A							,					__A		:     str												=		FeatureExtractionMixin.get_feature_extractor_dict(lowerCamelCase				,   **lowerCamelCase       )
   __A		:     Dict												=		config_dict.get("""feature_extractor_type"""				,   lowerCamelCase       )
   __A		:     List[Any]												=		None
   if "AutoFeatureExtractor" in config_dict.get("""auto_map"""				,   {}       ):
     __A		:     Optional[Any]												=		config_dict["""auto_map"""]["""AutoFeatureExtractor"""]

   # If we don't find the feature extractor class in the feature extractor config, let's try the model config.
   if feature_extractor_class is None and feature_extractor_auto_map is None:
     if not isinstance(lowerCamelCase				,   lowerCamelCase       ):
       __A		:     Union[str, Any]												=		AutoConfig.from_pretrained(lowerCamelCase				,   **lowerCamelCase       )
     # It could be in `config.feature_extractor_type``
     __A		:     str												=		getattr(lowerCamelCase				,   """feature_extractor_type"""				,   lowerCamelCase       )
     if hasattr(lowerCamelCase				,   """auto_map"""       ) and "AutoFeatureExtractor" in config.auto_map:
       __A		:     Optional[Any]												=		config.auto_map["""AutoFeatureExtractor"""]

   if feature_extractor_class is not None:
     __A		:     Tuple												=		feature_extractor_class_from_name(lowerCamelCase       )

   __A		:     str												=		feature_extractor_auto_map is not None
   __A		:     Tuple												=		feature_extractor_class is not None or type(lowerCamelCase       ) in FEATURE_EXTRACTOR_MAPPING
   __A		:     List[Any]												=		resolve_trust_remote_code(
       lowerCamelCase				,   lowerCamelCase				,   lowerCamelCase				,   lowerCamelCase       )

   if has_remote_code and trust_remote_code:
     __A		:     Tuple												=		get_class_from_dynamic_module(
         lowerCamelCase				,   lowerCamelCase				,   **lowerCamelCase       )
     __A		:     Optional[int]												=		kwargs.pop("""code_revision"""				,   lowerCamelCase       )
     if os.path.isdir(lowerCamelCase       ):
       feature_extractor_class.register_for_auto_class()
     return feature_extractor_class.from_dict(lowerCamelCase				,   **lowerCamelCase       )
   elif feature_extractor_class is not None:
     return feature_extractor_class.from_dict(lowerCamelCase				,   **lowerCamelCase       )
   # Last try: we use the FEATURE_EXTRACTOR_MAPPING.
   elif type(lowerCamelCase       ) in FEATURE_EXTRACTOR_MAPPING:
     __A		:     int												=		FEATURE_EXTRACTOR_MAPPING[type(lowerCamelCase       )]
     return feature_extractor_class.from_dict(lowerCamelCase				,   **lowerCamelCase       )

   raise ValueError(
       f"Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a "
       f"`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following "
       f"`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()       )}"       )






 @staticmethod
 def 		lowercase_(   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Any       ):



   """simple docstring"""





   FEATURE_EXTRACTOR_MAPPING.register(lowerCamelCase				,   lowerCamelCase       )





'''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)



