code: 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,
  )
  
  
  lowercase__    :       Optional[Any]						=			{
      '''vit_b32''': {
          '''embed_dim''': 5_1_2,
          '''image_resolution''': 7_6_8,
          '''context_length''': 1_6,
          '''vocab_size''': 4_9_4_0_8,
          '''vision_layers''': 1_2,
          '''vision_width''': 7_6_8,
          '''vision_patch_size''': 3_2,
          '''transformer_width''': 5_1_2,
          '''transformer_heads''': 8,
          '''transformer_layers''': 1_2,
      },
      '''vit_b16''': {
          '''embed_dim''': 5_1_2,
          '''image_resolution''': 7_6_8,
          '''context_length''': 1_6,
          '''vocab_size''': 4_9_4_0_8,
          '''vision_layers''': 1_2,
          '''vision_width''': 7_6_8,
          '''vision_patch_size''': 1_6,
          '''transformer_width''': 5_1_2,
          '''transformer_heads''': 8,
          '''transformer_layers''': 1_2,
      },
      '''vit_l14''': {
          '''embed_dim''': 7_6_8,
          '''image_resolution''': 8_4_0,
          '''context_length''': 1_6,
          '''vocab_size''': 4_9_4_0_8,
          '''vision_layers''': 2_4,
          '''vision_width''': 1_0_2_4,
          '''vision_patch_size''': 1_4,
          '''transformer_width''': 7_6_8,
          '''transformer_heads''': 1_2,
          '''transformer_layers''': 1_2,
      },
  }
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__=""     ,						snake_case__="/"							)  ->			str:
  							lowerCAmelCase				=	[]
  
  							for k, v in params.items():
  														lowerCAmelCase				=	parent_key + sep + k if parent_key else k
  
  														if isinstance(snake_case__     ,						collections.MutableMapping							):
  																					items.extend(flatten_nested_dict(snake_case__     ,						snake_case__     ,						sep=snake_case__							).items()							)
  														else:
  																					items.append((new_key, v)							)
  							return dict(snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__							)  ->			Optional[Any]:
  							return jax.tree_util.tree_map(lambda snake_case__							: x.astype(jnp.floataa							) if x.dtype == jnp.bfloataa else x     ,						snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			int:
  							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      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			int:
  							copy_linear(hf_mlp.fca     ,						pt_mlp.c_fc							)
  							copy_linear(hf_mlp.fca     ,						pt_mlp.c_proj							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			int:
  							lowerCAmelCase				=	pt_linear.weight
  							lowerCAmelCase				=	pt_linear.bias
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Optional[int]:
  							# copy layer norms
  							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      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Any:
  							for hf_layer, pt_layer in zip(snake_case__     ,						snake_case__							):
  														copy_layer(snake_case__     ,						snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			int:
  							# copy  embeds
  							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      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Optional[int]:
  							# copy projection
  							lowerCAmelCase				=	pt_model.text_projection.data.T
  
  							# copy text encoder
  							copy_encoder(hf_model.text_model     ,						snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Any:
  							# copy projection
  							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      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Any:
  							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(snake_case__							)
  							lowerCAmelCase				=	nn.Parameter(snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Dict:
  							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(snake_case__							)							)
  
  							# 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(snake_case__							)							)
  
  							# Copy flax params to PyTorch params
  							for name, param in new_params.items():
  														if name in pt_params.keys():
  																					pt_params[name].copy_(snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			Dict:
  							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(snake_case__							)
  
  														if "weight" in torch_key and "out" in torch_key:
  																					lowerCAmelCase				=	(v.shape[0] * v.shape[1], v.shape[2])
  																					lowerCAmelCase				=	v.reshape(snake_case__							).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(snake_case__							).T
  
  														# Copy flax CLIP attn params to HF PyTorch params
  														lowerCAmelCase				=	torch.from_numpy(snake_case__							)
  														hf_backbone.state_dict()[torch_key].copy_(snake_case__							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__							)  ->			List[str]:
  							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(snake_case__							)
  																					lowerCAmelCase				=	params[base + '''out.weight'''].shape[-1]
  																					lowerCAmelCase				=	params[base + '''out.weight'''].reshape(snake_case__     ,						snake_case__							).T
  																					lowerCAmelCase				=	params[base + '''out.bias''']
  														else:
  																					lowerCAmelCase				=	v
  							return new_params
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			str:
  							lowerCAmelCase				=	CLIP(**snake_case__							)
  							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(snake_case__							)
  							new_torch_params.update(snake_case__							)
  							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_(snake_case__							)
  														else:
  																					lowerCAmelCase				=	param
  
  							return torch_clip_params, torch_model, attn_params
  
  @torch.no_grad()
  def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__     ,						snake_case__     ,						snake_case__     ,						snake_case__=None							)  ->			Optional[Any]:
  							lowerCAmelCase				=	Repository(snake_case__     ,						clone_from=f"google/{pytorch_dump_folder_path}"							)
  							repo.git_pull()
  
  							if config_path is not None:
  														lowerCAmelCase				=	OwlViTConfig.from_pretrained(snake_case__							)
  							else:
  														lowerCAmelCase				=	OwlViTConfig()
  
  							lowerCAmelCase				=	OwlViTModel(snake_case__							).eval()
  							lowerCAmelCase				=	OwlViTForObjectDetection(snake_case__							).eval()
  
  							copy_text_model_and_projection(snake_case__     ,						snake_case__							)
  							copy_vision_model_and_projection(snake_case__     ,						snake_case__							)
  							lowerCAmelCase				=	pt_backbone.logit_scale
  							copy_flax_attn_params(snake_case__     ,						snake_case__							)
  
  							lowerCAmelCase				=	hf_backbone
  							copy_class_merge_token(snake_case__     ,						snake_case__							)
  							copy_class_box_heads(snake_case__     ,						snake_case__							)
  
  							# 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=1_6							)
  
  							# Initialize processor
  							lowerCAmelCase				=	OwlViTProcessor(image_processor=snake_case__     ,						tokenizer=snake_case__							)
  							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__":
  	lowercase__    :       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.'''
  	)
  	lowercase__    :       str						=			parser.parse_args()
  
  	# Initialize PyToch clip model
  	lowercase__    :       Union[str, Any]						=			args.owlvit_version
  	if model_name == "clip_b16":
  		lowercase__    :       Union[str, Any]						=			CONFIGS['''vit_b16''']
  	elif model_name == "clip_b32":
  		lowercase__    :       Optional[Any]						=			CONFIGS['''vit_b32''']
  	elif model_name == "clip_l14":
  		lowercase__    :       str						=			CONFIGS['''vit_l14''']
  
  	# Load from checkpoint and convert params to float-32
  	lowercase__    :       List[str]						=			checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)['''optimizer''']['''target''']
  	lowercase__    :       Dict						=			jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
  	del variables
  
  	# Convert CLIP backbone
  	lowercase__			,					lowercase__			,					lowercase__    :       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)
  
  
  
  
style_context: import math
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__							)  ->			float:
  							lowerCAmelCase				=	math.log(2     ,						1_0							) * number
  							lowerCAmelCase				=	round((log_number - int(snake_case__							))     ,						1_5							)
  
  							return difference
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__ = 6_7_8_9_1_0							)  ->			int:
  							lowerCAmelCase				=	9_0
  							lowerCAmelCase				=	0
  
  							lowerCAmelCase				=	math.log(1.23     ,						1_0							)
  							lowerCAmelCase				=	math.log(1.24     ,						1_0							)
  							lowerCAmelCase				=	0
  
  							while position < number:
  														lowerCAmelCase				=	log_difference(snake_case__							)
  
  														if difference >= upper_limit:
  																					power_iterator += 9_3
  
  														elif difference < lower_limit:
  																					power_iterator += 1_9_6
  
  														else:
  																					lowerCAmelCase				=	power_iterator
  																					power_iterator += 1_9_6
  																					position += 1
  
  							return previous_power
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  	print(f'{solution() = }')
  
  
  
  