






'''simple docstring'''





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


a_      = {
    'vit_b32': {
        'embed_dim': 512,
        'image_resolution': 768,
        'context_length': 16,
        'vocab_size': 49_408,
        'vision_layers': 12,
        'vision_width': 768,
        'vision_patch_size': 32,
        'transformer_width': 512,
        'transformer_heads': 8,
        'transformer_layers': 12,
    },
    'vit_b16': {
        'embed_dim': 512,
        'image_resolution': 768,
        'context_length': 16,
        'vocab_size': 49_408,
        'vision_layers': 12,
        'vision_width': 768,
        'vision_patch_size': 16,
        'transformer_width': 512,
        'transformer_heads': 8,
        'transformer_layers': 12,
    },
    'vit_l14': {
        'embed_dim': 768,
        'image_resolution': 840,
        'context_length': 16,
        'vocab_size': 49_408,
        'vision_layers': 24,
        'vision_width': 1_024,
        'vision_patch_size': 14,
        'transformer_width': 768,
        'transformer_heads': 12,
        'transformer_layers': 12,
    },
}



def 			__UpperCAmelCase				(lowercase__	,lowercase__=""	,lowercase__="/"				)		->				Any:

						'''simple docstring'''


						a_				     =   []

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

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



def 			__UpperCAmelCase				(lowercase__				)		->				Dict:

						'''simple docstring'''


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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				List[str]:

						'''simple docstring'''


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

						a_				     =   pt_attn_layer.out_proj.weight
						a_				     =   pt_attn_layer.out_proj.bias

						a_				     =   q_proj
						a_				     =   q_proj_bias

						a_				     =   k_proj
						a_				     =   k_proj_bias

						a_				     =   v_proj
						a_				     =   v_proj_bias

						a_				     =   out_proj_weights
						a_				     =   out_proj_bias



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				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				(lowercase__	,lowercase__				)		->				str:

						'''simple docstring'''


						a_				     =   pt_linear.weight
						a_				     =   pt_linear.bias



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				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				(lowercase__	,lowercase__				)		->				Union[str, Any]:

						'''simple docstring'''


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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				Union[str, Any]:

						'''simple docstring'''


						a_				     =   pt_model.token_embedding.weight
						a_				     =   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				(lowercase__	,lowercase__				)		->				Optional[int]:

						'''simple docstring'''


						a_				     =   pt_model.text_projection.data.T

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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				Tuple:

						'''simple docstring'''


						a_				     =   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
						a_				     =   pt_model.visual.conva.weight.data
						a_				     =   pt_model.visual.class_embedding
						a_				     =   pt_model.visual.positional_embedding.data

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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				str:

						'''simple docstring'''


						a_				     =   flatten_nested_dict(flax_params["backbone"]["merged_class_token"]				)

						a_				     =   torch.from_numpy(flax_class_token_params["scale"]				)
						a_				     =   torch.from_numpy(flax_class_token_params["bias"]				)
						a_				     =   nn.Parameter(lowercase__				)
						a_				     =   nn.Parameter(lowercase__				)



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				str:

						'''simple docstring'''


						a_				     =   hf_model.state_dict()
						a_				     =   {}

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

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

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

												a_				     =   nn.Parameter(torch.from_numpy(lowercase__				)				)

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

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

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

												a_				     =   nn.Parameter(torch.from_numpy(lowercase__				)				)

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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				Tuple:

						'''simple docstring'''


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

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

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

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

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

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



def 			__UpperCAmelCase				(lowercase__				)		->				List[Any]:

						'''simple docstring'''


						a_				     =   {}
						a_				     =   []

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

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



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				Tuple:

						'''simple docstring'''


						a_				     =   CLIP(**lowercase__				)
						torch_model.eval()
						a_				     =   torch_model.state_dict()

						a_				     =   flatten_nested_dict(flax_params["backbone"]["clip"]				)
						a_				     =   {}

						for flax_key, v in flax_clip_params.items():
												a_				     =   flax_key.replace("/"	,"."				)
												a_				     =   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"				)
												):
																		a_				     =   torch_key[5:]

												a_				     =   torch_key.replace("text_projection.kernel"	,"text_projection"				)
												a_				     =   torch_key.replace("visual.proj.kernel"	,"visual.proj"				)
												a_				     =   torch_key.replace(".scale"	,".weight"				)
												a_				     =   torch_key.replace(".kernel"	,".weight"				)

												if "conv" in torch_key or "downsample.0.weight" in torch_key:
																		a_				     =   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
																		a_				     =   v.T

												a_				     =   v

						a_				     =   _convert_attn_layers(lowercase__				)
						new_torch_params.update(lowercase__				)
						a_				     =   {}

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

						return torch_clip_params, torch_model, attn_params



@torch.no_grad()
def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__	,lowercase__	,lowercase__=None				)		->				List[str]:

						'''simple docstring'''


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

						if config_path is not None:
												a_				     =   OwlViTConfig.from_pretrained(lowercase__				)
						else:
												a_				     =   OwlViTConfig()

						a_				     =   OwlViTModel(lowercase__				).eval()
						a_				     =   OwlViTForObjectDetection(lowercase__				).eval()

						copy_text_model_and_projection(lowercase__	,lowercase__				)
						copy_vision_model_and_projection(lowercase__	,lowercase__				)
						a_				     =   pt_backbone.logit_scale
						copy_flax_attn_params(lowercase__	,lowercase__				)

						a_				     =   hf_backbone
						copy_class_merge_token(lowercase__	,lowercase__				)
						copy_class_box_heads(lowercase__	,lowercase__				)

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

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

						# Initialize processor
						a_				     =   OwlViTProcessor(image_processor=lowercase__	,tokenizer=lowercase__				)
						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__":
							a_      = 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.'
							)
							a_      = parser.parse_args()

							# Initialize PyToch clip model
							a_      = args.owlvit_version
							if model_name == "clip_b16":
														a_      = CONFIGS['vit_b16']
							elif model_name == "clip_b32":
														a_      = CONFIGS['vit_b32']
							elif model_name == "clip_l14":
														a_      = CONFIGS['vit_l14']

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

							# Convert CLIP backbone
							a_ ,    a_ ,    a_      = convert_clip_backbone(flax_params, torch_config)

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











'''simple docstring'''





from functools import partial
from typing import Any, Callable, Dict, List, Type, TypeVar, Union, overload

import torch
import torch.nn as nn
import torch.types



def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				torch.Tensor:

						'''simple docstring'''


						if not inplace:
												a_				     =   ma + ma
						else:
												ma += ma

						return ma



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				torch.Tensor:

						'''simple docstring'''


						a_				     =   -1 * len(lowercase__				)
						a_				     =   list(range(len(tensor.shape[:zero_index]				)				)				)
						return tensor.permute(first_inds + [zero_index + i for i in inds]				)



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				torch.Tensor:

						'''simple docstring'''


						return t.reshape(t.shape[:-no_dims] + (-1,)				)



def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__	,lowercase__ = 1e-4				)		->				torch.Tensor:

						'''simple docstring'''


						a_				     =   mask.expand(*value.shape				)
						return torch.sum(mask * value	,dim=lowercase__				) / (eps + torch.sum(lowercase__	,dim=lowercase__				))



def 			__UpperCAmelCase				(lowercase__	,lowercase__ = 2.3125	,lowercase__ = 21.6875	,lowercase__ = 64				)		->				torch.Tensor:

						'''simple docstring'''


						a_				     =   torch.linspace(lowercase__	,lowercase__	,no_bins - 1	,device=pts.device				)
						a_				     =   torch.sqrt(torch.sum((pts.unsqueeze(-2				) - pts.unsqueeze(-3				)) ** 2	,dim=-1				)				)
						return torch.bucketize(lowercase__	,lowercase__				)



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				dict:

						'''simple docstring'''


						a_				     =   dicts[0]
						a_				     =   {}
						for k, v in first.items():
												a_				     =   [d[k] for d in dicts]
												if isinstance(lowercase__	,lowercase__				):
																		a_				     =   dict_multimap(lowercase__	,lowercase__				)
												else:
																		a_				     =   fn(lowercase__				)

						return new_dict



def 			__UpperCAmelCase				(lowercase__	,lowercase__				)		->				torch.Tensor:

						'''simple docstring'''


						a_				     =   v_bins.view(((1,) * len(x.shape				)) + (len(lowercase__				),)				)
						a_				     =   x[..., None] - reshaped_bins
						a_				     =   torch.argmin(torch.abs(lowercase__				)	,dim=-1				)
						return nn.functional.one_hot(lowercase__	,num_classes=len(lowercase__				)				).float()



def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__ = 0	,lowercase__ = 0				)		->				torch.Tensor:

						'''simple docstring'''


						a_				     =   []
						for i, s in enumerate(data.shape[:no_batch_dims]				):
												a_				     =   torch.arange(lowercase__				)
												a_				     =   r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape				) - i - 1)))				)
												ranges.append(lowercase__				)

						a_				     =   [slice(lowercase__				) for _ in range(len(data.shape				) - no_batch_dims				)]
						a_				     =   inds
						ranges.extend(lowercase__				)
						# Matt note: Editing this to get around the behaviour of using a list as an array index changing
						# in recent Numpy versions
						return data[tuple(lowercase__				)]


a_      = TypeVar('T')



def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				Dict[Any, Union[dict, list, tuple, Any]]:

						'''simple docstring'''


						a_				     =   {}
						for k, v in dic.items():
												if isinstance(lowercase__	,lowercase__				):
																		a_				     =   dict_map(lowercase__	,lowercase__	,lowercase__				)
												else:
																		a_				     =   tree_map(lowercase__	,lowercase__	,lowercase__				)

						return new_dict



@overload
def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				Any:

						'''simple docstring'''


						...



@overload
def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				dict:

						'''simple docstring'''


						...



@overload
def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				list:

						'''simple docstring'''


						...



@overload
def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				tuple:

						'''simple docstring'''


						...



def 			__UpperCAmelCase				(lowercase__	,lowercase__	,lowercase__				)		->				List[Any]:

						'''simple docstring'''


						if isinstance(lowercase__	,lowercase__				):
												return dict_map(lowercase__	,lowercase__	,lowercase__				)
						elif isinstance(lowercase__	,lowercase__				):
												return [tree_map(lowercase__	,lowercase__	,lowercase__				) for x in tree]
						elif isinstance(lowercase__	,lowercase__				):
												return tuple(tree_map(lowercase__	,lowercase__	,lowercase__				) for x in tree				)
						elif isinstance(lowercase__	,lowercase__				):
												return fn(lowercase__				)
						else:
												print(type(lowercase__				)				)
												raise ValueError("Not supported"				)
a_      = partial(tree_map, leaf_type=torch.Tensor)



