code: 
  
  
  
  
  
  
  """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)
  
style_context: 
  
  
  
  
  
  
  """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() = }''')
  