


'''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""": 49408,
        """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""": 49408,
        """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""": 49408,
        """vision_layers""": 24,
        """vision_width""": 1024,
        """vision_patch_size""": 14,
        """transformer_width""": 768,
        """transformer_heads""": 12,
        """transformer_layers""": 12,
    },
}





def __snake_case (				UpperCAmelCase_						:						Optional[int] ,    UpperCAmelCase_						:						Dict="" ,    UpperCAmelCase_						:						int="/"		):
 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 __snake_case (				UpperCAmelCase_						:						Tuple		):
 return jax.tree_util.tree_map(lambda UpperCAmelCase_		: x.astype(jnp.floataa		) if x.dtype == jnp.bfloataa else x ,    UpperCAmelCase_		)





def __snake_case (				UpperCAmelCase_						:						Tuple ,    UpperCAmelCase_						:						List[str]		):
 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 __snake_case (				UpperCAmelCase_						:						Tuple ,    UpperCAmelCase_						:						List[str]		):
 copy_linear(hf_mlp.fca ,    pt_mlp.c_fc		)
 copy_linear(hf_mlp.fca ,    pt_mlp.c_proj		)





def __snake_case (				UpperCAmelCase_						:						List[str] ,    UpperCAmelCase_						:						Optional[int]		):
 lowerCamelCase_								=  pt_linear.weight
 lowerCamelCase_								=  pt_linear.bias





def __snake_case (				UpperCAmelCase_						:						int ,    UpperCAmelCase_						:						Tuple		):
 # 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 __snake_case (				UpperCAmelCase_						:						str ,    UpperCAmelCase_						:						Dict		):
 for hf_layer, pt_layer in zip(UpperCAmelCase_ ,    UpperCAmelCase_		):
  copy_layer(UpperCAmelCase_ ,    UpperCAmelCase_		)





def __snake_case (				UpperCAmelCase_						:						Any ,    UpperCAmelCase_						:						List[Any]		):
 # 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 __snake_case (				UpperCAmelCase_						:						Any ,    UpperCAmelCase_						:						Optional[Any]		):
 # copy projection
 lowerCamelCase_								=  pt_model.text_projection.data.T

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





def __snake_case (				UpperCAmelCase_						:						Dict ,    UpperCAmelCase_						:						str		):
 # 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 __snake_case (				UpperCAmelCase_						:						str ,    UpperCAmelCase_						:						Union[str, 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(UpperCAmelCase_		)
 lowerCamelCase_								=  nn.Parameter(UpperCAmelCase_		)





def __snake_case (				UpperCAmelCase_						:						Any ,    UpperCAmelCase_						:						Tuple		):
 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 __snake_case (				UpperCAmelCase_						:						Optional[Any] ,    UpperCAmelCase_						:						Optional[int]		):
 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 __snake_case (				UpperCAmelCase_						:						Union[str, Any]		):
 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 __snake_case (				UpperCAmelCase_						:						List[str] ,    UpperCAmelCase_						:						List[str]		):
 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 __snake_case (				UpperCAmelCase_						:						Optional[Any] ,    UpperCAmelCase_						:						str ,    UpperCAmelCase_						:						Tuple ,    UpperCAmelCase_						:						List[Any] ,    UpperCAmelCase_						:						List[Any]=None		):
 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__":
     a_  :    Dict      =			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_  :    List[str]      =			parser.parse_args()

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

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

import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
     import tensorflow as tf

     from transformers.activations_tf import get_tf_activation





@require_tf
class 					snake_case   (   unittest.TestCase      ):





  """simple docstring"""




  def   snake_case		(   self					):







   """simple docstring"""
   lowerCamelCase_								=  tf.constant([-100, -1.0, -0.1, 0, 0.1, 1.0, 100.0]					)
   lowerCamelCase_								=  get_tf_activation("gelu"					)
   lowerCamelCase_								=  get_tf_activation("gelu_10"					)

   lowerCamelCase_								=  gelu(UpperCamelCase					)
   lowerCamelCase_								=  geluaa(UpperCamelCase					)

   lowerCamelCase_								=  tf.where(y_gelu_aa < 10.0      ,  1.0      ,  0.0					)

   self.assertEqual(tf.math.reduce_max(UpperCamelCase					).numpy().item()      ,  10.0					)
   self.assertTrue(np.allclose(y_gelu * clipped_mask      ,  y_gelu_aa * clipped_mask					)					)







  def   snake_case		(   self					):







   """simple docstring"""
   get_tf_activation("gelu"					)
   get_tf_activation("gelu_10"					)
   get_tf_activation("gelu_fast"					)
   get_tf_activation("gelu_new"					)
   get_tf_activation("glu"					)
   get_tf_activation("mish"					)
   get_tf_activation("quick_gelu"					)
   get_tf_activation("relu"					)
   get_tf_activation("sigmoid"					)
   get_tf_activation("silu"					)
   get_tf_activation("swish"					)
   get_tf_activation("tanh"					)
   with self.assertRaises(UpperCamelCase					):
    get_tf_activation("bogus"					)
   with self.assertRaises(UpperCamelCase					):
    get_tf_activation(UpperCamelCase					)



