


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


lowerCamelCase_     :     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 _A		(		lowercase ,					lowercase="" ,					lowercase="/"	):







    """simple docstring"""
    a					=[]

    for k, v in params.items():
        a					=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 _A		(		lowercase	):







    """simple docstring"""
    return jax.tree_util.tree_map(lambda lowercase	: x.astype(jnp.floataa	) if x.dtype == jnp.bfloataa else x ,					snake_case__	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    a	,   a	,   a					=pt_attn_layer.in_proj_weight.chunk(3 ,					dim=0	)
    a	,   a	,   a					=pt_attn_layer.in_proj_bias.chunk(3 ,					dim=0	)

    a					=pt_attn_layer.out_proj.weight
    a					=pt_attn_layer.out_proj.bias

    a					=q_proj
    a					=q_proj_bias

    a					=k_proj
    a					=k_proj_bias

    a					=v_proj
    a					=v_proj_bias

    a					=out_proj_weights
    a					=out_proj_bias
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    copy_linear(hf_mlp.fca ,					pt_mlp.c_fc	)
    copy_linear(hf_mlp.fca ,					pt_mlp.c_proj	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    a					=pt_linear.weight
    a					=pt_linear.bias
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    # 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 _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    for hf_layer, pt_layer in zip(snake_case__ ,					snake_case__	):
        copy_layer(snake_case__ ,					snake_case__	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    # copy  embeds
    a					=pt_model.token_embedding.weight
    a					=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 _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    # copy projection
    a					=pt_model.text_projection.data.T

    # copy text encoder
    copy_encoder(hf_model.text_model ,					snake_case__	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    # copy projection
    a					=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
    a					=pt_model.visual.conva.weight.data
    a					=pt_model.visual.class_embedding
    a					=pt_model.visual.positional_embedding.data

    # copy encoder
    copy_layers(hf_model.vision_model.encoder.layers ,					pt_model.visual.transformer.resblocks	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    a					=flatten_nested_dict(flax_params['''backbone''']['''merged_class_token''']	)

    a					=torch.from_numpy(flax_class_token_params['''scale''']	)
    a					=torch.from_numpy(flax_class_token_params['''bias''']	)
    a					=nn.Parameter(snake_case__	)
    a					=nn.Parameter(snake_case__	)
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    a					=hf_model.state_dict()
    a					={}

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

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

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

        a					=nn.Parameter(torch.from_numpy(snake_case__	)	)

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

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

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

        a					=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 _A		(		lowercase ,					lowercase	):







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

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

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

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

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

        # Copy flax CLIP attn params to HF PyTorch params
        a					=torch.from_numpy(snake_case__	)
        hf_backbone.state_dict()[torch_key].copy_(snake_case__	)
def _A		(		lowercase	):







    """simple docstring"""
    a					={}
    a					=[]

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

            processed_attn_layers.append(snake_case__	)
            a					=params[base + '''out.weight'''].shape[-1]
            a					=params[base + '''out.weight'''].reshape(snake_case__ ,					snake_case__	).T
            a					=params[base + '''out.bias''']
        else:
            a					=v
    return new_params
def _A		(		lowercase ,					lowercase	):







    """simple docstring"""
    a					=CLIP(**snake_case__	)
    torch_model.eval()
    a					=torch_model.state_dict()

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

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

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

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

        a					=v

    a					=_convert_attn_layers(snake_case__	)
    new_torch_params.update(snake_case__	)
    a					={}

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

    return torch_clip_params, torch_model, attn_params
@torch.no_grad()
def _A		(		lowercase ,					lowercase ,					lowercase ,					lowercase ,					lowercase=None	):







    """simple docstring"""
    a					=Repository(snake_case__ ,					clone_from=f'''google/{pytorch_dump_folder_path}'''	)
    repo.git_pull()

    if config_path is not None:
        a					=OwlViTConfig.from_pretrained(snake_case__	)
    else:
        a					=OwlViTConfig()

    a					=OwlViTModel(snake_case__	).eval()
    a					=OwlViTForObjectDetection(snake_case__	).eval()

    copy_text_model_and_projection(snake_case__ ,					snake_case__	)
    copy_vision_model_and_projection(snake_case__ ,					snake_case__	)
    a					=pt_backbone.logit_scale
    copy_flax_attn_params(snake_case__ ,					snake_case__	)

    a					=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
    a					=OwlViTImageProcessor(
        size=config.vision_config.image_size ,					crop_size=config.vision_config.image_size	)
    # Initialize tokenizer
    a					=CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32''' ,					pad_token='''!''' ,					model_max_length=16	)

    # Initialize processor
    a					=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__":
       lowerCamelCase_     :     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."""
       )
       lowerCamelCase_     :     str    		=						parser.parse_args()

       # Initialize PyToch clip model
       lowerCamelCase_     :     Union[str, Any]    		=						args.owlvit_version
       if model_name == "clip_b16":
              lowerCamelCase_     :     Union[str, Any]    		=						CONFIGS['''vit_b16''']
       elif model_name == "clip_b32":
              lowerCamelCase_     :     Optional[Any]    		=						CONFIGS['''vit_b32''']
       elif model_name == "clip_l14":
              lowerCamelCase_     :     str    		=						CONFIGS['''vit_l14''']

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







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase_     :     Any    		=						logging.get_logger(__name__)

lowerCamelCase_     :     Tuple    		=						{
    """apple/mobilevitv2-1.0""": """https://huggingface.co/apple/mobilevitv2-1.0/resolve/main/config.json""",
}






class    __A       ( _SCREAMING_SNAKE_CASE    ):






 """simple docstring"""




 __lowerCAmelCase				      =						"mobilevitv2"


 def __init__(	self				,					__A=3				,					__A=256				,					__A=2				,					__A=2.0				,					__A="swish"				,					__A=3				,					__A=32				,					__A=0.1				,					__A=0.02				,					__A=1E-5				,					__A=512				,					__A=[6, 12, 18]				,					__A=0.1				,					__A=255				,					__A=[2, 4, 3]				,					__A=[128, 192, 256]				,					__A=1.0				,					__A=2				,					__A=0.0				,					__A=0.0				,					**__A				,					)      ->  int:
     super().__init__(**__A		)

     a					=num_channels
     a					=image_size
     a					=patch_size
     a					=expand_ratio
     a					=hidden_act
     a					=conv_kernel_size
     a					=output_stride
     a					=initializer_range
     a					=layer_norm_eps
     a					=n_attn_blocks
     a					=base_attn_unit_dims
     a					=width_multiplier
     a					=ffn_multiplier
     a					=ffn_dropout
     a					=attn_dropout
     a					=classifier_dropout_prob

     # decode head attributes for semantic segmentation
     a					=aspp_out_channels
     a					=atrous_rates
     a					=aspp_dropout_prob
     a					=semantic_loss_ignore_index






class    __A       ( _SCREAMING_SNAKE_CASE    ):






 """simple docstring"""




 __lowerCAmelCase				      =						version.parse("1.11"    )


 @property
 def    SCREAMING_SNAKE_CASE							(	self		)      ->  Mapping[str, Mapping[int, str]]:
     return OrderedDict([('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''})]		)


 @property
 def    SCREAMING_SNAKE_CASE							(	self		)      ->  Mapping[str, Mapping[int, str]]:
     if self.task == "image-classification":
         return OrderedDict([('''logits''', {0: '''batch'''})]		)
     else:
         return OrderedDict([('''last_hidden_state''', {0: '''batch'''}), ('''pooler_output''', {0: '''batch'''})]		)





 @property
 def    SCREAMING_SNAKE_CASE							(	self		)      ->  float:
     return 1E-4