





"""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 	__lowercase  (     snake_case_						:						int       ,snake_case_						:						Optional[Any]=""       ,snake_case_						:						Optional[Any]="/"		)     ->Union[str, Any]:



    '''simple docstring'''







    __A					:		Any						=  []

    for k, v in params.items():
        __A					:		List[Any]						=  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 	__lowercase  (     snake_case_						:						int		)     ->Optional[int]:



    '''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 	__lowercase  (     snake_case_						:						Optional[int]       ,snake_case_						:						Tuple		)     ->Optional[int]:



    '''simple docstring'''







    __A				, __A				, __A					:		str						=  pt_attn_layer.in_proj_weight.chunk(3       ,dim=0		)
    __A				, __A				, __A					:		Optional[Any]						=  pt_attn_layer.in_proj_bias.chunk(3       ,dim=0		)

    __A					:		str						=  pt_attn_layer.out_proj.weight
    __A					:		List[Any]						=  pt_attn_layer.out_proj.bias

    __A					:		List[str]						=  q_proj
    __A					:		Union[str, Any]						=  q_proj_bias

    __A					:		Union[str, Any]						=  k_proj
    __A					:		Any						=  k_proj_bias

    __A					:		str						=  v_proj
    __A					:		Optional[int]						=  v_proj_bias

    __A					:		Union[str, Any]						=  out_proj_weights
    __A					:		List[str]						=  out_proj_bias







def 	__lowercase  (     snake_case_						:						Dict       ,snake_case_						:						List[str]		)     ->int:



    '''simple docstring'''







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







def 	__lowercase  (     snake_case_						:						List[Any]       ,snake_case_						:						Tuple		)     ->Any:



    '''simple docstring'''







    __A					:		int						=  pt_linear.weight
    __A					:		Tuple						=  pt_linear.bias







def 	__lowercase  (     snake_case_						:						Dict       ,snake_case_						:						str		)     ->List[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 	__lowercase  (     snake_case_						:						List[Any]       ,snake_case_						:						int		)     ->Union[str, Any]:



    '''simple docstring'''







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







def 	__lowercase  (     snake_case_						:						Union[str, Any]       ,snake_case_						:						Optional[Any]		)     ->Union[str, Any]:



    '''simple docstring'''







    __A					:		Optional[int]						=  pt_model.token_embedding.weight
    __A					:		int						=  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 	__lowercase  (     snake_case_						:						Tuple       ,snake_case_						:						Tuple		)     ->Any:



    '''simple docstring'''







    __A					:		Tuple						=  pt_model.text_projection.data.T

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







def 	__lowercase  (     snake_case_						:						int       ,snake_case_						:						str		)     ->str:



    '''simple docstring'''







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

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







def 	__lowercase  (     snake_case_						:						Any       ,snake_case_						:						Tuple		)     ->Union[str, Any]:



    '''simple docstring'''







    __A					:		Any						=  flatten_nested_dict(flax_params['''backbone''']['''merged_class_token''']		)

    __A					:		Optional[int]						=  torch.from_numpy(flax_class_token_params['''scale''']		)
    __A					:		List[str]						=  torch.from_numpy(flax_class_token_params['''bias''']		)
    __A					:		List[Any]						=  nn.Parameter(snake_case_		)
    __A					:		Tuple						=  nn.Parameter(snake_case_		)







def 	__lowercase  (     snake_case_						:						Any       ,snake_case_						:						List[Any]		)     ->List[str]:



    '''simple docstring'''







    __A					:		str						=  hf_model.state_dict()
    __A					:		List[Any]						=  {}

    # Rename class prediction head flax params to pytorch HF
    __A					:		Optional[int]						=  flatten_nested_dict(flax_params['''class_head''']		)

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

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

        __A					:		str						=  nn.Parameter(torch.from_numpy(snake_case_		)		)

    # Rename box prediction box flax params to pytorch HF
    __A					:		List[str]						=  flatten_nested_dict(flax_params['''obj_box_head''']		)

    for flax_key, v in flax_box_params.items():
        __A					:		int						=  flax_key.replace('''/'''       ,'''.'''		)
        __A					:		List[str]						=  torch_key.replace('''.kernel'''       ,'''.weight'''		)
        __A					:		str						=  torch_key.replace('''_'''       ,''''''		).lower()
        __A					:		int						=  '''box_head.''' + torch_key

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

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



    '''simple docstring'''







    for k, v in flax_attn_params.items():
        if k.startswith('''transformer'''		):
            __A					:		int						=  k.replace('''transformer.resblocks'''       ,'''text_model.encoder.layers'''		)
        else:
            __A					:		Any						=  k.replace('''visual.transformer.resblocks'''       ,'''vision_model.encoder.layers'''		)

        __A					:		Any						=  torch_key.replace('''attn'''       ,'''self_attn'''		)
        __A					:		Tuple						=  torch_key.replace('''key'''       ,'''k_proj'''		)
        __A					:		Optional[int]						=  torch_key.replace('''value'''       ,'''v_proj'''		)
        __A					:		Union[str, Any]						=  torch_key.replace('''query'''       ,'''q_proj'''		)
        __A					:		Any						=  torch_key.replace('''out'''       ,'''out_proj'''		)

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

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

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

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







def 	__lowercase  (     snake_case_						:						Tuple		)     ->Optional[Any]:



    '''simple docstring'''







    __A					:		Union[str, Any]						=  {}
    __A					:		Optional[int]						=  []

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

            processed_attn_layers.append(snake_case_		)
            __A					:		Tuple						=  params[base + '''out.weight'''].shape[-1]
            __A					:		List[Any]						=  params[base + '''out.weight'''].reshape(snake_case_       ,snake_case_		).T
            __A					:		Optional[int]						=  params[base + '''out.bias''']
        else:
            __A					:		List[Any]						=  v
    return new_params







def 	__lowercase  (     snake_case_						:						Optional[int]       ,snake_case_						:						str		)     ->int:



    '''simple docstring'''







    __A					:		Optional[int]						=  CLIP(**snake_case_		)
    torch_model.eval()
    __A					:		Optional[Any]						=  torch_model.state_dict()

    __A					:		Any						=  flatten_nested_dict(flax_params['''backbone''']['''clip''']		)
    __A					:		str						=  {}

    for flax_key, v in flax_clip_params.items():
        __A					:		Union[str, Any]						=  flax_key.replace('''/'''       ,'''.'''		)
        __A					:		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'''		)
        ):
            __A					:		List[Any]						=  torch_key[5:]

        __A					:		List[Any]						=  torch_key.replace('''text_projection.kernel'''       ,'''text_projection'''		)
        __A					:		List[str]						=  torch_key.replace('''visual.proj.kernel'''       ,'''visual.proj'''		)
        __A					:		Dict						=  torch_key.replace('''.scale'''       ,'''.weight'''		)
        __A					:		Optional[int]						=  torch_key.replace('''.kernel'''       ,'''.weight'''		)

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

        __A					:		Optional[int]						=  v

    __A					:		int						=  _convert_attn_layers(snake_case_		)
    new_torch_params.update(snake_case_		)
    __A					:		int						=  {}

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

    return torch_clip_params, torch_model, attn_params







@torch.no_grad()
def 	__lowercase  (     snake_case_						:						Optional[Any]       ,snake_case_						:						Optional[int]       ,snake_case_						:						Optional[Any]       ,snake_case_						:						Any       ,snake_case_						:						int=None		)     ->Dict:



    '''simple docstring'''







    __A					:		int						=  Repository(snake_case_       ,clone_from=F"""google/{pytorch_dump_folder_path}"""		)
    repo.git_pull()

    if config_path is not None:
        __A					:		Any						=  OwlViTConfig.from_pretrained(snake_case_		)
    else:
        __A					:		Union[str, Any]						=  OwlViTConfig()

    __A					:		Tuple						=  OwlViTModel(snake_case_		).eval()
    __A					:		List[str]						=  OwlViTForObjectDetection(snake_case_		).eval()

    copy_text_model_and_projection(snake_case_       ,snake_case_		)
    copy_vision_model_and_projection(snake_case_       ,snake_case_		)
    __A					:		Optional[int]						=  pt_backbone.logit_scale
    copy_flax_attn_params(snake_case_       ,snake_case_		)

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

    # Initialize processor
    __A					:		Union[str, Any]						=  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__":
       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"""



import hashlib
import importlib.util
import json
import os
import pathlib
from types import ModuleType

import pytest
import requests

a_				=    pathlib.Path.cwd().joinpath("""project_euler""")
a_				=    pathlib.Path.cwd().joinpath(
    """scripts""", """project_euler_answers.json"""
)

with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
       a_				=    json.load(file_handle)







def 	__lowercase  (     snake_case_						:						pathlib.Path		)     ->ModuleType:



    '''simple docstring'''







    __A					:		str						=  importlib.util.spec_from_file_location(file_path.name       ,str(snake_case_		)		)
    __A					:		Optional[int]						=  importlib.util.module_from_spec(snake_case_		)  # type: ignore
    spec.loader.exec_module(snake_case_		)  # type: ignore
    return module







def 	__lowercase  (     )     ->list[pathlib.Path]:



    '''simple docstring'''







    __A					:		Optional[int]						=  []
    for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
        if problem_dir_path.is_file() or problem_dir_path.name.startswith('''_'''		):
            continue
        for file_path in problem_dir_path.iterdir():
            if file_path.suffix != ".py" or file_path.name.startswith(('''_''', '''test''')		):
                continue
            solution_file_paths.append(snake_case_		)
    return solution_file_paths







def 	__lowercase  (     )     ->str:



    '''simple docstring'''







    with open(os.environ['''GITHUB_EVENT_PATH''']		) as file:
        __A					:		Any						=  json.load(snake_case_		)
    return event["pull_request"]["url"] + "/files"







def 	__lowercase  (     )     ->list[pathlib.Path]:



    '''simple docstring'''







    __A					:		int						=  []
    __A					:		Optional[int]						=  {
        '''Accept''': '''application/vnd.github.v3+json''',
        '''Authorization''': '''token ''' + os.environ['''GITHUB_TOKEN'''],
    }
    __A					:		Optional[Any]						=  requests.get(get_files_url()       ,headers=snake_case_		).json()
    for file in files:
        __A					:		Union[str, Any]						=  pathlib.Path.cwd().joinpath(file['''filename''']		)
        if (
            filepath.suffix != ".py"
            or filepath.name.startswith(('''_''', '''test''')		)
            or not filepath.name.startswith('''sol'''		)
        ):
            continue
        solution_file_paths.append(snake_case_		)
    return solution_file_paths







def 	__lowercase  (     )     ->list[pathlib.Path]:



    '''simple docstring'''







    if os.environ.get('''CI'''		) and os.environ.get('''GITHUB_EVENT_NAME'''		) == "pull_request":
        # Return only if there are any, otherwise default to all solutions
        if filepaths := added_solution_file_path():
            return filepaths
    return all_solution_file_paths()







@pytest.mark.parametrize(
    '''solution_path'''       ,collect_solution_file_paths()       ,ids=lambda snake_case_		: F"""{path.parent.name}/{path.name}"""       ,)
def 	__lowercase  (     snake_case_						:						pathlib.Path		)     ->None:



    '''simple docstring'''







    __A					:		str						=  solution_path.parent.name[8:].zfill(3		)
    __A					:		str						=  PROBLEM_ANSWERS[problem_number]
    __A					:		Union[str, Any]						=  convert_path_to_module(snake_case_		)
    __A					:		List[str]						=  str(solution_module.solution()		)  # type: ignore
    __A					:		List[str]						=  hashlib.shaaaa(answer.encode()		).hexdigest()
    assert (
        answer == expected
    ), F"""Expected solution to {problem_number} to have hash {expected}, got {answer}"""




