




'''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							:     Optional[int]   	=				{
    "vit_b32": {
        "embed_dim": 512,
        "image_resolution": 768,
        "context_length": 16,
        "vocab_size": 4_9408,
        "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": 4_9408,
        "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": 4_9408,
        "vision_layers": 24,
        "vision_width": 1024,
        "vision_patch_size": 14,
        "transformer_width": 768,
        "transformer_heads": 12,
        "transformer_layers": 12,
    },
}


def   UpperCamelCase_(			snake_case							: str							,       snake_case							: Optional[Any]=""							,       snake_case							: str="/"  ):

							'''simple docstring'''






							snake_case_			      =   []

							for k, v in params.items():
														snake_case_			      =   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   UpperCamelCase_(			snake_case							: str  ):

							'''simple docstring'''






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


def   UpperCamelCase_(			snake_case							: List[str]							,       snake_case							: Dict  ):

							'''simple docstring'''






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

							snake_case_			      =   pt_attn_layer.out_proj.weight
							snake_case_			      =   pt_attn_layer.out_proj.bias

							snake_case_			      =   q_proj
							snake_case_			      =   q_proj_bias

							snake_case_			      =   k_proj
							snake_case_			      =   k_proj_bias

							snake_case_			      =   v_proj
							snake_case_			      =   v_proj_bias

							snake_case_			      =   out_proj_weights
							snake_case_			      =   out_proj_bias


def   UpperCamelCase_(			snake_case							: List[Any]							,       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_(			snake_case							: List[str]							,       snake_case							: str  ):

							'''simple docstring'''






							snake_case_			      =   pt_linear.weight
							snake_case_			      =   pt_linear.bias


def   UpperCamelCase_(			snake_case							: Optional[int]							,       snake_case							: Any  ):

							'''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_(			snake_case							: Dict							,       snake_case							: Optional[int]  ):

							'''simple docstring'''






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


def   UpperCamelCase_(			snake_case							: Dict							,       snake_case							: List[Any]  ):

							'''simple docstring'''






							snake_case_			      =   pt_model.token_embedding.weight
							snake_case_			      =   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_(			snake_case							: Dict							,       snake_case							: List[str]  ):

							'''simple docstring'''






							snake_case_			      =   pt_model.text_projection.data.T

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


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: Optional[Any]  ):

							'''simple docstring'''






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

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


def   UpperCamelCase_(			snake_case							: List[Any]							,       snake_case							: Any  ):

							'''simple docstring'''






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

							snake_case_			      =   torch.from_numpy(flax_class_token_params["scale"]  )
							snake_case_			      =   torch.from_numpy(flax_class_token_params["bias"]  )
							snake_case_			      =   nn.Parameter(snake_case  )
							snake_case_			      =   nn.Parameter(snake_case  )


def   UpperCamelCase_(			snake_case							: str							,       snake_case							: Any  ):

							'''simple docstring'''






							snake_case_			      =   hf_model.state_dict()
							snake_case_			      =   {}

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

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

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

														snake_case_			      =   nn.Parameter(torch.from_numpy(snake_case  )  )

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

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

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

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

							'''simple docstring'''






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

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

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

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

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

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


def   UpperCamelCase_(			snake_case							: Optional[Any]  ):

							'''simple docstring'''






							snake_case_			      =   {}
							snake_case_			      =   []

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

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


def   UpperCamelCase_(			snake_case							: List[str]							,       snake_case							: str  ):

							'''simple docstring'''






							snake_case_			      =   CLIP(**snake_case  )
							torch_model.eval()
							snake_case_			      =   torch_model.state_dict()

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

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

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

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

														snake_case_			      =   v

							snake_case_			      =   _convert_attn_layers(snake_case  )
							new_torch_params.update(snake_case  )
							snake_case_			      =   {}

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

							return torch_clip_params, torch_model, attn_params


@torch.no_grad()
def   UpperCamelCase_(			snake_case							: Optional[int]							,       snake_case							: Union[str, Any]							,       snake_case							: Optional[Any]							,       snake_case							: str							,       snake_case							: Any=None  ):

							'''simple docstring'''






							snake_case_			      =   Repository(snake_case							,       clone_from=f'google/{pytorch_dump_folder_path}'  )
							repo.git_pull()

							if config_path is not None:
														snake_case_			      =   OwlViTConfig.from_pretrained(snake_case  )
							else:
														snake_case_			      =   OwlViTConfig()

							snake_case_			      =   OwlViTModel(snake_case  ).eval()
							snake_case_			      =   OwlViTForObjectDetection(snake_case  ).eval()

							copy_text_model_and_projection(snake_case							,       snake_case  )
							copy_vision_model_and_projection(snake_case							,       snake_case  )
							snake_case_			      =   pt_backbone.logit_scale
							copy_flax_attn_params(snake_case							,       snake_case  )

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

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

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

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





import heapq


def   UpperCamelCase_(			snake_case							: List[Any]							,       snake_case							: List[str]							,       snake_case							: Dict  ):

							'''simple docstring'''






							snake_case_			      =   [(0, start)]  # cost from start node,end node
							snake_case_			      =   set()
							while heap:
														((snake_case_)      ,   (snake_case_))			      =   heapq.heappop(snake_case  )
														if u in visited:
																					continue
														visited.add(snake_case  )
														if u == end:
																					return cost
														for v, c in graph[u]:
																					if v in visited:
																												continue
																					snake_case_			      =   cost + c
																					heapq.heappush(snake_case							,       (next_item, v)  )
							return -1


_SCREAMING_SNAKE_CASE							:     Dict   	=				{
    "A": [["B", 2], ["C", 5]],
    "B": [["A", 2], ["D", 3], ["E", 1], ["F", 1]],
    "C": [["A", 5], ["F", 3]],
    "D": [["B", 3]],
    "E": [["B", 4], ["F", 3]],
    "F": [["C", 3], ["E", 3]],
}
_SCREAMING_SNAKE_CASE							:     Optional[int]   	=				{
    "B": [["C", 1]],
    "C": [["D", 1]],
    "D": [["F", 1]],
    "E": [["B", 1], ["F", 3]],
    "F": [],
}
_SCREAMING_SNAKE_CASE							:     Any   	=				{
    "B": [["C", 1]],
    "C": [["D", 1]],
    "D": [["F", 1]],
    "E": [["B", 1], ["G", 2]],
    "F": [],
    "G": [["F", 1]],
}

_SCREAMING_SNAKE_CASE							:     Tuple   	=				dijkstra(G, "E", "C")
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

_SCREAMING_SNAKE_CASE							:     str   	=				dijkstra(Ga, "E", "F")
print(short_distance)  # E -- 3 --> F == 3

_SCREAMING_SNAKE_CASE							:     List[Any]   	=				dijkstra(Ga, "E", "F")
print(short_distance)  # E -- 2 --> G -- 1 --> F == 3

if __name__ == "__main__":
		import doctest

		doctest.testmod()




