






import argparse
import json

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

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  TimesformerConfig()

						if "large" in model_name:
												lowerCAmelCase__			  =  96

						if "hr" in model_name:
												lowerCAmelCase__			  =  16
												lowerCAmelCase__			  =  448

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

						return config







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict						)     ->      Union[str, Any]:

						"""simple docstring"""



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

						return name







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[str]			,				UpperCamelCase_				:    int						)     ->      Optional[int]:

						"""simple docstring"""



						for key in orig_state_dict.copy().keys():
												lowerCAmelCase__			  =  orig_state_dict.pop(UpperCamelCase_						)

												if key.startswith('model.'						):
																		lowerCAmelCase__			  =  key.replace('model.'			,				''						)

												if "qkv" in key:
																		lowerCAmelCase__			  =  key.split('.'						)
																		lowerCAmelCase__			  =  int(key_split[1]						)
																		lowerCAmelCase__			  =  'timesformer.encoder.layer.'
																		if "temporal" in key:
																								lowerCAmelCase__			  =  '.temporal_attention.attention.qkv.'
																		else:
																								lowerCAmelCase__			  =  '.attention.attention.qkv.'
																		if "weight" in key:
																								lowerCAmelCase__			  =  val
																		else:
																								lowerCAmelCase__			  =  val
												else:
																		lowerCAmelCase__			  =  val

						return orig_state_dict







def 		_UpperCamelCase      (			)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  hf_hub_download(
						    repo_id='hf-internal-testing/spaghetti-video'			,				filename='eating_spaghetti.npy'			,				repo_type='dataset'						)
						lowerCAmelCase__			  =  np.load(UpperCamelCase_						)
						return list(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[str]			,				UpperCamelCase_				:    str			,				UpperCamelCase_				:    int			,				UpperCamelCase_				:    List[Any]						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  get_timesformer_config(UpperCamelCase_						)

						lowerCAmelCase__			  =  TimesformerForVideoClassification(UpperCamelCase_						)

						# download original checkpoint, hosted on Google Drive
						lowerCAmelCase__			  =  'pytorch_model.bin'
						gdown.cached_download(UpperCamelCase_			,				UpperCamelCase_			,				quiet=UpperCamelCase_						)
						lowerCAmelCase__			  =  torch.load(UpperCamelCase_			,				map_location='cpu'						)
						if "model" in files:
												lowerCAmelCase__			  =  files['model']
						elif "module" in files:
												lowerCAmelCase__			  =  files['module']
						else:
												lowerCAmelCase__			  =  files['model_state']
						lowerCAmelCase__			  =  convert_state_dict(UpperCamelCase_			,				UpperCamelCase_						)

						model.load_state_dict(UpperCamelCase_						)
						model.eval()

						# verify model on basic input
						lowerCAmelCase__			  =  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,				image_std=[0.5, 0.5, 0.5]						)
						lowerCAmelCase__			  =  prepare_video()
						lowerCAmelCase__			  =  image_processor(video[:8]			,				return_tensors='pt'						)

						lowerCAmelCase__			  =  model(**UpperCamelCase_						)
						lowerCAmelCase__			  =  outputs.logits

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

						# NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
						if model_name == "timesformer-base-finetuned-k400":
												lowerCAmelCase__			  =  torch.Size([1, 400]						)
												lowerCAmelCase__			  =  torch.tensor([-0.3016, -0.7713, -0.4205]						)
						elif model_name == "timesformer-base-finetuned-k600":
												lowerCAmelCase__			  =  torch.Size([1, 600]						)
												lowerCAmelCase__			  =  torch.tensor([-0.7267, -0.7466, 3.2404]						)
						elif model_name == "timesformer-base-finetuned-ssv2":
												lowerCAmelCase__			  =  torch.Size([1, 174]						)
												lowerCAmelCase__			  =  torch.tensor([-0.9059, 0.6433, -3.1457]						)
						elif model_name == "timesformer-large-finetuned-k400":
												lowerCAmelCase__			  =  torch.Size([1, 400]						)
												lowerCAmelCase__			  =  torch.tensor([0, 0, 0]						)
						elif model_name == "timesformer-large-finetuned-k600":
												lowerCAmelCase__			  =  torch.Size([1, 600]						)
												lowerCAmelCase__			  =  torch.tensor([0, 0, 0]						)
						elif model_name == "timesformer-large-finetuned-ssv2":
												lowerCAmelCase__			  =  torch.Size([1, 174]						)
												lowerCAmelCase__			  =  torch.tensor([0, 0, 0]						)
						elif model_name == "timesformer-hr-finetuned-k400":
												lowerCAmelCase__			  =  torch.Size([1, 400]						)
												lowerCAmelCase__			  =  torch.tensor([-0.9617, -3.7311, -3.7708]						)
						elif model_name == "timesformer-hr-finetuned-k600":
												lowerCAmelCase__			  =  torch.Size([1, 600]						)
												lowerCAmelCase__			  =  torch.tensor([2.5273, 0.7127, 1.8848]						)
						elif model_name == "timesformer-hr-finetuned-ssv2":
												lowerCAmelCase__			  =  torch.Size([1, 174]						)
												lowerCAmelCase__			  =  torch.tensor([-3.6756, -0.7513, 0.7180]						)
						else:
												raise ValueError(F"Model name not supported. Should be one of {model_names}"						)

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

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

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


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

					__snake_case			:			int			   =   parser.parse_args()
					convert_timesformer_checkpoint(
					    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
					)













import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


__snake_case			:			int			   =   {
    """vit_b32""": {
        """embed_dim""": 5_12,
        """image_resolution""": 7_68,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 12,
        """vision_width""": 7_68,
        """vision_patch_size""": 32,
        """transformer_width""": 5_12,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_b16""": {
        """embed_dim""": 5_12,
        """image_resolution""": 7_68,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 12,
        """vision_width""": 7_68,
        """vision_patch_size""": 16,
        """transformer_width""": 5_12,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_l14""": {
        """embed_dim""": 7_68,
        """image_resolution""": 8_40,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 24,
        """vision_width""": 10_24,
        """vision_patch_size""": 14,
        """transformer_width""": 7_68,
        """transformer_heads""": 12,
        """transformer_layers""": 12,
    },
}







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    Any=""			,				UpperCamelCase_				:    List[str]="/"						)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  []

						for k, v in params.items():
												lowerCAmelCase__			  =  parent_key + sep + k if parent_key else k

												if isinstance(UpperCamelCase_			,				collections.MutableMapping						):
																		items.extend(flatten_nested_dict(UpperCamelCase_			,				UpperCamelCase_			,				sep=UpperCamelCase_						).items()						)
												else:
																		items.append((new_key, v)						)
						return dict(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple						)     ->      Optional[int]:

						"""simple docstring"""



						return jax.tree_util.tree_map(lambda UpperCamelCase_						: x.astype(jnp.floataa						) if x.dtype == jnp.bfloataa else x			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    Union[str, Any]						)     ->      List[Any]:

						"""simple docstring"""



						lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  pt_attn_layer.in_proj_weight.chunk(3			,				dim=0						)
						lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  pt_attn_layer.in_proj_bias.chunk(3			,				dim=0						)

						lowerCAmelCase__			  =  pt_attn_layer.out_proj.weight
						lowerCAmelCase__			  =  pt_attn_layer.out_proj.bias

						lowerCAmelCase__			  =  q_proj
						lowerCAmelCase__			  =  q_proj_bias

						lowerCAmelCase__			  =  k_proj
						lowerCAmelCase__			  =  k_proj_bias

						lowerCAmelCase__			  =  v_proj
						lowerCAmelCase__			  =  v_proj_bias

						lowerCAmelCase__			  =  out_proj_weights
						lowerCAmelCase__			  =  out_proj_bias







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Union[str, Any]:

						"""simple docstring"""



						copy_linear(hf_mlp.fca			,				pt_mlp.c_fc						)
						copy_linear(hf_mlp.fca			,				pt_mlp.c_proj						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Union[str, Any]			,				UpperCamelCase_				:    Tuple						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_linear.weight
						lowerCAmelCase__			  =  pt_linear.bias







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    Optional[Any]						)     ->      Tuple:

						"""simple docstring"""



						copy_linear(hf_layer.layer_norma			,				pt_layer.ln_a						)
						copy_linear(hf_layer.layer_norma			,				pt_layer.ln_a						)

						# copy MLP
						copy_mlp(hf_layer.mlp			,				pt_layer.mlp						)

						# copy attn
						copy_attn_layer(hf_layer.self_attn			,				pt_layer.attn						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    List[str]						)     ->      Optional[int]:

						"""simple docstring"""



						for hf_layer, pt_layer in zip(UpperCamelCase_			,				UpperCamelCase_						):
												copy_layer(UpperCamelCase_			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.token_embedding.weight
						lowerCAmelCase__			  =  pt_model.positional_embedding

						# copy layer norm
						copy_linear(hf_encoder.final_layer_norm			,				pt_model.ln_final						)

						# copy hidden layers
						copy_layers(hf_encoder.encoder.layers			,				pt_model.transformer.resblocks						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    Dict						)     ->      Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.text_projection.data.T

						# copy text encoder
						copy_encoder(hf_model.text_model			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    str						)     ->      Tuple:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.visual.proj.data.T

						# copy layer norms
						copy_linear(hf_model.vision_model.pre_layernorm			,				pt_model.visual.ln_pre						)
						copy_linear(hf_model.vision_model.post_layernorm			,				pt_model.visual.ln_post						)

						# copy embeds
						lowerCAmelCase__			  =  pt_model.visual.conva.weight.data
						lowerCAmelCase__			  =  pt_model.visual.class_embedding
						lowerCAmelCase__			  =  pt_model.visual.positional_embedding.data

						# copy encoder
						copy_layers(hf_model.vision_model.encoder.layers			,				pt_model.visual.transformer.resblocks						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    Any						)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['backbone']['merged_class_token']						)

						lowerCAmelCase__			  =  torch.from_numpy(flax_class_token_params['scale']						)
						lowerCAmelCase__			  =  torch.from_numpy(flax_class_token_params['bias']						)
						lowerCAmelCase__			  =  nn.Parameter(UpperCamelCase_						)
						lowerCAmelCase__			  =  nn.Parameter(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    str			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  hf_model.state_dict()
						lowerCAmelCase__			  =  {}

						# Rename class prediction head flax params to pytorch HF
						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['class_head']						)

						for flax_key, v in flax_class_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('Dense_0'			,				'dense0'						)
												lowerCAmelCase__			  =  'class_head.' + torch_key

												if "weight" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  nn.Parameter(torch.from_numpy(UpperCamelCase_						)						)

						# Rename box prediction box flax params to pytorch HF
						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['obj_box_head']						)

						for flax_key, v in flax_box_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('_'			,				''						).lower()
												lowerCAmelCase__			  =  'box_head.' + torch_key

												if "weight" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  nn.Parameter(torch.from_numpy(UpperCamelCase_						)						)

						# Copy flax params to PyTorch params
						for name, param in new_params.items():
												if name in pt_params.keys():
																		pt_params[name].copy_(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple			,				UpperCamelCase_				:    List[str]						)     ->      str:

						"""simple docstring"""



						for k, v in flax_attn_params.items():
												if k.startswith('transformer'						):
																		lowerCAmelCase__			  =  k.replace('transformer.resblocks'			,				'text_model.encoder.layers'						)
												else:
																		lowerCAmelCase__			  =  k.replace('visual.transformer.resblocks'			,				'vision_model.encoder.layers'						)

												lowerCAmelCase__			  =  torch_key.replace('attn'			,				'self_attn'						)
												lowerCAmelCase__			  =  torch_key.replace('key'			,				'k_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('value'			,				'v_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('query'			,				'q_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('out'			,				'out_proj'						)

												if "bias" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.shape[0] * v.shape[1]
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						)

												if "weight" in torch_key and "out" in torch_key:
																		lowerCAmelCase__			  =  (v.shape[0] * v.shape[1], v.shape[2])
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						).T

												if "weight" in torch_key and "out" not in torch_key:
																		lowerCAmelCase__			  =  (v.shape[0], v.shape[1] * v.shape[2])
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						).T

												# Copy flax CLIP attn params to HF PyTorch params
												lowerCAmelCase__			  =  torch.from_numpy(UpperCamelCase_						)
												hf_backbone.state_dict()[torch_key].copy_(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any						)     ->      Dict:

						"""simple docstring"""



						lowerCAmelCase__			  =  {}
						lowerCAmelCase__			  =  []

						for k, v in params.items():
												if "attn." in k:
																		lowerCAmelCase__			  =  k[: k.rindex('attn.'						) + 5]
																		if base in processed_attn_layers:
																								continue

																		processed_attn_layers.append(UpperCamelCase_						)
																		lowerCAmelCase__			  =  params[base + 'out.weight'].shape[-1]
																		lowerCAmelCase__			  =  params[base + 'out.weight'].reshape(UpperCamelCase_			,				UpperCamelCase_						).T
																		lowerCAmelCase__			  =  params[base + 'out.bias']
												else:
																		lowerCAmelCase__			  =  v
						return new_params







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    int						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  CLIP(**UpperCamelCase_						)
						torch_model.eval()
						lowerCAmelCase__			  =  torch_model.state_dict()

						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['backbone']['clip']						)
						lowerCAmelCase__			  =  {}

						for flax_key, v in flax_clip_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('text.token_embedding.embedding'			,				'token_embedding.kernel'						)

												if (
												    torch_key.startswith('text.transformer'						)
												    or torch_key.startswith('text.text_projection'						)
												    or torch_key.startswith('text.ln_final'						)
												    or torch_key.startswith('text.positional_embedding'						)
												):
																		lowerCAmelCase__			  =  torch_key[5:]

												lowerCAmelCase__			  =  torch_key.replace('text_projection.kernel'			,				'text_projection'						)
												lowerCAmelCase__			  =  torch_key.replace('visual.proj.kernel'			,				'visual.proj'						)
												lowerCAmelCase__			  =  torch_key.replace('.scale'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)

												if "conv" in torch_key or "downsample.0.weight" in torch_key:
																		lowerCAmelCase__			  =  v.transpose(3			,				2			,				0			,				1						)

												elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
																		# Fully connected layers are transposed, embeddings are not
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  v

						lowerCAmelCase__			  =  _convert_attn_layers(UpperCamelCase_						)
						new_torch_params.update(UpperCamelCase_						)
						lowerCAmelCase__			  =  {}

						# Copy flax CLIP backbone params to PyTorch params
						for name, param in new_torch_params.items():
												if name in torch_clip_params.keys():
																		lowerCAmelCase__			  =  torch.from_numpy(new_torch_params[name]						)
																		torch_clip_params[name].copy_(UpperCamelCase_						)
												else:
																		lowerCAmelCase__			  =  param

						return torch_clip_params, torch_model, attn_params







@torch.no_grad()
def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    Union[str, Any]			,				UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    List[Any]=None						)     ->      Any:

						"""simple docstring"""



						lowerCAmelCase__			  =  Repository(UpperCamelCase_			,				clone_from=F"google/{pytorch_dump_folder_path}"						)
						repo.git_pull()

						if config_path is not None:
												lowerCAmelCase__			  =  OwlViTConfig.from_pretrained(UpperCamelCase_						)
						else:
												lowerCAmelCase__			  =  OwlViTConfig()

						lowerCAmelCase__			  =  OwlViTModel(UpperCamelCase_						).eval()
						lowerCAmelCase__			  =  OwlViTForObjectDetection(UpperCamelCase_						).eval()

						copy_text_model_and_projection(UpperCamelCase_			,				UpperCamelCase_						)
						copy_vision_model_and_projection(UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  pt_backbone.logit_scale
						copy_flax_attn_params(UpperCamelCase_			,				UpperCamelCase_						)

						lowerCAmelCase__			  =  hf_backbone
						copy_class_merge_token(UpperCamelCase_			,				UpperCamelCase_						)
						copy_class_box_heads(UpperCamelCase_			,				UpperCamelCase_						)

						# Save HF model
						hf_model.save_pretrained(repo.local_dir						)

						# Initialize image processor
						lowerCAmelCase__			  =  OwlViTImageProcessor(
						    size=config.vision_config.image_size			,				crop_size=config.vision_config.image_size						)
						# Initialize tokenizer
						lowerCAmelCase__			  =  CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32'			,				pad_token='!'			,				model_max_length=16						)

						# Initialize processor
						lowerCAmelCase__			  =  OwlViTProcessor(image_processor=UpperCamelCase_			,				tokenizer=UpperCamelCase_						)
						image_processor.save_pretrained(repo.local_dir						)
						processor.save_pretrained(repo.local_dir						)

						repo.git_add()
						repo.git_commit('Upload model and processor'						)
						repo.git_push()


if __name__ == "__main__":
					__snake_case			:			Union[str, Any]			   =   argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--owlvit_version""",
					    default=None,
					    type=str,
					    required=True,
					    help="""OWL-ViT model name [clip_b16, clip_b32, clip_l14].""",
					)
					parser.add_argument(
					    """--owlvit_checkpoint""", default=None, type=str, required=True, help="""Path to flax model checkpoint."""
					)
					parser.add_argument("""--hf_config""", default=None, type=str, required=True, help="""Path to HF model config.""")
					parser.add_argument(
					    """--pytorch_dump_folder_path""", default="""hf_model""", type=str, help="""Path to the output PyTorch model."""
					)
					__snake_case			:			Any			   =   parser.parse_args()

					# Initialize PyToch clip model
					__snake_case			:			int			   =   args.owlvit_version
					if model_name == "clip_b16":
										__snake_case			:			Optional[Any]			   =   CONFIGS["""vit_b16"""]
					elif model_name == "clip_b32":
										__snake_case			:			Optional[int]			   =   CONFIGS["""vit_b32"""]
					elif model_name == "clip_l14":
										__snake_case			:			int			   =   CONFIGS["""vit_l14"""]

					# Load from checkpoint and convert params to float-32
					__snake_case			:			List[str]			   =   checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["""optimizer"""]["""target"""]
					__snake_case			:			List[str]			   =   jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
					del variables

					# Convert CLIP backbone
					__snake_case   ,       __snake_case   ,       __snake_case			:			Tuple			   =   convert_clip_backbone(flax_params, torch_config)

					convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)





