






"""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,
)


lowerCAmelCase_		:			Optional[int]				   =					{
    '''vit_b32''': {
        '''embed_dim''': 5_1_2,
        '''image_resolution''': 7_6_8,
        '''context_length''': 1_6,
        '''vocab_size''': 4_9_4_0_8,
        '''vision_layers''': 1_2,
        '''vision_width''': 7_6_8,
        '''vision_patch_size''': 3_2,
        '''transformer_width''': 5_1_2,
        '''transformer_heads''': 8,
        '''transformer_layers''': 1_2,
    },
    '''vit_b16''': {
        '''embed_dim''': 5_1_2,
        '''image_resolution''': 7_6_8,
        '''context_length''': 1_6,
        '''vocab_size''': 4_9_4_0_8,
        '''vision_layers''': 1_2,
        '''vision_width''': 7_6_8,
        '''vision_patch_size''': 1_6,
        '''transformer_width''': 5_1_2,
        '''transformer_heads''': 8,
        '''transformer_layers''': 1_2,
    },
    '''vit_l14''': {
        '''embed_dim''': 7_6_8,
        '''image_resolution''': 8_4_0,
        '''context_length''': 1_6,
        '''vocab_size''': 4_9_4_0_8,
        '''vision_layers''': 2_4,
        '''vision_width''': 1_0_2_4,
        '''vision_patch_size''': 1_4,
        '''transformer_width''': 7_6_8,
        '''transformer_heads''': 1_2,
        '''transformer_layers''': 1_2,
    },
}






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase=""		,					lowerCAmelCase="/"						):







       '''simple docstring'''
       UpperCAmelCase					=	[]

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

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






def 					_lowerCAmelCase				(					lowerCAmelCase						):







       '''simple docstring'''
       return jax.tree_util.tree_map(lambda lowerCAmelCase						: x.astype(jnp.floataa						) if x.dtype == jnp.bfloataa else x		,					lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       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 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       copy_linear(hf_mlp.fca		,					pt_mlp.c_fc						)
       copy_linear(hf_mlp.fca		,					pt_mlp.c_proj						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	pt_linear.weight
       UpperCAmelCase					=	pt_linear.bias






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       # 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 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       for hf_layer, pt_layer in zip(lowerCAmelCase		,					lowerCAmelCase						):
              copy_layer(lowerCAmelCase		,					lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       # 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 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       # copy projection
       UpperCAmelCase					=	pt_model.text_projection.data.T

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






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       # 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 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       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(lowerCAmelCase						)
       UpperCAmelCase					=	nn.Parameter(lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       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(lowerCAmelCase						)						)

       # 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(lowerCAmelCase						)						)

       # Copy flax params to PyTorch params
       for name, param in new_params.items():
              if name in pt_params.keys():
                     pt_params[name].copy_(lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       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(lowerCAmelCase						)

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

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






def 					_lowerCAmelCase				(					lowerCAmelCase						):







       '''simple docstring'''
       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(lowerCAmelCase						)
                     UpperCAmelCase					=	params[base + """out.weight"""].shape[-1]
                     UpperCAmelCase					=	params[base + """out.weight"""].reshape(lowerCAmelCase		,					lowerCAmelCase						).T
                     UpperCAmelCase					=	params[base + """out.bias"""]
              else:
                     UpperCAmelCase					=	v
       return new_params






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	CLIP(**lowerCAmelCase						)
       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(lowerCAmelCase						)
       new_torch_params.update(lowerCAmelCase						)
       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_(lowerCAmelCase						)
              else:
                     UpperCAmelCase					=	param

       return torch_clip_params, torch_model, attn_params






@torch.no_grad()
def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase=None						):







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

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

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

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

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

       # 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=lowerCAmelCase		,					tokenizer=lowerCAmelCase						)
       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__":
 lowerCAmelCase_		:			List[str]				   =					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.'''
 )
 lowerCAmelCase_		:			Dict				   =					parser.parse_args()

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

 # Load from checkpoint and convert params to float-32
 lowerCAmelCase_		:			Tuple				   =					checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)['''optimizer''']['''target''']
 lowerCAmelCase_		:			Optional[int]				   =					jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
 del variables

 # Convert CLIP backbone
 lowerCAmelCase_   ,    lowerCAmelCase_   ,    lowerCAmelCase_		:			Dict				   =					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 ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_		:			str				   =					logging.get_logger(__name__)

lowerCAmelCase_		:			Optional[int]				   =					{
    '''google/reformer-crime-and-punishment''': (
        '''https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/config.json'''
    ),
    '''google/reformer-enwik8''': '''https://huggingface.co/google/reformer-enwik8/resolve/main/config.json''',
}





class      UpperCamelCase_       (				a_     ):
  _A				:    int =		'reformer'
  _A				:    Any =		['past_buckets_states']
  _A				:    Optional[Any] =		{}



  def __init__(					self       ,						snake_case__=64       ,						snake_case__=["local", "lsh", "local", "lsh", "local", "lsh"]       ,						snake_case__=1.0       ,						snake_case__=True       ,						snake_case__=[64, 64]       ,						snake_case__=[64, 1_92]       ,						snake_case__=0       ,						snake_case__=2       ,						snake_case__=5_12       ,						snake_case__=None       ,						snake_case__="relu"       ,						snake_case__=0.05       ,						snake_case__=2_56       ,						snake_case__=0.02       ,						snake_case__=False       ,						snake_case__=1e-12       ,						snake_case__=1       ,						snake_case__=0       ,						snake_case__=0.05       ,						snake_case__=64       ,						snake_case__=64       ,						snake_case__=0.0       ,						snake_case__=1       ,						snake_case__=0       ,						snake_case__=40_96       ,						snake_case__=12       ,						snake_case__=None       ,						snake_case__=1       ,						snake_case__=0       ,						snake_case__=3_20       ,						snake_case__=False       ,						snake_case__=True       ,						snake_case__=None       ,						**snake_case__       ,						)	->	List[Any]:



         """simple docstring"""





         UpperCAmelCase					=	hash_seed
         UpperCAmelCase					=	vocab_size
         UpperCAmelCase					=	attention_head_size
         UpperCAmelCase					=	hidden_size
         UpperCAmelCase					=	num_attention_heads
         UpperCAmelCase					=	num_hashes
         UpperCAmelCase					=	len(snake_case__ )
         UpperCAmelCase					=	tuple(snake_case__ ) if isinstance(snake_case__       ,						snake_case__ ) else num_buckets
         UpperCAmelCase					=	lsh_attn_chunk_length
         UpperCAmelCase					=	local_attn_chunk_length
         UpperCAmelCase					=	lsh_num_chunks_after
         UpperCAmelCase					=	lsh_num_chunks_before
         UpperCAmelCase					=	local_num_chunks_after
         UpperCAmelCase					=	local_num_chunks_before
         UpperCAmelCase					=	hidden_act
         UpperCAmelCase					=	feed_forward_size
         UpperCAmelCase					=	hidden_dropout_prob
         UpperCAmelCase					=	lsh_attention_probs_dropout_prob
         UpperCAmelCase					=	local_attention_probs_dropout_prob
         UpperCAmelCase					=	max_position_embeddings
         UpperCAmelCase					=	initializer_range
         UpperCAmelCase					=	layer_norm_eps
         UpperCAmelCase					=	axial_pos_embds
         UpperCAmelCase					=	tuple(snake_case__ )
         UpperCAmelCase					=	tuple(snake_case__ )
         UpperCAmelCase					=	axial_norm_std
         UpperCAmelCase					=	chunk_size_lm_head
         UpperCAmelCase					=	attn_layers
         UpperCAmelCase					=	use_cache
         UpperCAmelCase					=	classifier_dropout
         super().__init__(
             pad_token_id=snake_case__       ,						eos_token_id=snake_case__       ,						is_decoder=snake_case__       ,						tie_word_embeddings=snake_case__       ,						**snake_case__       ,						)
