






"""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_			  =    {
    "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 						_UpperCamelCase			(  A    ,       A=""    ,       A="/"			):
   UpperCamelCase_     =[]

   for k, v in params.items():
      UpperCamelCase_     =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 						_UpperCamelCase			(  A			):
   return jax.tree_util.tree_map(lambda A			: x.astype(jnp.floataa			) if x.dtype == jnp.bfloataa else x    ,       A			)




def 						_UpperCamelCase			(  A    ,       A			):
   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 						_UpperCamelCase			(  A    ,       A			):
   copy_linear(hf_mlp.fca    ,       pt_mlp.c_fc			)
   copy_linear(hf_mlp.fca    ,       pt_mlp.c_proj			)




def 						_UpperCamelCase			(  A    ,       A			):
   UpperCamelCase_     =pt_linear.weight
   UpperCamelCase_     =pt_linear.bias




def 						_UpperCamelCase			(  A    ,       A			):
   # 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 						_UpperCamelCase			(  A    ,       A			):
   for hf_layer, pt_layer in zip(A    ,       A			):
      copy_layer(A    ,       A			)




def 						_UpperCamelCase			(  A    ,       A			):
   # 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 						_UpperCamelCase			(  A    ,       A			):
   # copy projection
   UpperCamelCase_     =pt_model.text_projection.data.T

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




def 						_UpperCamelCase			(  A    ,       A			):
   # 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 						_UpperCamelCase			(  A    ,       A			):
   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(A			)
   UpperCamelCase_     =nn.Parameter(A			)




def 						_UpperCamelCase			(  A    ,       A			):
   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(A			)			)

   # 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(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 						_UpperCamelCase			(  A    ,       A			):
   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(A			)

      if "weight" in torch_key and "out" in torch_key:
         UpperCamelCase_     =(v.shape[0] * v.shape[1], v.shape[2])
         UpperCamelCase_     =v.reshape(A			).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(A			).T

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




def 						_UpperCamelCase			(  A			):
   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(A			)
         UpperCamelCase_     =params[base + "out.weight"].shape[-1]
         UpperCamelCase_     =params[base + "out.weight"].reshape(A    ,       A			).T
         UpperCamelCase_     =params[base + "out.bias"]
      else:
         UpperCamelCase_     =v
   return new_params




def 						_UpperCamelCase			(  A    ,       A			):
   UpperCamelCase_     =CLIP(**A			)
   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(A			)
   new_torch_params.update(A			)
   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_(A			)
      else:
         UpperCamelCase_     =param

   return torch_clip_params, torch_model, attn_params




@torch.no_grad()
def 						_UpperCamelCase			(  A    ,       A    ,       A    ,       A    ,       A=None			):
   UpperCamelCase_     =Repository(A    ,       clone_from=f"""google/{pytorch_dump_folder_path}"""			)
   repo.git_pull()

   if config_path is not None:
      UpperCamelCase_     =OwlViTConfig.from_pretrained(A			)
   else:
      UpperCamelCase_     =OwlViTConfig()

   UpperCamelCase_     =OwlViTModel(A			).eval()
   UpperCamelCase_     =OwlViTForObjectDetection(A			).eval()

   copy_text_model_and_projection(A    ,       A			)
   copy_vision_model_and_projection(A    ,       A			)
   UpperCamelCase_     =pt_backbone.logit_scale
   copy_flax_attn_params(A    ,       A			)

   UpperCamelCase_     =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
   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=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_			  =    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_			  =    parser.parse_args()

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

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




def 						_UpperCamelCase			(  A = 5			):
   UpperCamelCase_     =defaultdict(A			)
   UpperCamelCase_     =0

   while True:
      UpperCamelCase_     =get_digits(A			)
      freqs[digits].append(A			)

      if len(freqs[digits]			) == max_base:
         UpperCamelCase_     =freqs[digits][0] ** 3
         return base

      num += 1




def 						_UpperCamelCase			(  A			):
   return "".join(sorted(str(num**3			)			)			)


if __name__ == "__main__":
    print(f'''{solution() = }''')
