

'''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			:	Dict								=  {
    '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  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				Optional[int]=""    ,				SCREAMING_SNAKE_CASE :				Union[str, Any]="/"  ):
  UpperCAmelCase  							=		[]

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

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


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				str  ):
  return jax.tree_util.tree_map(lambda SCREAMING_SNAKE_CASE  : x.astype(jnp.floataa  ) if x.dtype == jnp.bfloataa else x    ,				SCREAMING_SNAKE_CASE  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				Dict  ):
  UpperCAmelCase							, UpperCAmelCase							, UpperCAmelCase  							=		pt_attn_layer.in_proj_weight.chunk(3    ,				dim=0  )
  UpperCAmelCase							, UpperCAmelCase							, UpperCAmelCase  							=		pt_attn_layer.in_proj_bias.chunk(3    ,				dim=0  )

  UpperCAmelCase  							=		pt_attn_layer.out_proj.weight
  UpperCAmelCase  							=		pt_attn_layer.out_proj.bias

  UpperCAmelCase  							=		q_proj
  UpperCAmelCase  							=		q_proj_bias

  UpperCAmelCase  							=		k_proj
  UpperCAmelCase  							=		k_proj_bias

  UpperCAmelCase  							=		v_proj
  UpperCAmelCase  							=		v_proj_bias

  UpperCAmelCase  							=		out_proj_weights
  UpperCAmelCase  							=		out_proj_bias


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Dict    ,				SCREAMING_SNAKE_CASE :				List[str]  ):
  copy_linear(hf_mlp.fca    ,				pt_mlp.c_fc  )
  copy_linear(hf_mlp.fca    ,				pt_mlp.c_proj  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				str    ,				SCREAMING_SNAKE_CASE :				Optional[int]  ):
  UpperCAmelCase  							=		pt_linear.weight
  UpperCAmelCase  							=		pt_linear.bias


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Tuple    ,				SCREAMING_SNAKE_CASE :				Any  ):
  # 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  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Optional[int]    ,				SCREAMING_SNAKE_CASE :				List[Any]  ):
  for hf_layer, pt_layer in zip(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  ):
    copy_layer(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[Any]    ,				SCREAMING_SNAKE_CASE :				Optional[Any]  ):
  # copy  embeds
  UpperCAmelCase  							=		pt_model.token_embedding.weight
  UpperCAmelCase  							=		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  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Tuple    ,				SCREAMING_SNAKE_CASE :				List[Any]  ):
  # copy projection
  UpperCAmelCase  							=		pt_model.text_projection.data.T

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


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Any    ,				SCREAMING_SNAKE_CASE :				Optional[int]  ):
  # copy projection
  UpperCAmelCase  							=		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
  UpperCAmelCase  							=		pt_model.visual.conva.weight.data
  UpperCAmelCase  							=		pt_model.visual.class_embedding
  UpperCAmelCase  							=		pt_model.visual.positional_embedding.data

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


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Any    ,				SCREAMING_SNAKE_CASE :				Dict  ):
  UpperCAmelCase  							=		flatten_nested_dict(flax_params['backbone']['merged_class_token']  )

  UpperCAmelCase  							=		torch.from_numpy(flax_class_token_params['scale']  )
  UpperCAmelCase  							=		torch.from_numpy(flax_class_token_params['bias']  )
  UpperCAmelCase  							=		nn.Parameter(SCREAMING_SNAKE_CASE  )
  UpperCAmelCase  							=		nn.Parameter(SCREAMING_SNAKE_CASE  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Optional[Any]    ,				SCREAMING_SNAKE_CASE :				Optional[Any]  ):
  UpperCAmelCase  							=		hf_model.state_dict()
  UpperCAmelCase  							=		{}

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

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

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

    UpperCAmelCase  							=		nn.Parameter(torch.from_numpy(SCREAMING_SNAKE_CASE  )  )

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

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

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

    UpperCAmelCase  							=		nn.Parameter(torch.from_numpy(SCREAMING_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_(SCREAMING_SNAKE_CASE  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[Any]    ,				SCREAMING_SNAKE_CASE :				Optional[int]  ):
  for k, v in flax_attn_params.items():
    if k.startswith('transformer'  ):
      UpperCAmelCase  							=		k.replace('transformer.resblocks'    ,				'text_model.encoder.layers'  )
    else:
      UpperCAmelCase  							=		k.replace('visual.transformer.resblocks'    ,				'vision_model.encoder.layers'  )

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

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

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

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

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


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[str]  ):
  UpperCAmelCase  							=		{}
  UpperCAmelCase  							=		[]

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

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


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Union[str, Any]    ,				SCREAMING_SNAKE_CASE :				Optional[Any]  ):
  UpperCAmelCase  							=		CLIP(**SCREAMING_SNAKE_CASE  )
  torch_model.eval()
  UpperCAmelCase  							=		torch_model.state_dict()

  UpperCAmelCase  							=		flatten_nested_dict(flax_params['backbone']['clip']  )
  UpperCAmelCase  							=		{}

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

    UpperCAmelCase  							=		torch_key.replace('text_projection.kernel'    ,				'text_projection'  )
    UpperCAmelCase  							=		torch_key.replace('visual.proj.kernel'    ,				'visual.proj'  )
    UpperCAmelCase  							=		torch_key.replace('.scale'    ,				'.weight'  )
    UpperCAmelCase  							=		torch_key.replace('.kernel'    ,				'.weight'  )

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

    UpperCAmelCase  							=		v

  UpperCAmelCase  							=		_convert_attn_layers(SCREAMING_SNAKE_CASE  )
  new_torch_params.update(SCREAMING_SNAKE_CASE  )
  UpperCAmelCase  							=		{}

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

  return torch_clip_params, torch_model, attn_params


@torch.no_grad()
def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Tuple    ,				SCREAMING_SNAKE_CASE :				Optional[Any]    ,				SCREAMING_SNAKE_CASE :				str    ,				SCREAMING_SNAKE_CASE :				str    ,				SCREAMING_SNAKE_CASE :				str=None  ):
  UpperCAmelCase  							=		Repository(SCREAMING_SNAKE_CASE    ,				clone_from=f'''google/{pytorch_dump_folder_path}'''  )
  repo.git_pull()

  if config_path is not None:
    UpperCAmelCase  							=		OwlViTConfig.from_pretrained(SCREAMING_SNAKE_CASE  )
  else:
    UpperCAmelCase  							=		OwlViTConfig()

  UpperCAmelCase  							=		OwlViTModel(SCREAMING_SNAKE_CASE  ).eval()
  UpperCAmelCase  							=		OwlViTForObjectDetection(SCREAMING_SNAKE_CASE  ).eval()

  copy_text_model_and_projection(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )
  copy_vision_model_and_projection(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )
  UpperCAmelCase  							=		pt_backbone.logit_scale
  copy_flax_attn_params(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )

  UpperCAmelCase  							=		hf_backbone
  copy_class_merge_token(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )
  copy_class_box_heads(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )

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

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

  # Initialize processor
  UpperCAmelCase  							=		OwlViTProcessor(image_processor=SCREAMING_SNAKE_CASE    ,				tokenizer=SCREAMING_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__":
  _a			:	Tuple								=  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			:	List[str]								=  CONFIGS['vit_b16']
  elif model_name == "clip_b32":
    _a			:	Optional[Any]								=  CONFIGS['vit_b32']
  elif model_name == "clip_l14":
    _a			:	Dict								=  CONFIGS['vit_l14']

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




def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				str  ):
  UpperCAmelCase  							=		str(SCREAMING_SNAKE_CASE  ).strip()
  if not bin_string:
    raise ValueError('Empty string was passed to the function'  )
  UpperCAmelCase  							=		bin_string[0] == '-'
  if is_negative:
    UpperCAmelCase  							=		bin_string[1:]
  if not all(char in '01' for char in bin_string  ):
    raise ValueError('Non-binary value was passed to the function'  )
  UpperCAmelCase  							=		0
  for char in bin_string:
    UpperCAmelCase  							=		2 * decimal_number + int(SCREAMING_SNAKE_CASE  )
  return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
  from doctest import testmod

  testmod()


