"""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	:	Optional[Any]=					{
    "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							(       UpperCAmelCase_       :							Dict     ,				UpperCAmelCase_       :							Any=""     ,				UpperCAmelCase_       :							Dict="/"    )				->     Optional[int]:

	'''simple docstring'''





	__snake_case     :				Any 						=					[]

	for k, v in params.items():
		__snake_case     :				int 						=					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_       :							List[str]    )				->     List[str]:

	'''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_       :							Tuple     ,				UpperCAmelCase_       :							Optional[int]    )				->     str:

	'''simple docstring'''





	__snake_case						,							__snake_case						,							__snake_case     :				Dict 						=					pt_attn_layer.in_proj_weight.chunk(3     ,				dim=0    )
	__snake_case						,							__snake_case						,							__snake_case     :				List[Any] 						=					pt_attn_layer.in_proj_bias.chunk(3     ,				dim=0    )

	__snake_case     :				str 						=					pt_attn_layer.out_proj.weight
	__snake_case     :				Any 						=					pt_attn_layer.out_proj.bias

	__snake_case     :				Dict 						=					q_proj
	__snake_case     :				int 						=					q_proj_bias

	__snake_case     :				Any 						=					k_proj
	__snake_case     :				Optional[int] 						=					k_proj_bias

	__snake_case     :				List[Any] 						=					v_proj
	__snake_case     :				str 						=					v_proj_bias

	__snake_case     :				Optional[int] 						=					out_proj_weights
	__snake_case     :				Optional[int] 						=					out_proj_bias
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Union[str, Any]     ,				UpperCAmelCase_       :							Optional[int]    )				->     Dict:

	'''simple docstring'''





	copy_linear(hf_mlp.fca     ,				pt_mlp.c_fc    )
	copy_linear(hf_mlp.fca     ,				pt_mlp.c_proj    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							int     ,				UpperCAmelCase_       :							List[Any]    )				->     Dict:

	'''simple docstring'''





	__snake_case     :				int 						=					pt_linear.weight
	__snake_case     :				Dict 						=					pt_linear.bias
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Any     ,				UpperCAmelCase_       :							int    )				->     List[str]:

	'''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_       :							str     ,				UpperCAmelCase_       :							Tuple    )				->     str:

	'''simple docstring'''





	for hf_layer, pt_layer in zip(UpperCAmelCase_     ,				UpperCAmelCase_    ):
		copy_layer(UpperCAmelCase_     ,				UpperCAmelCase_    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Optional[int]     ,				UpperCAmelCase_       :							Optional[Any]    )				->     Tuple:

	'''simple docstring'''





	__snake_case     :				int 						=					pt_model.token_embedding.weight
	__snake_case     :				Optional[int] 						=					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_       :							str     ,				UpperCAmelCase_       :							List[str]    )				->     List[Any]:

	'''simple docstring'''





	__snake_case     :				Tuple 						=					pt_model.text_projection.data.T

	# copy text encoder
	copy_encoder(hf_model.text_model     ,				UpperCAmelCase_    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[Any]     ,				UpperCAmelCase_       :							List[Any]    )				->     Optional[int]:

	'''simple docstring'''





	__snake_case     :				str 						=					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
	__snake_case     :				Union[str, Any] 						=					pt_model.visual.conva.weight.data
	__snake_case     :				Dict 						=					pt_model.visual.class_embedding
	__snake_case     :				Optional[Any] 						=					pt_model.visual.positional_embedding.data

	# copy encoder
	copy_layers(hf_model.vision_model.encoder.layers     ,				pt_model.visual.transformer.resblocks    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							int     ,				UpperCAmelCase_       :							Dict    )				->     str:

	'''simple docstring'''





	__snake_case     :				str 						=					flatten_nested_dict(flax_params['backbone']['merged_class_token']    )

	__snake_case     :				Optional[Any] 						=					torch.from_numpy(flax_class_token_params['scale']    )
	__snake_case     :				Optional[int] 						=					torch.from_numpy(flax_class_token_params['bias']    )
	__snake_case     :				Tuple 						=					nn.Parameter(UpperCAmelCase_    )
	__snake_case     :				Union[str, Any] 						=					nn.Parameter(UpperCAmelCase_    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Union[str, Any]     ,				UpperCAmelCase_       :							int    )				->     str:

	'''simple docstring'''





	__snake_case     :				int 						=					hf_model.state_dict()
	__snake_case     :				Optional[Any] 						=					{}

	# Rename class prediction head flax params to pytorch HF
	__snake_case     :				Optional[int] 						=					flatten_nested_dict(flax_params['class_head']    )

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

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

		__snake_case     :				Any 						=					nn.Parameter(torch.from_numpy(UpperCAmelCase_    )    )

	# Rename box prediction box flax params to pytorch HF
	__snake_case     :				Union[str, Any] 						=					flatten_nested_dict(flax_params['obj_box_head']    )

	for flax_key, v in flax_box_params.items():
		__snake_case     :				Tuple 						=					flax_key.replace('/'     ,				'.'    )
		__snake_case     :				Optional[Any] 						=					torch_key.replace('.kernel'     ,				'.weight'    )
		__snake_case     :				Optional[int] 						=					torch_key.replace('_'     ,				''    ).lower()
		__snake_case     :				Union[str, Any] 						=					'box_head.' + torch_key

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

		__snake_case     :				List[Any] 						=					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_       :							int     ,				UpperCAmelCase_       :							List[Any]    )				->     Optional[Any]:

	'''simple docstring'''





	for k, v in flax_attn_params.items():
		if k.startswith('transformer'    ):
			__snake_case     :				Optional[Any] 						=					k.replace('transformer.resblocks'     ,				'text_model.encoder.layers'    )
		else:
			__snake_case     :				Union[str, Any] 						=					k.replace('visual.transformer.resblocks'     ,				'vision_model.encoder.layers'    )

		__snake_case     :				str 						=					torch_key.replace('attn'     ,				'self_attn'    )
		__snake_case     :				Union[str, Any] 						=					torch_key.replace('key'     ,				'k_proj'    )
		__snake_case     :				List[Any] 						=					torch_key.replace('value'     ,				'v_proj'    )
		__snake_case     :				Union[str, Any] 						=					torch_key.replace('query'     ,				'q_proj'    )
		__snake_case     :				Any 						=					torch_key.replace('out'     ,				'out_proj'    )

		if "bias" in torch_key and v.ndim == 2:
			__snake_case     :				Optional[int] 						=					v.shape[0] * v.shape[1]
			__snake_case     :				List[Any] 						=					v.reshape(UpperCAmelCase_    )

		if "weight" in torch_key and "out" in torch_key:
			__snake_case     :				Optional[int] 						=					(v.shape[0] * v.shape[1], v.shape[2])
			__snake_case     :				List[str] 						=					v.reshape(UpperCAmelCase_    ).T

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

		# Copy flax CLIP attn params to HF PyTorch params
		__snake_case     :				str 						=					torch.from_numpy(UpperCAmelCase_    )
		hf_backbone.state_dict()[torch_key].copy_(UpperCAmelCase_    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[str]    )				->     Optional[int]:

	'''simple docstring'''





	__snake_case     :				Dict 						=					{}
	__snake_case     :				Union[str, Any] 						=					[]

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

			processed_attn_layers.append(UpperCAmelCase_    )
			__snake_case     :				Tuple 						=					params[base + 'out.weight'].shape[-1]
			__snake_case     :				Any 						=					params[base + 'out.weight'].reshape(UpperCAmelCase_     ,				UpperCAmelCase_    ).T
			__snake_case     :				Union[str, Any] 						=					params[base + 'out.bias']
		else:
			__snake_case     :				Tuple 						=					v
	return new_params
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[Any]     ,				UpperCAmelCase_       :							Tuple    )				->     str:

	'''simple docstring'''





	__snake_case     :				str 						=					CLIP(**UpperCAmelCase_    )
	torch_model.eval()
	__snake_case     :				Union[str, Any] 						=					torch_model.state_dict()

	__snake_case     :				List[Any] 						=					flatten_nested_dict(flax_params['backbone']['clip']    )
	__snake_case     :				Optional[int] 						=					{}

	for flax_key, v in flax_clip_params.items():
		__snake_case     :				Optional[Any] 						=					flax_key.replace('/'     ,				'.'    )
		__snake_case     :				int 						=					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'    )
		):
			__snake_case     :				Union[str, Any] 						=					torch_key[5:]

		__snake_case     :				Tuple 						=					torch_key.replace('text_projection.kernel'     ,				'text_projection'    )
		__snake_case     :				List[str] 						=					torch_key.replace('visual.proj.kernel'     ,				'visual.proj'    )
		__snake_case     :				Optional[Any] 						=					torch_key.replace('.scale'     ,				'.weight'    )
		__snake_case     :				List[str] 						=					torch_key.replace('.kernel'     ,				'.weight'    )

		if "conv" in torch_key or "downsample.0.weight" in torch_key:
			__snake_case     :				Optional[int] 						=					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
			__snake_case     :				Dict 						=					v.T

		__snake_case     :				Union[str, Any] 						=					v

	__snake_case     :				Union[str, Any] 						=					_convert_attn_layers(UpperCAmelCase_    )
	new_torch_params.update(UpperCAmelCase_    )
	__snake_case     :				Dict 						=					{}

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

	return torch_clip_params, torch_model, attn_params
@torch.no_grad()
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[str]     ,				UpperCAmelCase_       :							Union[str, Any]     ,				UpperCAmelCase_       :							Optional[int]     ,				UpperCAmelCase_       :							Union[str, Any]     ,				UpperCAmelCase_       :							str=None    )				->     Any:

	'''simple docstring'''





	__snake_case     :				int 						=					Repository(UpperCAmelCase_     ,				clone_from=F"google/{pytorch_dump_folder_path}"    )
	repo.git_pull()

	if config_path is not None:
		__snake_case     :				Union[str, Any] 						=					OwlViTConfig.from_pretrained(UpperCAmelCase_    )
	else:
		__snake_case     :				Dict 						=					OwlViTConfig()

	__snake_case     :				Tuple 						=					OwlViTModel(UpperCAmelCase_    ).eval()
	__snake_case     :				Optional[int] 						=					OwlViTForObjectDetection(UpperCAmelCase_    ).eval()

	copy_text_model_and_projection(UpperCAmelCase_     ,				UpperCAmelCase_    )
	copy_vision_model_and_projection(UpperCAmelCase_     ,				UpperCAmelCase_    )
	__snake_case     :				List[Any] 						=					pt_backbone.logit_scale
	copy_flax_attn_params(UpperCAmelCase_     ,				UpperCAmelCase_    )

	__snake_case     :				Optional[int] 						=					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
	__snake_case     :				List[Any] 						=					OwlViTImageProcessor(
	    size=config.vision_config.image_size     ,				crop_size=config.vision_config.image_size    )
	# Initialize tokenizer
	__snake_case     :				Dict 						=					CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32'     ,				pad_token='!'     ,				model_max_length=16    )

	# Initialize processor
	__snake_case     :				str 						=					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__":
	_a	:	Optional[int]=					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	:	str=					parser.parse_args()

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

	# Load from checkpoint and convert params to float-32
	_a	:	str=					checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["optimizer"]["target"]
	_a	:	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
	_a,						_a,						_a	:	Union[str, Any]=					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"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							str    )				->     str:

	'''simple docstring'''





	return " ".join(sorted(set(sentence.split()    )    )    )


if __name__ == "__main__":
	import doctest

	doctest.testmod()





