






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


__SCREAMING_SNAKE_CASE :  Any  =						{
    """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 			UpperCamelCase_							(      _UpperCAmelCase						:   List[Any]    ,			_UpperCAmelCase						:   Tuple=""    ,			_UpperCAmelCase						:   List[Any]="/"					)					->					List[str]:


       """simple docstring"""







       _UpperCAmelCase  :						List[str]							   =					[]

       for k, v in params.items():
              _UpperCAmelCase  :						Union[str, Any]							   =					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 			UpperCamelCase_							(      _UpperCAmelCase						:   List[Any]					)					->					int:


       """simple docstring"""







       return jax.tree_util.tree_map(lambda _UpperCAmelCase					: x.astype(jnp.floataa					) if x.dtype == jnp.bfloataa else x    ,			_UpperCAmelCase					)

def 			UpperCamelCase_							(      _UpperCAmelCase						:   str    ,			_UpperCAmelCase						:   int					)					->					int:


       """simple docstring"""







       _UpperCAmelCase  :						int							   =					pt_attn_layer.in_proj_weight.chunk(3    ,			dim=0					)
       _UpperCAmelCase  :						int							   =					pt_attn_layer.in_proj_bias.chunk(3    ,			dim=0					)

       _UpperCAmelCase  :						Tuple							   =					pt_attn_layer.out_proj.weight
       _UpperCAmelCase  :						Optional[int]							   =					pt_attn_layer.out_proj.bias

       _UpperCAmelCase  :						int							   =					q_proj
       _UpperCAmelCase  :						Optional[int]							   =					q_proj_bias

       _UpperCAmelCase  :						Optional[int]							   =					k_proj
       _UpperCAmelCase  :						Any							   =					k_proj_bias

       _UpperCAmelCase  :						Optional[int]							   =					v_proj
       _UpperCAmelCase  :						List[str]							   =					v_proj_bias

       _UpperCAmelCase  :						Optional[Any]							   =					out_proj_weights
       _UpperCAmelCase  :						Optional[int]							   =					out_proj_bias

def 			UpperCamelCase_							(      _UpperCAmelCase						:   Optional[int]    ,			_UpperCAmelCase						:   Any					)					->					Any:


       """simple docstring"""







       copy_linear(hf_mlp.fca    ,			pt_mlp.c_fc					)
       copy_linear(hf_mlp.fca    ,			pt_mlp.c_proj					)

def 			UpperCamelCase_							(      _UpperCAmelCase						:   List[Any]    ,			_UpperCAmelCase						:   Any					)					->					Dict:


       """simple docstring"""







       _UpperCAmelCase  :						Optional[int]							   =					pt_linear.weight
       _UpperCAmelCase  :						Optional[int]							   =					pt_linear.bias

def 			UpperCamelCase_							(      _UpperCAmelCase						:   int    ,			_UpperCAmelCase						:   Optional[int]					)					->					Tuple:


       """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 			UpperCamelCase_							(      _UpperCAmelCase						:   Union[str, Any]    ,			_UpperCAmelCase						:   int					)					->					Any:


       """simple docstring"""







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

def 			UpperCamelCase_							(      _UpperCAmelCase						:   Union[str, Any]    ,			_UpperCAmelCase						:   Dict					)					->					Union[str, Any]:


       """simple docstring"""







       _UpperCAmelCase  :						List[str]							   =					pt_model.token_embedding.weight
       _UpperCAmelCase  :						str							   =					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 			UpperCamelCase_							(      _UpperCAmelCase						:   int    ,			_UpperCAmelCase						:   List[Any]					)					->					Union[str, Any]:


       """simple docstring"""







       _UpperCAmelCase  :						Optional[int]							   =					pt_model.text_projection.data.T

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

def 			UpperCamelCase_							(      _UpperCAmelCase						:   List[Any]    ,			_UpperCAmelCase						:   Dict					)					->					Optional[int]:


       """simple docstring"""







       _UpperCAmelCase  :						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
       _UpperCAmelCase  :						Union[str, Any]							   =					pt_model.visual.conva.weight.data
       _UpperCAmelCase  :						Tuple							   =					pt_model.visual.class_embedding
       _UpperCAmelCase  :						Any							   =					pt_model.visual.positional_embedding.data

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

def 			UpperCamelCase_							(      _UpperCAmelCase						:   List[str]    ,			_UpperCAmelCase						:   Union[str, Any]					)					->					Any:


       """simple docstring"""







       _UpperCAmelCase  :						List[str]							   =					flatten_nested_dict(flax_params["backbone"]["merged_class_token"]					)

       _UpperCAmelCase  :						Dict							   =					torch.from_numpy(flax_class_token_params["scale"]					)
       _UpperCAmelCase  :						int							   =					torch.from_numpy(flax_class_token_params["bias"]					)
       _UpperCAmelCase  :						Union[str, Any]							   =					nn.Parameter(_UpperCAmelCase					)
       _UpperCAmelCase  :						List[Any]							   =					nn.Parameter(_UpperCAmelCase					)

def 			UpperCamelCase_							(      _UpperCAmelCase						:   Optional[Any]    ,			_UpperCAmelCase						:   str					)					->					str:


       """simple docstring"""







       _UpperCAmelCase  :						int							   =					hf_model.state_dict()
       _UpperCAmelCase  :						List[Any]							   =					{}

       # Rename class prediction head flax params to pytorch HF
       _UpperCAmelCase  :						Union[str, Any]							   =					flatten_nested_dict(flax_params["class_head"]					)

       for flax_key, v in flax_class_params.items():
              _UpperCAmelCase  :						Dict							   =					flax_key.replace("/"    ,			"."					)
              _UpperCAmelCase  :						Tuple							   =					torch_key.replace(".kernel"    ,			".weight"					)
              _UpperCAmelCase  :						List[Any]							   =					torch_key.replace("Dense_0"    ,			"dense0"					)
              _UpperCAmelCase  :						Tuple							   =					"class_head." + torch_key

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

              _UpperCAmelCase  :						Any							   =					nn.Parameter(torch.from_numpy(_UpperCAmelCase					)					)

       # Rename box prediction box flax params to pytorch HF
       _UpperCAmelCase  :						Optional[Any]							   =					flatten_nested_dict(flax_params["obj_box_head"]					)

       for flax_key, v in flax_box_params.items():
              _UpperCAmelCase  :						List[str]							   =					flax_key.replace("/"    ,			"."					)
              _UpperCAmelCase  :						int							   =					torch_key.replace(".kernel"    ,			".weight"					)
              _UpperCAmelCase  :						Union[str, Any]							   =					torch_key.replace("_"    ,			""					).lower()
              _UpperCAmelCase  :						Optional[Any]							   =					"box_head." + torch_key

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

              _UpperCAmelCase  :						Any							   =					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 			UpperCamelCase_							(      _UpperCAmelCase						:   str    ,			_UpperCAmelCase						:   List[Any]					)					->					List[Any]:


       """simple docstring"""







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

              _UpperCAmelCase  :						Union[str, Any]							   =					torch_key.replace("attn"    ,			"self_attn"					)
              _UpperCAmelCase  :						Dict							   =					torch_key.replace("key"    ,			"k_proj"					)
              _UpperCAmelCase  :						List[Any]							   =					torch_key.replace("value"    ,			"v_proj"					)
              _UpperCAmelCase  :						int							   =					torch_key.replace("query"    ,			"q_proj"					)
              _UpperCAmelCase  :						Tuple							   =					torch_key.replace("out"    ,			"out_proj"					)

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

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

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

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

def 			UpperCamelCase_							(      _UpperCAmelCase						:   Tuple					)					->					str:


       """simple docstring"""







       _UpperCAmelCase  :						Tuple							   =					{}
       _UpperCAmelCase  :						List[str]							   =					[]

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

                     processed_attn_layers.append(_UpperCAmelCase					)
                     _UpperCAmelCase  :						str							   =					params[base + "out.weight"].shape[-1]
                     _UpperCAmelCase  :						str							   =					params[base + "out.weight"].reshape(_UpperCAmelCase    ,			_UpperCAmelCase					).T
                     _UpperCAmelCase  :						Optional[int]							   =					params[base + "out.bias"]
              else:
                     _UpperCAmelCase  :						str							   =					v
       return new_params

def 			UpperCamelCase_							(      _UpperCAmelCase						:   str    ,			_UpperCAmelCase						:   Dict					)					->					Union[str, Any]:


       """simple docstring"""







       _UpperCAmelCase  :						Optional[int]							   =					CLIP(**_UpperCAmelCase					)
       torch_model.eval()
       _UpperCAmelCase  :						Tuple							   =					torch_model.state_dict()

       _UpperCAmelCase  :						str							   =					flatten_nested_dict(flax_params["backbone"]["clip"]					)
       _UpperCAmelCase  :						Union[str, Any]							   =					{}

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

              _UpperCAmelCase  :						Tuple							   =					torch_key.replace("text_projection.kernel"    ,			"text_projection"					)
              _UpperCAmelCase  :						Optional[int]							   =					torch_key.replace("visual.proj.kernel"    ,			"visual.proj"					)
              _UpperCAmelCase  :						Tuple							   =					torch_key.replace(".scale"    ,			".weight"					)
              _UpperCAmelCase  :						Any							   =					torch_key.replace(".kernel"    ,			".weight"					)

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

              _UpperCAmelCase  :						List[Any]							   =					v

       _UpperCAmelCase  :						List[Any]							   =					_convert_attn_layers(_UpperCAmelCase					)
       new_torch_params.update(_UpperCAmelCase					)
       _UpperCAmelCase  :						int							   =					{}

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

       return torch_clip_params, torch_model, attn_params

@torch.no_grad()
def 			UpperCamelCase_							(      _UpperCAmelCase						:   Optional[Any]    ,			_UpperCAmelCase						:   Tuple    ,			_UpperCAmelCase						:   Tuple    ,			_UpperCAmelCase						:   List[Any]    ,			_UpperCAmelCase						:   Any=None					)					->					Tuple:


       """simple docstring"""







       _UpperCAmelCase  :						str							   =					Repository(_UpperCAmelCase    ,			clone_from=F"""google/{pytorch_dump_folder_path}"""					)
       repo.git_pull()

       if config_path is not None:
              _UpperCAmelCase  :						int							   =					OwlViTConfig.from_pretrained(_UpperCAmelCase					)
       else:
              _UpperCAmelCase  :						Dict							   =					OwlViTConfig()

       _UpperCAmelCase  :						str							   =					OwlViTModel(_UpperCAmelCase					).eval()
       _UpperCAmelCase  :						Dict							   =					OwlViTForObjectDetection(_UpperCAmelCase					).eval()

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

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

       # Initialize processor
       _UpperCAmelCase  :						Any							   =					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__":
  __SCREAMING_SNAKE_CASE :  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."""
  )
  __SCREAMING_SNAKE_CASE :  Optional[Any]  =						parser.parse_args()

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

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

from datasets.utils.version import Version

@pytest.mark.parametrize(
    "other, expected_equality"    ,			[
        (Version("1.0.0"					), True),
        ("1.0.0", True),
        (Version("2.0.0"					), False),
        ("2.0.0", False),
        ("1", False),
        ("a", False),
        (1, False),
        (None, False),
    ]    ,			)
def 			UpperCamelCase_							(      _UpperCAmelCase						:   Tuple    ,			_UpperCAmelCase						:   List[Any]					)					->					int:


       """simple docstring"""







       _UpperCAmelCase  :						Union[str, Any]							   =					Version("1.0.0"					)
       assert (version == other) is expected_equality
       assert (version != other) is not expected_equality
       assert (hash(_UpperCAmelCase					) == hash(_UpperCAmelCase					)) is expected_equality

