





"""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__ =       {
    "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__							(  SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						List[Any]=""							,						SCREAMING_SNAKE_CASE					:						Union[str, Any]="/"      ):







      '''simple docstring'''




      lowerCAmelCase  						=	[]

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

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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Dict      ):







      '''simple docstring'''




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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						List[Any]							,						SCREAMING_SNAKE_CASE					:						Optional[Any]      ):







      '''simple docstring'''




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

      lowerCAmelCase  						=	pt_attn_layer.out_proj.weight
      lowerCAmelCase  						=	pt_attn_layer.out_proj.bias

      lowerCAmelCase  						=	q_proj
      lowerCAmelCase  						=	q_proj_bias

      lowerCAmelCase  						=	k_proj
      lowerCAmelCase  						=	k_proj_bias

      lowerCAmelCase  						=	v_proj
      lowerCAmelCase  						=	v_proj_bias

      lowerCAmelCase  						=	out_proj_weights
      lowerCAmelCase  						=	out_proj_bias


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Dict							,						SCREAMING_SNAKE_CASE					:						Optional[int]      ):







      '''simple docstring'''




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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						List[Any]							,						SCREAMING_SNAKE_CASE					:						List[Any]      ):







      '''simple docstring'''




      lowerCAmelCase  						=	pt_linear.weight
      lowerCAmelCase  						=	pt_linear.bias


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						str							,						SCREAMING_SNAKE_CASE					:						Optional[int]      ):







      '''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__							(  SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						List[str]      ):







      '''simple docstring'''




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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						str							,						SCREAMING_SNAKE_CASE					:						List[Any]      ):







      '''simple docstring'''




      lowerCAmelCase  						=	pt_model.token_embedding.weight
      lowerCAmelCase  						=	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__							(  SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						str      ):







      '''simple docstring'''




      lowerCAmelCase  						=	pt_model.text_projection.data.T

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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Union[str, Any]							,						SCREAMING_SNAKE_CASE					:						Optional[int]      ):







      '''simple docstring'''




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

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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						int							,						SCREAMING_SNAKE_CASE					:						List[str]      ):







      '''simple docstring'''




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

      lowerCAmelCase  						=	torch.from_numpy(flax_class_token_params["""scale"""]      )
      lowerCAmelCase  						=	torch.from_numpy(flax_class_token_params["""bias"""]      )
      lowerCAmelCase  						=	nn.Parameter(SCREAMING_SNAKE_CASE      )
      lowerCAmelCase  						=	nn.Parameter(SCREAMING_SNAKE_CASE      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						List[str]							,						SCREAMING_SNAKE_CASE					:						Optional[int]      ):







      '''simple docstring'''




      lowerCAmelCase  						=	hf_model.state_dict()
      lowerCAmelCase  						=	{}

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

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

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

            lowerCAmelCase  						=	nn.Parameter(torch.from_numpy(SCREAMING_SNAKE_CASE      )      )

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

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

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

            lowerCAmelCase  						=	nn.Parameter(torch.from_numpy(SCREAMING_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_(SCREAMING_SNAKE_CASE      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Tuple							,						SCREAMING_SNAKE_CASE					:						Tuple      ):







      '''simple docstring'''




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

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

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

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

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

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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Tuple      ):







      '''simple docstring'''




      lowerCAmelCase  						=	{}
      lowerCAmelCase  						=	[]

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

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


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Union[str, Any]							,						SCREAMING_SNAKE_CASE					:						Tuple      ):







      '''simple docstring'''




      lowerCAmelCase  						=	CLIP(**SCREAMING_SNAKE_CASE      )
      torch_model.eval()
      lowerCAmelCase  						=	torch_model.state_dict()

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

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

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

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

            lowerCAmelCase  						=	v

      lowerCAmelCase  						=	_convert_attn_layers(SCREAMING_SNAKE_CASE      )
      new_torch_params.update(SCREAMING_SNAKE_CASE      )
      lowerCAmelCase  						=	{}

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

      return torch_clip_params, torch_model, attn_params


@torch.no_grad()
def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						List[Any]							,						SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						List[Any]							,						SCREAMING_SNAKE_CASE					:						str							,						SCREAMING_SNAKE_CASE					:						str=None      ):







      '''simple docstring'''




      lowerCAmelCase  						=	Repository(SCREAMING_SNAKE_CASE							,						clone_from=F'google/{pytorch_dump_folder_path}'      )
      repo.git_pull()

      if config_path is not None:
            lowerCAmelCase  						=	OwlViTConfig.from_pretrained(SCREAMING_SNAKE_CASE      )
      else:
            lowerCAmelCase  						=	OwlViTConfig()

      lowerCAmelCase  						=	OwlViTModel(SCREAMING_SNAKE_CASE      ).eval()
      lowerCAmelCase  						=	OwlViTForObjectDetection(SCREAMING_SNAKE_CASE      ).eval()

      copy_text_model_and_projection(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      )
      copy_vision_model_and_projection(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      )
      lowerCAmelCase  						=	pt_backbone.logit_scale
      copy_flax_attn_params(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      )

      lowerCAmelCase  						=	hf_backbone
      copy_class_merge_token(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      )
      copy_class_box_heads(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      )

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

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

      # Initialize processor
      lowerCAmelCase  						=	OwlViTProcessor(image_processor=SCREAMING_SNAKE_CASE							,						tokenizer=SCREAMING_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__":
       SCREAMING_SNAKE_CASE__ =       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__ =       parser.parse_args()

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

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





SCREAMING_SNAKE_CASE__ =       [0.33, 0.44, 0.55, 0.44, 0.33]
SCREAMING_SNAKE_CASE__ =       3
SCREAMING_SNAKE_CASE__ =       5

# Buffer Space (with Parameters Space)
SCREAMING_SNAKE_CASE__ =       []
SCREAMING_SNAKE_CASE__ =       []

# Machine Time
SCREAMING_SNAKE_CASE__ =       0


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Tuple      ):







      '''simple docstring'''




      global buffer_space, params_space, machine_time, K, m, t

      # Choosing Dynamical Systems (All)
      for key, value in enumerate(SCREAMING_SNAKE_CASE      ):
            # Evolution Parameter
            lowerCAmelCase  						=	float(seed / value      )

            # Control Theory: Orbit Change
            lowerCAmelCase  						=	(buffer_space[(key + 1) % m] + e) % 1

            # Control Theory: Trajectory Change
            lowerCAmelCase  						=	(params_space[key] + e) % 1 + 3

            # Modification (Transition Function) - Jumps
            lowerCAmelCase  						=	round(float(r * value * (1 - value)      )							,						10      )
            lowerCAmelCase  						=	r  # Saving to Parameters Space

      # Logistic Map
      assert max(SCREAMING_SNAKE_CASE      ) < 1
      assert max(SCREAMING_SNAKE_CASE      ) < 4

      # Machine Time
      machine_time += 1


def       UpperCAmelCase__							(  ):







      '''simple docstring'''




      global buffer_space, params_space, machine_time, K, m, t

      # PRNG (Xorshift by George Marsaglia)
      def xorshift(SCREAMING_SNAKE_CASE					:						List[str]							,						SCREAMING_SNAKE_CASE					:						Tuple      ):
            x ^= y >> 13
            y ^= x << 17
            x ^= y >> 5
            return x

      # Choosing Dynamical Systems (Increment)
      lowerCAmelCase  						=	machine_time % m

      # Evolution (Time Length)
      for _ in range(0							,						SCREAMING_SNAKE_CASE      ):
            # Variables (Position + Parameters)
            lowerCAmelCase  						=	params_space[key]
            lowerCAmelCase  						=	buffer_space[key]

            # Modification (Transition Function) - Flow
            lowerCAmelCase  						=	round(float(r * value * (1 - value)      )							,						10      )
            lowerCAmelCase  						=	(machine_time * 0.01 + r * 1.01) % 1 + 3

      # Choosing Chaotic Data
      lowerCAmelCase  						=	int(buffer_space[(key + 2) % m] * (10**10)      )
      lowerCAmelCase  						=	int(buffer_space[(key - 2) % m] * (10**10)      )

      # Machine Time
      machine_time += 1

      return xorshift(SCREAMING_SNAKE_CASE							,						SCREAMING_SNAKE_CASE      ) % 0xff_fff_fff


def       UpperCAmelCase__							(  ):







      '''simple docstring'''




      global buffer_space, params_space, machine_time, K, m, t

      lowerCAmelCase  						=	K
      lowerCAmelCase  						=	[0] * m
      lowerCAmelCase  						=	0


if __name__ == "__main__":
       # Initialization
       reset()

       # Pushing Data (Input)
       import random

       SCREAMING_SNAKE_CASE__ =       random.sample(range(0Xf_f_f_f_f_f_f_f), 100)
       for chunk in message:
              push(chunk)

       # for controlling
       SCREAMING_SNAKE_CASE__ =       ""

       # Pulling Data (Output)
       while inp in ("e", "E"):
              print(f'{format(pull(), "#04x")}')
              print(buffer_space)
              print(params_space)
              SCREAMING_SNAKE_CASE__ =       input("(e)exit? ").strip()






