



'''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			) -> Optional[int]:
  __lowerCamelCase			:			Any       			=					XCLIPTextConfig()

  # derive patch size from model name
  __lowerCamelCase			:			Any       			=					model_name.find('patch'			)
  __lowerCamelCase			:			str       			=					int(model_name[start_idx + len('patch'			) : start_idx + len('patch'			) + 2]			)
  __lowerCamelCase			:			Tuple       			=					XCLIPVisionConfig(patch_size=_lowerCAmelCase			,num_frames=_lowerCAmelCase			)

  if "large" in model_name:
    __lowerCamelCase			:			Any       			=					768
    __lowerCamelCase			:			List[str]       			=					3072
    __lowerCamelCase			:			int       			=					12

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

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

  __lowerCamelCase			:			Tuple       			=					XCLIPConfig.from_text_vision_configs(_lowerCAmelCase			,_lowerCAmelCase			)

  if "large" in model_name:
    __lowerCamelCase			:			Dict       			=					768

  return config

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

  return name

def 			a_	(				_lowerCAmelCase			,_lowerCAmelCase			) -> Optional[Any]:
  for key in orig_state_dict.copy().keys():
    __lowerCamelCase			:			List[Any]       			=					orig_state_dict.pop(_lowerCAmelCase			)

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

  return orig_state_dict

def 			a_	(				_lowerCAmelCase			) -> Optional[int]:
  if num_frames == 8:
    __lowerCamelCase			:			Optional[int]       			=					'eating_spaghetti_8_frames.npy'
  elif num_frames == 16:
    __lowerCamelCase			:			List[Any]       			=					'eating_spaghetti.npy'
  elif num_frames == 32:
    __lowerCamelCase			:			Any       			=					'eating_spaghetti_32_frames.npy'
  __lowerCamelCase			:			int       			=					hf_hub_download(
      repo_id='hf-internal-testing/spaghetti-video'			,filename=_lowerCAmelCase			,repo_type='dataset'			,)
  __lowerCamelCase			:			str       			=					np.load(_lowerCAmelCase			)
  return list(_lowerCAmelCase			)

def 			a_	(				_lowerCAmelCase			,_lowerCAmelCase=None			,_lowerCAmelCase=False			) -> str:
  __lowerCamelCase			:			Dict       			=					{
      # 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',
  }

  __lowerCamelCase			:			List[str]       			=					model_to_url[model_name]
  __lowerCamelCase			:			Any       			=					8
  if "16-frames" in model_name:
    __lowerCamelCase			:			List[str]       			=					16
  elif "shot" in model_name:
    __lowerCamelCase			:			Dict       			=					32

  __lowerCamelCase			:			Tuple       			=					get_xclip_config(_lowerCAmelCase			,_lowerCAmelCase			)
  __lowerCamelCase			:			List[Any]       			=					XCLIPModel(_lowerCAmelCase			)
  model.eval()

  if "drive" in checkpoint_url:
    __lowerCamelCase			:			List[Any]       			=					'pytorch_model.bin'
    gdown.cached_download(_lowerCAmelCase			,_lowerCAmelCase			,quiet=_lowerCAmelCase			)
    __lowerCamelCase			:			Union[str, Any]       			=					torch.load(_lowerCAmelCase			,map_location='cpu'			)['model']
  else:
    __lowerCamelCase			:			Dict       			=					torch.hub.load_state_dict_from_url(_lowerCAmelCase			)['model']

  __lowerCamelCase			:			int       			=					convert_state_dict(_lowerCAmelCase			,_lowerCAmelCase			)

  __lowerCamelCase			:			int       			=					XCLIPModel(_lowerCAmelCase			)
  __lowerCamelCase			,__lowerCamelCase			:			Union[str, Any]       			=					model.load_state_dict(_lowerCAmelCase			,strict=_lowerCAmelCase			)
  assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
  model.eval()

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

  __lowerCamelCase			:			Dict       			=					prepare_video(_lowerCAmelCase			)
  __lowerCamelCase			:			Tuple       			=					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():
    __lowerCamelCase			:			Union[str, Any]       			=					model(**_lowerCAmelCase			)

  # Verify outputs
  __lowerCamelCase			:			List[Any]       			=					outputs.logits_per_video
  __lowerCamelCase			:			int       			=					logits_per_video.softmax(dim=1			)
  print('Probs:'			,_lowerCAmelCase			)
  # kinetics-400
  if model_name == "xclip-base-patch32":
    __lowerCamelCase			:			int       			=					torch.tensor([[0.0019, 0.9951, 0.0030]]			)
  elif model_name == "xclip-base-patch32-16-frames":
    __lowerCamelCase			:			Optional[Any]       			=					torch.tensor([[7.0999E-04, 9.9883E-01, 4.5580E-04]]			)
  elif model_name == "xclip-base-patch16":
    __lowerCamelCase			:			Union[str, Any]       			=					torch.tensor([[0.0083, 0.9681, 0.0236]]			)
  elif model_name == "xclip-base-patch16-16-frames":
    __lowerCamelCase			:			Optional[Any]       			=					torch.tensor([[7.6937E-04, 9.9728E-01, 1.9473E-03]]			)
  elif model_name == "xclip-large-patch14":
    __lowerCamelCase			:			Tuple       			=					torch.tensor([[0.0062, 0.9864, 0.0075]]			)
  elif model_name == "xclip-large-patch14-16-frames":
    __lowerCamelCase			:			Dict       			=					torch.tensor([[3.3877E-04, 9.9937E-01, 2.8888E-04]]			)
  # kinetics-600
  elif model_name == "xclip-base-patch16-kinetics-600":
    __lowerCamelCase			:			str       			=					torch.tensor([[0.0555, 0.8914, 0.0531]]			)
  elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
    __lowerCamelCase			:			List[Any]       			=					torch.tensor([[3.8554E-04, 9.9929E-01, 3.2754E-04]]			)
  elif model_name == "xclip-large-patch14-kinetics-600":
    __lowerCamelCase			:			Any       			=					torch.tensor([[0.0036, 0.9920, 0.0045]]			)
  # few shot
  elif model_name == "xclip-base-patch16-hmdb-2-shot":
    __lowerCamelCase			:			Any       			=					torch.tensor([[7.1890E-06, 9.9994E-01, 5.6559E-05]]			)
  elif model_name == "xclip-base-patch16-hmdb-4-shot":
    __lowerCamelCase			:			List[str]       			=					torch.tensor([[1.0320E-05, 9.9993E-01, 6.2435E-05]]			)
  elif model_name == "xclip-base-patch16-hmdb-8-shot":
    __lowerCamelCase			:			Optional[int]       			=					torch.tensor([[4.1377E-06, 9.9990E-01, 9.8386E-05]]			)
  elif model_name == "xclip-base-patch16-hmdb-16-shot":
    __lowerCamelCase			:			Tuple       			=					torch.tensor([[4.1347E-05, 9.9962E-01, 3.3411E-04]]			)
  elif model_name == "xclip-base-patch16-ucf-2-shot":
    __lowerCamelCase			:			Optional[Any]       			=					torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]			)
  elif model_name == "xclip-base-patch16-ucf-4-shot":
    __lowerCamelCase			:			int       			=					torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]			)
  elif model_name == "xclip-base-patch16-ucf-8-shot":
    __lowerCamelCase			:			str       			=					torch.tensor([[0.0027, 0.9904, 0.0070]]			)
  elif model_name == "xclip-base-patch16-ucf-16-shot":
    __lowerCamelCase			:			Tuple       			=					torch.tensor([[9.8219E-04, 9.9593E-01, 3.0863E-03]]			)
  # zero shot
  elif model_name == "xclip-base-patch16-zero-shot":
    __lowerCamelCase			:			Union[str, Any]       			=					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__":
   _UpperCamelCase											=		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.'
   )

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











'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_UpperCamelCase											=		{
    'configuration_bridgetower': [
        'BRIDGETOWER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'BridgeTowerConfig',
        'BridgeTowerTextConfig',
        'BridgeTowerVisionConfig',
    ],
    'processing_bridgetower': ['BridgeTowerProcessor'],
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=		['BridgeTowerImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=		[
       'BRIDGETOWER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'BridgeTowerForContrastiveLearning',
       'BridgeTowerForImageAndTextRetrieval',
       'BridgeTowerForMaskedLM',
       'BridgeTowerModel',
       'BridgeTowerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_bridgetower import (
       BRIDGETOWER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       BridgeTowerConfig,
       BridgeTowerTextConfig,
       BridgeTowerVisionConfig,
   )
   from .processing_bridgetower import BridgeTowerProcessor

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_bridgetower import BridgeTowerImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_bridgetower import (
          BRIDGETOWER_PRETRAINED_MODEL_ARCHIVE_LIST,
          BridgeTowerForContrastiveLearning,
          BridgeTowerForImageAndTextRetrieval,
          BridgeTowerForMaskedLM,
          BridgeTowerModel,
          BridgeTowerPreTrainedModel,
      )


else:
   import sys

   _UpperCamelCase											=		_LazyModule(__name__, globals()['__file__'], _import_structure)






