



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCamelCase       	=						logging.get_logger(__name__)
class 				lowercase__       (   SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''pixel_values''']



       def __init__(							self      :  Union[str, Any]		,    _UpperCAmelCase      :  bool = True		,    _UpperCAmelCase      :  Optional[Dict[str, int]] = None		,    _UpperCAmelCase      :  PILImageResampling = PILImageResampling.BILINEAR		,    _UpperCAmelCase      :  bool = True		,    _UpperCAmelCase      :  Dict[str, int] = None		,    _UpperCAmelCase      :  bool = True		,    _UpperCAmelCase      :  Union[int, float] = 1 / 255		,    _UpperCAmelCase      :  bool = True		,    _UpperCAmelCase      :  Optional[Union[float, List[float]]] = None		,    _UpperCAmelCase      :  Optional[Union[float, List[float]]] = None		,    **_UpperCAmelCase      :  int		,    )			->						None:


             '''simple docstring'''




             super().__init__(**_UpperCAmelCase   )
             UpperCAmelCase_      			=							size if size is not None else {"shortest_edge": 256}
             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase		,    default_to_square=_UpperCAmelCase   )
             UpperCAmelCase_      			=							crop_size if crop_size is not None else {"height": 224, "width": 224}
             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase   )
             UpperCAmelCase_      			=							do_resize
             UpperCAmelCase_      			=							size
             UpperCAmelCase_      			=							resample
             UpperCAmelCase_      			=							do_center_crop
             UpperCAmelCase_      			=							crop_size
             UpperCAmelCase_      			=							do_rescale
             UpperCAmelCase_      			=							rescale_factor
             UpperCAmelCase_      			=							do_normalize
             UpperCAmelCase_      			=							image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
             UpperCAmelCase_      			=							image_std if image_std is not None else IMAGENET_STANDARD_STD



       def 					lowercase__    (							self      :  Optional[Any]		,    _UpperCAmelCase      :  np.ndarray		,    _UpperCAmelCase      :  Dict[str, int]		,    _UpperCAmelCase      :  PILImageResampling = PILImageResampling.BICUBIC		,    _UpperCAmelCase      :  Optional[Union[str, ChannelDimension]] = None		,    **_UpperCAmelCase      :  List[str]		,    )			->						np.ndarray:


             '''simple docstring'''




             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase		,    default_to_square=_UpperCAmelCase   )
             if "shortest_edge" not in size:
                   raise ValueError(F"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""   )
             UpperCAmelCase_      			=							get_resize_output_image_size(_UpperCAmelCase		,    size=size["shortest_edge"]		,    default_to_square=_UpperCAmelCase   )
             return resize(_UpperCAmelCase		,    size=_UpperCAmelCase		,    resample=_UpperCAmelCase		,    data_format=_UpperCAmelCase		,    **_UpperCAmelCase   )



       def 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  np.ndarray		,    _UpperCAmelCase      :  Dict[str, int]		,    _UpperCAmelCase      :  Optional[Union[str, ChannelDimension]] = None		,    **_UpperCAmelCase      :  Tuple		,    )			->						np.ndarray:


             '''simple docstring'''




             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase   )
             return center_crop(_UpperCAmelCase		,    size=(size["height"], size["width"])		,    data_format=_UpperCAmelCase		,    **_UpperCAmelCase   )



       def 					lowercase__    (							self      :  List[str]		,    _UpperCAmelCase      :  np.ndarray		,    _UpperCAmelCase      :  float		,    _UpperCAmelCase      :  Optional[Union[str, ChannelDimension]] = None		,    **_UpperCAmelCase      :  Optional[int]   )			->						np.ndarray:


             '''simple docstring'''




             return rescale(_UpperCAmelCase		,    scale=_UpperCAmelCase		,    data_format=_UpperCAmelCase		,    **_UpperCAmelCase   )



       def 					lowercase__    (							self      :  Optional[Any]		,    _UpperCAmelCase      :  np.ndarray		,    _UpperCAmelCase      :  Union[float, List[float]]		,    _UpperCAmelCase      :  Union[float, List[float]]		,    _UpperCAmelCase      :  Optional[Union[str, ChannelDimension]] = None		,    **_UpperCAmelCase      :  Tuple		,    )			->						np.ndarray:


             '''simple docstring'''




             return normalize(_UpperCAmelCase		,    mean=_UpperCAmelCase		,    std=_UpperCAmelCase		,    data_format=_UpperCAmelCase		,    **_UpperCAmelCase   )







       def 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  ImageInput		,    _UpperCAmelCase      :  Optional[bool] = None		,    _UpperCAmelCase      :  Dict[str, int] = None		,    _UpperCAmelCase      :  PILImageResampling = None		,    _UpperCAmelCase      :  bool = None		,    _UpperCAmelCase      :  Dict[str, int] = None		,    _UpperCAmelCase      :  Optional[bool] = None		,    _UpperCAmelCase      :  Optional[float] = None		,    _UpperCAmelCase      :  Optional[bool] = None		,    _UpperCAmelCase      :  Optional[Union[float, List[float]]] = None		,    _UpperCAmelCase      :  Optional[Union[float, List[float]]] = None		,    _UpperCAmelCase      :  Optional[Union[str, TensorType]] = None		,    _UpperCAmelCase      :  Union[str, ChannelDimension] = ChannelDimension.FIRST		,    **_UpperCAmelCase      :  Optional[int]		,    )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							do_resize if do_resize is not None else self.do_resize
             UpperCAmelCase_      			=							size if size is not None else self.size
             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase		,    default_to_square=_UpperCAmelCase   )
             UpperCAmelCase_      			=							resample if resample is not None else self.resample
             UpperCAmelCase_      			=							do_center_crop if do_center_crop is not None else self.do_center_crop
             UpperCAmelCase_      			=							crop_size if crop_size is not None else self.crop_size
             UpperCAmelCase_      			=							get_size_dict(_UpperCAmelCase   )
             UpperCAmelCase_      			=							do_rescale if do_rescale is not None else self.do_rescale
             UpperCAmelCase_      			=							rescale_factor if rescale_factor is not None else self.rescale_factor
             UpperCAmelCase_      			=							do_normalize if do_normalize is not None else self.do_normalize
             UpperCAmelCase_      			=							image_mean if image_mean is not None else self.image_mean
             UpperCAmelCase_      			=							image_std if image_std is not None else self.image_std

             UpperCAmelCase_      			=							make_list_of_images(_UpperCAmelCase   )

             if not valid_images(_UpperCAmelCase   ):
                   raise ValueError(
                       "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                       "torch.Tensor, tf.Tensor or jax.ndarray."   )

             if do_resize and size is None:
                   raise ValueError("Size must be specified if do_resize is True."   )

             if do_center_crop and crop_size is None:
                   raise ValueError("Crop size must be specified if do_center_crop is True."   )

             if do_rescale and rescale_factor is None:
                   raise ValueError("Rescale factor must be specified if do_rescale is True."   )

             if do_normalize and (image_mean is None or image_std is None):
                   raise ValueError("Image mean and std must be specified if do_normalize is True."   )

             # All transformations expect numpy arrays.
             UpperCAmelCase_      			=							[to_numpy_array(_UpperCAmelCase   ) for image in images]

             if do_resize:
                   UpperCAmelCase_      			=							[self.resize(image=_UpperCAmelCase		,    size=_UpperCAmelCase		,    resample=_UpperCAmelCase   ) for image in images]

             if do_center_crop:
                   UpperCAmelCase_      			=							[self.center_crop(image=_UpperCAmelCase		,    size=_UpperCAmelCase   ) for image in images]

             if do_rescale:
                   UpperCAmelCase_      			=							[self.rescale(image=_UpperCAmelCase		,    scale=_UpperCAmelCase   ) for image in images]

             if do_normalize:
                   UpperCAmelCase_      			=							[self.normalize(image=_UpperCAmelCase		,    mean=_UpperCAmelCase		,    std=_UpperCAmelCase   ) for image in images]

             UpperCAmelCase_      			=							[to_channel_dimension_format(_UpperCAmelCase		,    _UpperCAmelCase   ) for image in images]

             UpperCAmelCase_      			=							{"pixel_values": images}
             return BatchFeature(data=_UpperCAmelCase		,    tensor_type=_UpperCAmelCase   )









"""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__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      UpperCAmelCase_      			=							XCLIPTextConfig()

      # derive patch size from model name
      UpperCAmelCase_      			=							model_name.find("patch"				)
      UpperCAmelCase_      			=							int(model_name[start_idx + len("patch"				) : start_idx + len("patch"				) + 2]				)
      UpperCAmelCase_      			=							XCLIPVisionConfig(patch_size=lowerCAmelCase__     ,      num_frames=lowerCAmelCase__				)

      if "large" in model_name:
            UpperCAmelCase_      			=							768
            UpperCAmelCase_      			=							3072
            UpperCAmelCase_      			=							12

            UpperCAmelCase_      			=							1024
            UpperCAmelCase_      			=							4096
            UpperCAmelCase_      			=							16
            UpperCAmelCase_      			=							24
            UpperCAmelCase_      			=							768
            UpperCAmelCase_      			=							3072

      if model_name == "xclip-large-patch14-16-frames":
            UpperCAmelCase_      			=							336

      UpperCAmelCase_      			=							XCLIPConfig.from_text_vision_configs(lowerCAmelCase__     ,      lowerCAmelCase__				)

      if "large" in model_name:
            UpperCAmelCase_      			=							768

      return config
def        a__     (				lowerCAmelCase__				):
      # text encoder
      if name == "token_embedding.weight":
            UpperCAmelCase_      			=							name.replace("token_embedding.weight"     ,      "text_model.embeddings.token_embedding.weight"				)
      if name == "positional_embedding":
            UpperCAmelCase_      			=							name.replace("positional_embedding"     ,      "text_model.embeddings.position_embedding.weight"				)
      if "ln_1" in name:
            UpperCAmelCase_      			=							name.replace("ln_1"     ,      "layer_norm1"				)
      if "ln_2" in name:
            UpperCAmelCase_      			=							name.replace("ln_2"     ,      "layer_norm2"				)
      if "c_fc" in name:
            UpperCAmelCase_      			=							name.replace("c_fc"     ,      "fc1"				)
      if "c_proj" in name:
            UpperCAmelCase_      			=							name.replace("c_proj"     ,      "fc2"				)
      if name.startswith("transformer.resblocks"				):
            UpperCAmelCase_      			=							name.replace("transformer.resblocks"     ,      "text_model.encoder.layers"				)
      if "attn.out_proj" in name and "message" not in name:
            UpperCAmelCase_      			=							name.replace("attn.out_proj"     ,      "self_attn.out_proj"				)
      if "ln_final" in name:
            UpperCAmelCase_      			=							name.replace("ln_final"     ,      "text_model.final_layer_norm"				)
      # visual encoder
      if name == "visual.class_embedding":
            UpperCAmelCase_      			=							name.replace("visual.class_embedding"     ,      "vision_model.embeddings.class_embedding"				)
      if name == "visual.positional_embedding":
            UpperCAmelCase_      			=							name.replace("visual.positional_embedding"     ,      "vision_model.embeddings.position_embedding.weight"				)
      if name.startswith("visual.transformer.resblocks"				):
            UpperCAmelCase_      			=							name.replace("visual.transformer.resblocks"     ,      "vision_model.encoder.layers"				)
      if "visual.conv1" in name:
            UpperCAmelCase_      			=							name.replace("visual.conv1"     ,      "vision_model.embeddings.patch_embedding"				)
      if "visual.ln_pre" in name:
            UpperCAmelCase_      			=							name.replace("visual.ln_pre"     ,      "vision_model.pre_layernorm"				)
      if "visual.ln_post" in name:
            UpperCAmelCase_      			=							name.replace("visual.ln_post"     ,      "vision_model.post_layernorm"				)
      if "visual.proj" in name:
            UpperCAmelCase_      			=							name.replace("visual.proj"     ,      "visual_projection.weight"				)
      if "text_projection" in name:
            UpperCAmelCase_      			=							name.replace("text_projection"     ,      "text_projection.weight"				)
      # things on top
      if "prompts_visual_proj" in name:
            UpperCAmelCase_      			=							name.replace("prompts_visual_proj"     ,      "prompts_visual_projection"				)
      if "prompts_visual_ln" in name:
            UpperCAmelCase_      			=							name.replace("prompts_visual_ln"     ,      "prompts_visual_layernorm"				)
      # mit
      if name == "mit.positional_embedding":
            UpperCAmelCase_      			=							name.replace("positional"     ,      "position"				)
      if name.startswith("mit.resblocks"				):
            UpperCAmelCase_      			=							name.replace("mit.resblocks"     ,      "mit.encoder.layers"				)
      # prompts generator
      if name.startswith("prompts_generator.norm"				):
            UpperCAmelCase_      			=							name.replace("prompts_generator.norm"     ,      "prompts_generator.layernorm"				)

      return name
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      for key in orig_state_dict.copy().keys():
            UpperCAmelCase_      			=							orig_state_dict.pop(lowerCAmelCase__				)

            if "attn.in_proj" in key:
                  UpperCAmelCase_      			=							key.split("."				)
                  if key.startswith("visual"				):
                        UpperCAmelCase_      			=							key_split[3]
                        UpperCAmelCase_      			=							config.vision_config.hidden_size
                        if "message_attn" in key:
                              if "weight" in key:
                                    UpperCAmelCase_      			=							val[
                                        :dim, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:, :
                                    ]
                              else:
                                    UpperCAmelCase_      			=							val[
                                        :dim
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:
                                    ]
                        else:
                              if "weight" in key:
                                    UpperCAmelCase_      			=							val[
                                        :dim, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:, :
                                    ]
                              else:
                                    UpperCAmelCase_      			=							val[:dim]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2
                                    ]
                                    UpperCAmelCase_      			=							val[-dim:]
                  elif key.startswith("mit"				):
                        UpperCAmelCase_      			=							key_split[2]
                        UpperCAmelCase_      			=							config.vision_config.mit_hidden_size
                        if "weight" in key:
                              UpperCAmelCase_      			=							val[:dim, :]
                              UpperCAmelCase_      			=							val[dim : dim * 2, :]
                              UpperCAmelCase_      			=							val[-dim:, :]
                        else:
                              UpperCAmelCase_      			=							val[:dim]
                              UpperCAmelCase_      			=							val[dim : dim * 2]
                              UpperCAmelCase_      			=							val[-dim:]
                  else:
                        UpperCAmelCase_      			=							key_split[2]
                        UpperCAmelCase_      			=							config.text_config.hidden_size
                        if "weight" in key:
                              UpperCAmelCase_      			=							val[:dim, :]
                              UpperCAmelCase_      			=							val[
                                  dim : dim * 2, :
                              ]
                              UpperCAmelCase_      			=							val[-dim:, :]
                        else:
                              UpperCAmelCase_      			=							val[:dim]
                              UpperCAmelCase_      			=							val[
                                  dim : dim * 2
                              ]
                              UpperCAmelCase_      			=							val[-dim:]
            else:
                  UpperCAmelCase_      			=							rename_key(lowerCAmelCase__				)
                  if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
                        UpperCAmelCase_      			=							val.T
                  UpperCAmelCase_      			=							val

      return orig_state_dict
def        a__     (				lowerCAmelCase__				):
      if num_frames == 8:
            UpperCAmelCase_      			=							"eating_spaghetti_8_frames.npy"
      elif num_frames == 16:
            UpperCAmelCase_      			=							"eating_spaghetti.npy"
      elif num_frames == 32:
            UpperCAmelCase_      			=							"eating_spaghetti_32_frames.npy"
      UpperCAmelCase_      			=							hf_hub_download(
          repo_id="hf-internal-testing/spaghetti-video"     ,      filename=lowerCAmelCase__     ,      repo_type="dataset"     ,      )
      UpperCAmelCase_      			=							np.load(lowerCAmelCase__				)
      return list(lowerCAmelCase__				)
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__=None     ,      lowerCAmelCase__=False				):
      UpperCAmelCase_      			=							{
          # 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",
      }

      UpperCAmelCase_      			=							model_to_url[model_name]
      UpperCAmelCase_      			=							8
      if "16-frames" in model_name:
            UpperCAmelCase_      			=							16
      elif "shot" in model_name:
            UpperCAmelCase_      			=							32

      UpperCAmelCase_      			=							get_xclip_config(lowerCAmelCase__     ,      lowerCAmelCase__				)
      UpperCAmelCase_      			=							XCLIPModel(lowerCAmelCase__				)
      model.eval()

      if "drive" in checkpoint_url:
            UpperCAmelCase_      			=							"pytorch_model.bin"
            gdown.cached_download(lowerCAmelCase__     ,      lowerCAmelCase__     ,      quiet=lowerCAmelCase__				)
            UpperCAmelCase_      			=							torch.load(lowerCAmelCase__     ,      map_location="cpu"				)["model"]
      else:
            UpperCAmelCase_      			=							torch.hub.load_state_dict_from_url(lowerCAmelCase__				)["model"]

      UpperCAmelCase_      			=							convert_state_dict(lowerCAmelCase__     ,      lowerCAmelCase__				)

      UpperCAmelCase_      			=							XCLIPModel(lowerCAmelCase__				)
      UpperCAmelCase_			,   UpperCAmelCase_      			=							model.load_state_dict(lowerCAmelCase__     ,      strict=lowerCAmelCase__				)
      assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
      model.eval()

      UpperCAmelCase_      			=							336 if model_name == "xclip-large-patch14-16-frames" else 224
      UpperCAmelCase_      			=							VideoMAEImageProcessor(size=lowerCAmelCase__				)
      UpperCAmelCase_      			=							CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"				)
      UpperCAmelCase_      			=							CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32"				)
      UpperCAmelCase_      			=							XCLIPProcessor(image_processor=lowerCAmelCase__     ,      tokenizer=lowerCAmelCase__				)

      UpperCAmelCase_      			=							prepare_video(lowerCAmelCase__				)
      UpperCAmelCase_      			=							processor(
          text=["playing sports", "eating spaghetti", "go shopping"]     ,      videos=lowerCAmelCase__     ,      return_tensors="pt"     ,      padding=lowerCAmelCase__				)

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

      with torch.no_grad():
            UpperCAmelCase_      			=							model(**lowerCAmelCase__				)

      # Verify outputs
      UpperCAmelCase_      			=							outputs.logits_per_video
      UpperCAmelCase_      			=							logits_per_video.softmax(dim=1				)
      print("Probs:"     ,      lowerCAmelCase__				)
      # kinetics-400
      if model_name == "xclip-base-patch32":
            UpperCAmelCase_      			=							torch.tensor([[0.0019, 0.9951, 0.0030]]				)
      elif model_name == "xclip-base-patch32-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[7.0999e-04, 9.9883e-01, 4.5580e-04]]				)
      elif model_name == "xclip-base-patch16":
            UpperCAmelCase_      			=							torch.tensor([[0.0083, 0.9681, 0.0236]]				)
      elif model_name == "xclip-base-patch16-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[7.6937e-04, 9.9728e-01, 1.9473e-03]]				)
      elif model_name == "xclip-large-patch14":
            UpperCAmelCase_      			=							torch.tensor([[0.0062, 0.9864, 0.0075]]				)
      elif model_name == "xclip-large-patch14-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[3.3877e-04, 9.9937e-01, 2.8888e-04]]				)
      # kinetics-600
      elif model_name == "xclip-base-patch16-kinetics-600":
            UpperCAmelCase_      			=							torch.tensor([[0.0555, 0.8914, 0.0531]]				)
      elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[3.8554e-04, 9.9929e-01, 3.2754e-04]]				)
      elif model_name == "xclip-large-patch14-kinetics-600":
            UpperCAmelCase_      			=							torch.tensor([[0.0036, 0.9920, 0.0045]]				)
      # few shot
      elif model_name == "xclip-base-patch16-hmdb-2-shot":
            UpperCAmelCase_      			=							torch.tensor([[7.1890e-06, 9.9994e-01, 5.6559e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-4-shot":
            UpperCAmelCase_      			=							torch.tensor([[1.0320e-05, 9.9993e-01, 6.2435e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-8-shot":
            UpperCAmelCase_      			=							torch.tensor([[4.1377e-06, 9.9990e-01, 9.8386e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-16-shot":
            UpperCAmelCase_      			=							torch.tensor([[4.1347e-05, 9.9962e-01, 3.3411e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-2-shot":
            UpperCAmelCase_      			=							torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-4-shot":
            UpperCAmelCase_      			=							torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-8-shot":
            UpperCAmelCase_      			=							torch.tensor([[0.0027, 0.9904, 0.0070]]				)
      elif model_name == "xclip-base-patch16-ucf-16-shot":
            UpperCAmelCase_      			=							torch.tensor([[9.8219e-04, 9.9593e-01, 3.0863e-03]]				)
      # zero shot
      elif model_name == "xclip-base-patch16-zero-shot":
            UpperCAmelCase_      			=							torch.tensor([[3.5082e-04, 9.9785e-01, 1.7966e-03]]				)
      else:
            raise ValueError(f"""Model name {model_name} not supported"""				)
      assert torch.allclose(lowerCAmelCase__     ,      lowerCAmelCase__     ,      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(lowerCAmelCase__				)

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


if __name__ == "__main__":
  lowerCamelCase       	=						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."""
  )

  lowerCamelCase       	=						parser.parse_args()
  convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




