




'''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				: int					      =			{
    """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 							snake_case_    (  a__						:      List[Any]       ,a__						:      Dict=""       ,a__						:      Dict="/"     ):



    """simple docstring"""




    __lowercase     							=		[]

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

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



    """simple docstring"""




    return jax.tree_util.tree_map(lambda a__     : x.astype(jnp.floataa     ) if x.dtype == jnp.bfloataa else x       ,a__     )
def 							snake_case_    (  a__						:      Union[str, Any]       ,a__						:      Any     ):



    """simple docstring"""




    __lowercase							,__lowercase							,__lowercase     							=		pt_attn_layer.in_proj_weight.chunk(3       ,dim=0     )
    __lowercase							,__lowercase							,__lowercase     							=		pt_attn_layer.in_proj_bias.chunk(3       ,dim=0     )

    __lowercase     							=		pt_attn_layer.out_proj.weight
    __lowercase     							=		pt_attn_layer.out_proj.bias

    __lowercase     							=		q_proj
    __lowercase     							=		q_proj_bias

    __lowercase     							=		k_proj
    __lowercase     							=		k_proj_bias

    __lowercase     							=		v_proj
    __lowercase     							=		v_proj_bias

    __lowercase     							=		out_proj_weights
    __lowercase     							=		out_proj_bias
def 							snake_case_    (  a__						:      Dict       ,a__						:      List[Any]     ):



    """simple docstring"""




    copy_linear(hf_mlp.fca       ,pt_mlp.c_fc     )
    copy_linear(hf_mlp.fca       ,pt_mlp.c_proj     )
def 							snake_case_    (  a__						:      Dict       ,a__						:      Union[str, Any]     ):



    """simple docstring"""




    __lowercase     							=		pt_linear.weight
    __lowercase     							=		pt_linear.bias
def 							snake_case_    (  a__						:      List[str]       ,a__						:      Optional[Any]     ):



    """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 							snake_case_    (  a__						:      Optional[Any]       ,a__						:      int     ):



    """simple docstring"""




    for hf_layer, pt_layer in zip(a__       ,a__     ):
        copy_layer(a__       ,a__     )
def 							snake_case_    (  a__						:      List[Any]       ,a__						:      List[Any]     ):



    """simple docstring"""




    __lowercase     							=		pt_model.token_embedding.weight
    __lowercase     							=		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_    (  a__						:      Tuple       ,a__						:      Dict     ):



    """simple docstring"""




    __lowercase     							=		pt_model.text_projection.data.T

    # copy text encoder
    copy_encoder(hf_model.text_model       ,a__     )
def 							snake_case_    (  a__						:      List[str]       ,a__						:      Optional[Any]     ):



    """simple docstring"""




    __lowercase     							=		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
    __lowercase     							=		pt_model.visual.conva.weight.data
    __lowercase     							=		pt_model.visual.class_embedding
    __lowercase     							=		pt_model.visual.positional_embedding.data

    # copy encoder
    copy_layers(hf_model.vision_model.encoder.layers       ,pt_model.visual.transformer.resblocks     )
def 							snake_case_    (  a__						:      Any       ,a__						:      int     ):



    """simple docstring"""




    __lowercase     							=		flatten_nested_dict(flax_params["""backbone"""]["""merged_class_token"""]     )

    __lowercase     							=		torch.from_numpy(flax_class_token_params["""scale"""]     )
    __lowercase     							=		torch.from_numpy(flax_class_token_params["""bias"""]     )
    __lowercase     							=		nn.Parameter(a__     )
    __lowercase     							=		nn.Parameter(a__     )
def 							snake_case_    (  a__						:      Union[str, Any]       ,a__						:      Any     ):



    """simple docstring"""




    __lowercase     							=		hf_model.state_dict()
    __lowercase     							=		{}

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

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

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

        __lowercase     							=		nn.Parameter(torch.from_numpy(a__     )     )

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

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

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

        __lowercase     							=		nn.Parameter(torch.from_numpy(a__     )     )

    # Copy flax params to PyTorch params
    for name, param in new_params.items():
        if name in pt_params.keys():
            pt_params[name].copy_(a__     )
def 							snake_case_    (  a__						:      List[Any]       ,a__						:      List[str]     ):



    """simple docstring"""




    for k, v in flax_attn_params.items():
        if k.startswith("""transformer"""     ):
            __lowercase     							=		k.replace("""transformer.resblocks"""       ,"""text_model.encoder.layers"""     )
        else:
            __lowercase     							=		k.replace("""visual.transformer.resblocks"""       ,"""vision_model.encoder.layers"""     )

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

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

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

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

        # Copy flax CLIP attn params to HF PyTorch params
        __lowercase     							=		torch.from_numpy(a__     )
        hf_backbone.state_dict()[torch_key].copy_(a__     )
def 							snake_case_    (  a__						:      Dict     ):



    """simple docstring"""




    __lowercase     							=		{}
    __lowercase     							=		[]

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

            processed_attn_layers.append(a__     )
            __lowercase     							=		params[base + """out.weight"""].shape[-1]
            __lowercase     							=		params[base + """out.weight"""].reshape(a__       ,a__     ).T
            __lowercase     							=		params[base + """out.bias"""]
        else:
            __lowercase     							=		v
    return new_params
def 							snake_case_    (  a__						:      Tuple       ,a__						:      Dict     ):



    """simple docstring"""




    __lowercase     							=		CLIP(**a__     )
    torch_model.eval()
    __lowercase     							=		torch_model.state_dict()

    __lowercase     							=		flatten_nested_dict(flax_params["""backbone"""]["""clip"""]     )
    __lowercase     							=		{}

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

        __lowercase     							=		torch_key.replace("""text_projection.kernel"""       ,"""text_projection"""     )
        __lowercase     							=		torch_key.replace("""visual.proj.kernel"""       ,"""visual.proj"""     )
        __lowercase     							=		torch_key.replace(""".scale"""       ,""".weight"""     )
        __lowercase     							=		torch_key.replace(""".kernel"""       ,""".weight"""     )

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

        __lowercase     							=		v

    __lowercase     							=		_convert_attn_layers(a__     )
    new_torch_params.update(a__     )
    __lowercase     							=		{}

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

    return torch_clip_params, torch_model, attn_params
@torch.no_grad()
def 							snake_case_    (  a__						:      List[str]       ,a__						:      Union[str, Any]       ,a__						:      Optional[int]       ,a__						:      int       ,a__						:      List[Any]=None     ):



    """simple docstring"""




    __lowercase     							=		Repository(a__       ,clone_from=f'google/{pytorch_dump_folder_path}'     )
    repo.git_pull()

    if config_path is not None:
        __lowercase     							=		OwlViTConfig.from_pretrained(a__     )
    else:
        __lowercase     							=		OwlViTConfig()

    __lowercase     							=		OwlViTModel(a__     ).eval()
    __lowercase     							=		OwlViTForObjectDetection(a__     ).eval()

    copy_text_model_and_projection(a__       ,a__     )
    copy_vision_model_and_projection(a__       ,a__     )
    __lowercase     							=		pt_backbone.logit_scale
    copy_flax_attn_params(a__       ,a__     )

    __lowercase     							=		hf_backbone
    copy_class_merge_token(a__       ,a__     )
    copy_class_box_heads(a__       ,a__     )

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

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

    # Initialize processor
    __lowercase     							=		OwlViTProcessor(image_processor=a__       ,tokenizer=a__     )
    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				: Dict					      =			parser.parse_args()

  # Initialize PyToch clip model
  A				: int					      =			args.owlvit_version
  if model_name == "clip_b16":
    A				: Dict					      =			CONFIGS["""vit_b16"""]
  elif model_name == "clip_b32":
    A				: Union[str, Any]					      =			CONFIGS["""vit_b32"""]
  elif model_name == "clip_l14":
    A				: Tuple					      =			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[Any]					      =			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 							snake_case_    (  a__						:      int     ):



    """simple docstring"""




    __lowercase     							=		1
    __lowercase     							=		0
    __lowercase     							=		1
    __lowercase     							=		1
    __lowercase     							=		3
    __lowercase     							=		3
    __lowercase     							=		limit
    __lowercase     							=		0

    __lowercase     							=		""""""
    while counter != decimal + 1:
        if 4 * q + r - t < n * t:
            result += str(a__     )
            if counter == 0:
                result += "."

            if decimal == counter:
                break

            counter += 1
            __lowercase     							=		10 * (r - n * t)
            __lowercase     							=		((10 * (3 * q + r)) // t) - 10 * n
            q *= 10
            __lowercase     							=		nr
        else:
            __lowercase     							=		(2 * q + r) * l
            __lowercase     							=		(q * (7 * k) + 2 + (r * l)) // (t * l)
            q *= k
            t *= l
            l += 2
            k += 1
            __lowercase     							=		nn
            __lowercase     							=		nr
    return result
def 							snake_case_    (  ):



    """simple docstring"""




    print(f'{calculate_pi(50     ) = }'     )
    import doctest

    doctest.testmod()


if __name__ == "__main__":
  main()




