




'''simple docstring'''






from __future__ import annotations




def 		a_(			lowerCamelCase   )					->list[int]:






       '''simple docstring'''




       if not list_of_ints:
              return []

       if min(lowerCamelCase   ) < 0:
              raise ValueError('''All numbers must be positive'''   )

       lowercase	:		Tuple    =   max(len(bin(lowerCamelCase   )[2:]   ) for x in list_of_ints   )
       return _msd_radix_sort(lowerCamelCase ,					lowerCamelCase   )




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->list[int]:






       '''simple docstring'''




       if bit_position == 0 or len(lowerCamelCase   ) in [0, 1]:
              return list_of_ints

       lowercase	:		Optional[int]    =   []
       lowercase	:		Optional[int]    =   []
       # Split numbers based on bit at bit_position from the right
       for number in list_of_ints:
              if (number >> (bit_position - 1)) & 1:
                     # number has a one at bit bit_position
                     ones.append(lowerCamelCase   )
              else:
                     # number has a zero at bit bit_position
                     zeros.append(lowerCamelCase   )

    # recursively split both lists further
       lowercase	:		Optional[Any]    =   _msd_radix_sort(lowerCamelCase ,					bit_position - 1   )
       lowercase	:		List[str]    =   _msd_radix_sort(lowerCamelCase ,					bit_position - 1   )

       # recombine lists
       lowercase	:		Optional[Any]    =   zeros
       res.extend(lowerCamelCase   )

       return res




def 		a_(			lowerCamelCase   )					->Tuple:






       '''simple docstring'''




       lowercase	:		List[Any]    =   len(lowerCamelCase   )
       if not list_of_ints or length == 1:
              return

       if min(lowerCamelCase   ) < 0:
              raise ValueError('''All numbers must be positive'''   )

       lowercase	:		Optional[Any]    =   max(len(bin(lowerCamelCase   )[2:]   ) for x in list_of_ints   )
       _msd_radix_sort_inplace(lowerCamelCase ,					lowerCamelCase ,					0 ,					lowerCamelCase   )




def 		a_(			lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase   )					->List[Any]:






       '''simple docstring'''




       if bit_position == 0 or end_index - begin_index <= 1:
              return

       bit_position -= 1

       lowercase	:		Tuple    =   begin_index
       lowercase	:		str    =   end_index - 1
       while i <= j:
              lowercase	:		str    =   False
              if not (list_of_ints[i] >> bit_position) & 1:
                     # found zero at the beginning
                     i += 1
                     lowercase	:		Any    =   True
              if (list_of_ints[j] >> bit_position) & 1:
                     # found one at the end
                     j -= 1
                     lowercase	:		Tuple    =   True

              if changed:
                     continue

              lowercase,  lowercase	:		int    =   list_of_ints[j], list_of_ints[i]
              j -= 1
              if j != i:
                     i += 1

       _msd_radix_sort_inplace(lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase   )
       _msd_radix_sort_inplace(lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()










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


lowercase						:   Any      						=							{
    '''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 		a_(			lowerCamelCase ,					lowerCamelCase="" ,					lowerCamelCase="/"   )					->str:






       '''simple docstring'''




       lowercase	:		List[Any]    =   []

       for k, v in params.items():
              lowercase	:		int    =   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 		a_(			lowerCamelCase   )					->Optional[Any]:






       '''simple docstring'''




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




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Dict:






       '''simple docstring'''




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

       lowercase	:		Union[str, Any]    =   pt_attn_layer.out_proj.weight
       lowercase	:		Tuple    =   pt_attn_layer.out_proj.bias

       lowercase	:		int    =   q_proj
       lowercase	:		Optional[Any]    =   q_proj_bias

       lowercase	:		str    =   k_proj
       lowercase	:		List[Any]    =   k_proj_bias

       lowercase	:		Dict    =   v_proj
       lowercase	:		List[str]    =   v_proj_bias

       lowercase	:		Optional[int]    =   out_proj_weights
       lowercase	:		Tuple    =   out_proj_bias




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->List[str]:






       '''simple docstring'''




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




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Any:






       '''simple docstring'''




       lowercase	:		List[str]    =   pt_linear.weight
       lowercase	:		Tuple    =   pt_linear.bias




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->str:






       '''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 		a_(			lowerCamelCase ,					lowerCamelCase   )					->List[Any]:






       '''simple docstring'''




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




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Dict:






       '''simple docstring'''




       lowercase	:		List[str]    =   pt_model.token_embedding.weight
       lowercase	:		Optional[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 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Tuple:






       '''simple docstring'''




       lowercase	:		List[str]    =   pt_model.text_projection.data.T

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




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->str:






       '''simple docstring'''




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

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




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->List[Any]:






       '''simple docstring'''




       lowercase	:		Dict    =   flatten_nested_dict(flax_params['''backbone''']['''merged_class_token''']   )

       lowercase	:		Union[str, Any]    =   torch.from_numpy(flax_class_token_params['''scale''']   )
       lowercase	:		List[str]    =   torch.from_numpy(flax_class_token_params['''bias''']   )
       lowercase	:		Tuple    =   nn.Parameter(lowerCamelCase   )
       lowercase	:		Union[str, Any]    =   nn.Parameter(lowerCamelCase   )




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->List[Any]:






       '''simple docstring'''




       lowercase	:		Optional[int]    =   hf_model.state_dict()
       lowercase	:		Dict    =   {}

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

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

              if "weight" in torch_key and v.ndim == 2:
                     lowercase	:		Optional[int]    =   v.T

              lowercase	:		Optional[int]    =   nn.Parameter(torch.from_numpy(lowerCamelCase   )   )

       # Rename box prediction box flax params to pytorch HF
       lowercase	:		Optional[Any]    =   flatten_nested_dict(flax_params['''obj_box_head''']   )

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

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

              lowercase	:		Tuple    =   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 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Dict:






       '''simple docstring'''




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

              lowercase	:		Optional[Any]    =   torch_key.replace('''attn''' ,					'''self_attn'''   )
              lowercase	:		Optional[int]    =   torch_key.replace('''key''' ,					'''k_proj'''   )
              lowercase	:		Dict    =   torch_key.replace('''value''' ,					'''v_proj'''   )
              lowercase	:		List[Any]    =   torch_key.replace('''query''' ,					'''q_proj'''   )
              lowercase	:		Any    =   torch_key.replace('''out''' ,					'''out_proj'''   )

              if "bias" in torch_key and v.ndim == 2:
                     lowercase	:		str    =   v.shape[0] * v.shape[1]
                     lowercase	:		List[str]    =   v.reshape(lowerCamelCase   )

              if "weight" in torch_key and "out" in torch_key:
                     lowercase	:		Union[str, Any]    =   (v.shape[0] * v.shape[1], v.shape[2])
                     lowercase	:		Union[str, Any]    =   v.reshape(lowerCamelCase   ).T

              if "weight" in torch_key and "out" not in torch_key:
                     lowercase	:		Optional[int]    =   (v.shape[0], v.shape[1] * v.shape[2])
                     lowercase	:		List[Any]    =   v.reshape(lowerCamelCase   ).T

              # Copy flax CLIP attn params to HF PyTorch params
              lowercase	:		List[str]    =   torch.from_numpy(lowerCamelCase   )
              hf_backbone.state_dict()[torch_key].copy_(lowerCamelCase   )




def 		a_(			lowerCamelCase   )					->Any:






       '''simple docstring'''




       lowercase	:		Union[str, Any]    =   {}
       lowercase	:		Union[str, Any]    =   []

       for k, v in params.items():
              if "attn." in k:
                     lowercase	:		Union[str, Any]    =   k[: k.rindex('''attn.'''   ) + 5]
                     if base in processed_attn_layers:
                            continue

                     processed_attn_layers.append(lowerCamelCase   )
                     lowercase	:		Dict    =   params[base + '''out.weight'''].shape[-1]
                     lowercase	:		Union[str, Any]    =   params[base + '''out.weight'''].reshape(lowerCamelCase ,					lowerCamelCase   ).T
                     lowercase	:		List[str]    =   params[base + '''out.bias''']
              else:
                     lowercase	:		Dict    =   v
       return new_params




def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->Dict:






       '''simple docstring'''




       lowercase	:		Tuple    =   CLIP(**lowerCamelCase   )
       torch_model.eval()
       lowercase	:		Any    =   torch_model.state_dict()

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

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

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

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

              lowercase	:		str    =   v

       lowercase	:		Tuple    =   _convert_attn_layers(lowerCamelCase   )
       new_torch_params.update(lowerCamelCase   )
       lowercase	:		Union[str, Any]    =   {}

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

       return torch_clip_params, torch_model, attn_params




@torch.no_grad()
def 		a_(			lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase ,					lowerCamelCase=None   )					->Tuple:






       '''simple docstring'''




       lowercase	:		List[str]    =   Repository(lowerCamelCase ,					clone_from=f"""google/{pytorch_dump_folder_path}"""   )
       repo.git_pull()

       if config_path is not None:
              lowercase	:		Any    =   OwlViTConfig.from_pretrained(lowerCamelCase   )
       else:
              lowercase	:		Optional[int]    =   OwlViTConfig()

       lowercase	:		Any    =   OwlViTModel(lowerCamelCase   ).eval()
       lowercase	:		str    =   OwlViTForObjectDetection(lowerCamelCase   ).eval()

       copy_text_model_and_projection(lowerCamelCase ,					lowerCamelCase   )
       copy_vision_model_and_projection(lowerCamelCase ,					lowerCamelCase   )
       lowercase	:		Any    =   pt_backbone.logit_scale
       copy_flax_attn_params(lowerCamelCase ,					lowerCamelCase   )

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

       # Initialize processor
       lowercase	:		Tuple    =   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__":
      lowercase						:   Optional[Any]      						=							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.'''
      )
      lowercase						:   Optional[int]      						=							parser.parse_args()

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

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

      convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)




