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


__UpperCAmelCase												=   {
    "vit_b32": {
        "embed_dim": 512,
        "image_resolution": 768,
        "context_length": 16,
        "vocab_size": 4_9408,
        "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": 4_9408,
        "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": 4_9408,
        "vision_layers": 24,
        "vision_width": 1024,
        "vision_patch_size": 14,
        "transformer_width": 768,
        "transformer_heads": 12,
        "transformer_layers": 12,
    },
}



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str   ,     snake_case_				:	Union[str, Any]=""   ,     snake_case_				:	Optional[Any]="/"							)       ->	Union[str, Any]:
 SCREAMING_SNAKE_CASE  :  int								=		[]

 for k, v in params.items():
  SCREAMING_SNAKE_CASE  :  Tuple								=		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[int]							)       ->	Tuple:
 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_				:	List[Any]   ,     snake_case_				:	List[str]							)       ->	Dict:
 SCREAMING_SNAKE_CASE  :  Optional[int]								=		pt_attn_layer.in_proj_weight.chunk(3   ,     dim=0							)
 SCREAMING_SNAKE_CASE  :  Dict								=		pt_attn_layer.in_proj_bias.chunk(3   ,     dim=0							)

 SCREAMING_SNAKE_CASE  :  Optional[Any]								=		pt_attn_layer.out_proj.weight
 SCREAMING_SNAKE_CASE  :  str								=		pt_attn_layer.out_proj.bias

 SCREAMING_SNAKE_CASE  :  List[str]								=		q_proj
 SCREAMING_SNAKE_CASE  :  Dict								=		q_proj_bias

 SCREAMING_SNAKE_CASE  :  Tuple								=		k_proj
 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		k_proj_bias

 SCREAMING_SNAKE_CASE  :  Optional[int]								=		v_proj
 SCREAMING_SNAKE_CASE  :  Tuple								=		v_proj_bias

 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		out_proj_weights
 SCREAMING_SNAKE_CASE  :  Dict								=		out_proj_bias



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[int]   ,     snake_case_				:	List[str]							)       ->	Union[str, Any]:
 copy_linear(hf_mlp.fca   ,     pt_mlp.c_fc							)
 copy_linear(hf_mlp.fca   ,     pt_mlp.c_proj							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[int]   ,     snake_case_				:	Any							)       ->	str:
 SCREAMING_SNAKE_CASE  :  Dict								=		pt_linear.weight
 SCREAMING_SNAKE_CASE  :  Optional[int]								=		pt_linear.bias



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	List[str]   ,     snake_case_				:	Optional[Any]							)       ->	Dict:
 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_				:	Optional[Any]   ,     snake_case_				:	Optional[int]							)       ->	Tuple:



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



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[Any]   ,     snake_case_				:	str							)       ->	Dict:
 SCREAMING_SNAKE_CASE  :  List[Any]								=		pt_model.token_embedding.weight
 SCREAMING_SNAKE_CASE  :  Any								=		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_				:	Any   ,     snake_case_				:	int							)       ->	Optional[Any]:
 SCREAMING_SNAKE_CASE  :  List[Any]								=		pt_model.text_projection.data.T

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



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str   ,     snake_case_				:	int							)       ->	Optional[Any]:
 SCREAMING_SNAKE_CASE  :  int								=		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
 SCREAMING_SNAKE_CASE  :  str								=		pt_model.visual.conva.weight.data
 SCREAMING_SNAKE_CASE  :  Tuple								=		pt_model.visual.class_embedding
 SCREAMING_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        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Tuple   ,     snake_case_				:	Optional[Any]							)       ->	List[str]:
 SCREAMING_SNAKE_CASE  :  Any								=		flatten_nested_dict(flax_params['backbone']['merged_class_token']							)

 SCREAMING_SNAKE_CASE  :  Any								=		torch.from_numpy(flax_class_token_params['scale']							)
 SCREAMING_SNAKE_CASE  :  int								=		torch.from_numpy(flax_class_token_params['bias']							)
 SCREAMING_SNAKE_CASE  :  Any								=		nn.Parameter(snake_case_							)
 SCREAMING_SNAKE_CASE  :  Any								=		nn.Parameter(snake_case_							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[Any]   ,     snake_case_				:	Optional[int]							)       ->	str:
 SCREAMING_SNAKE_CASE  :  List[str]								=		hf_model.state_dict()
 SCREAMING_SNAKE_CASE  :  Tuple								=		{}

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

 for flax_key, v in flax_class_params.items():
  SCREAMING_SNAKE_CASE  :  List[Any]								=		flax_key.replace('/'   ,     '.'							)
  SCREAMING_SNAKE_CASE  :  str								=		torch_key.replace('.kernel'   ,     '.weight'							)
  SCREAMING_SNAKE_CASE  :  List[str]								=		torch_key.replace('Dense_0'   ,     'dense0'							)
  SCREAMING_SNAKE_CASE  :  Optional[int]								=		'''class_head.''' + torch_key

  if "weight" in torch_key and v.ndim == 2:
   SCREAMING_SNAKE_CASE  :  List[str]								=		v.T

  SCREAMING_SNAKE_CASE  :  int								=		nn.Parameter(torch.from_numpy(snake_case_							)							)

 # Rename box prediction box flax params to pytorch HF
 SCREAMING_SNAKE_CASE  :  Optional[int]								=		flatten_nested_dict(flax_params['obj_box_head']							)

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

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

  SCREAMING_SNAKE_CASE  :  List[Any]								=		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_				:	List[str]   ,     snake_case_				:	Any							)       ->	Optional[Any]:



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

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

  if "bias" in torch_key and v.ndim == 2:
   SCREAMING_SNAKE_CASE  :  Tuple								=		v.shape[0] * v.shape[1]
   SCREAMING_SNAKE_CASE  :  Optional[Any]								=		v.reshape(snake_case_							)

  if "weight" in torch_key and "out" in torch_key:
   SCREAMING_SNAKE_CASE  :  Optional[Any]								=		(v.shape[0] * v.shape[1], v.shape[2])
   SCREAMING_SNAKE_CASE  :  Optional[int]								=		v.reshape(snake_case_							).T

  if "weight" in torch_key and "out" not in torch_key:
   SCREAMING_SNAKE_CASE  :  List[str]								=		(v.shape[0], v.shape[1] * v.shape[2])
   SCREAMING_SNAKE_CASE  :  Dict								=		v.reshape(snake_case_							).T

  # Copy flax CLIP attn params to HF PyTorch params
  SCREAMING_SNAKE_CASE  :  Optional[int]								=		torch.from_numpy(snake_case_							)
  hf_backbone.state_dict()[torch_key].copy_(snake_case_							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[int]							)       ->	Optional[Any]:
 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		{}
 SCREAMING_SNAKE_CASE  :  List[str]								=		[]

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

   processed_attn_layers.append(snake_case_							)
   SCREAMING_SNAKE_CASE  :  Optional[int]								=		params[base + '''out.weight'''].shape[-1]
   SCREAMING_SNAKE_CASE  :  Dict								=		params[base + '''out.weight'''].reshape(snake_case_   ,     snake_case_							).T
   SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		params[base + '''out.bias''']
  else:
   SCREAMING_SNAKE_CASE  :  List[Any]								=		v
 return new_params



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	List[str]   ,     snake_case_				:	List[Any]							)       ->	List[str]:
 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		CLIP(**snake_case_							)
 torch_model.eval()
 SCREAMING_SNAKE_CASE  :  Optional[int]								=		torch_model.state_dict()

 SCREAMING_SNAKE_CASE  :  int								=		flatten_nested_dict(flax_params['backbone']['clip']							)
 SCREAMING_SNAKE_CASE  :  Tuple								=		{}

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

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

  if "conv" in torch_key or "downsample.0.weight" in torch_key:
   SCREAMING_SNAKE_CASE  :  List[Any]								=		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
   SCREAMING_SNAKE_CASE  :  Tuple								=		v.T

  SCREAMING_SNAKE_CASE  :  List[Any]								=		v

 SCREAMING_SNAKE_CASE  :  int								=		_convert_attn_layers(snake_case_							)
 new_torch_params.update(snake_case_							)
 SCREAMING_SNAKE_CASE  :  str								=		{}

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

 return torch_clip_params, torch_model, attn_params



@torch.no_grad()
def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	Optional[int]   ,     snake_case_				:	Any   ,     snake_case_				:	str   ,     snake_case_				:	List[str]   ,     snake_case_				:	Tuple=None							)       ->	List[str]:
 SCREAMING_SNAKE_CASE  :  Dict								=		Repository(snake_case_   ,     clone_from=f"""google/{pytorch_dump_folder_path}"""							)
 repo.git_pull()

 if config_path is not None:
  SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		OwlViTConfig.from_pretrained(snake_case_							)
 else:
  SCREAMING_SNAKE_CASE  :  Any								=		OwlViTConfig()

 SCREAMING_SNAKE_CASE  :  Any								=		OwlViTModel(snake_case_							).eval()
 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		OwlViTForObjectDetection(snake_case_							).eval()

 copy_text_model_and_projection(snake_case_   ,     snake_case_							)
 copy_vision_model_and_projection(snake_case_   ,     snake_case_							)
 SCREAMING_SNAKE_CASE  :  Dict								=		pt_backbone.logit_scale
 copy_flax_attn_params(snake_case_   ,     snake_case_							)

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

 # Initialize processor
 SCREAMING_SNAKE_CASE  :  Any								=		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__":
   __UpperCAmelCase												=   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.'
   )
   __UpperCAmelCase												=   parser.parse_args()

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

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

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

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






from hashlib import mda, shaaaa

__UpperCamelCase							:							Dict    							=					(shaaaa, mda)

class    __magic_name__						:


     def __init__(   self				:  Optional[Any]				,						lowerCamelCase__				:  int = 8      )	->   None:





      '''simple docstring'''






      UpperCamelCase__       :     int 							= 0b0
      UpperCamelCase__       :     Optional[int] 							= size


     def   UpperCAmelCase__						(   self				:  Tuple				,						lowerCamelCase__				:  str      )	->   None:





      '''simple docstring'''






      UpperCamelCase__       :     Union[str, Any] 							= self.hash_(lowerCamelCase__      )
      self.bitarray |= h


     def   UpperCAmelCase__						(   self				:  Any				,						lowerCamelCase__				:  str      )	->   bool:





      '''simple docstring'''






      UpperCamelCase__       :     Any 							= self.hash_(lowerCamelCase__      )
      return (h & self.bitarray) == h


     def __contains__(   self				:  Any				,						lowerCamelCase__				:  str      )	->   bool:





      '''simple docstring'''






      return self.exists(lowerCamelCase__      )


     def   UpperCAmelCase__						(   self				:  Union[str, Any]				,						lowerCamelCase__				:  int      )	->   str:





      '''simple docstring'''






      UpperCamelCase__       :     Optional[int] 							= bin(lowerCamelCase__      )[2:]
      return res.zfill(self.size      )


     @property
     def   UpperCAmelCase__						(   self				:  Tuple      )	->   str:





      '''simple docstring'''






      return self.format_bin(self.bitarray      )


     def   UpperCAmelCase__						(   self				:  int				,						lowerCamelCase__				:  str      )	->   int:





      '''simple docstring'''






      UpperCamelCase__       :     Union[str, Any] 							= 0b0
      for func in HASH_FUNCTIONS:
       UpperCamelCase__       :     Optional[Any] 							= (
           int.from_bytes(func(value.encode()      ).digest()				,						'''little'''      ) % self.size
       )
       res |= 2**position
      return res


     def   UpperCAmelCase__						(   self				:  Union[str, Any]				,						lowerCamelCase__				:  str      )	->   str:





      '''simple docstring'''






      return self.format_bin(self.hash_(lowerCamelCase__      )      )


     @property
     def   UpperCAmelCase__						(   self				:  str      )	->   float:





      '''simple docstring'''






      UpperCamelCase__       :     Tuple 							= bin(self.bitarray      ).count('''1'''      )
      return (n_ones / self.size) ** len(lowerCamelCase__      )


