
import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel

def a__   (	A_,					A_ ):






  '''simple docstring'''





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

  __magic_name__    					=	pt_attn_layer.out_proj.weight
  __magic_name__    					=	pt_attn_layer.out_proj.bias

  __magic_name__    					=	q_proj
  __magic_name__    					=	q_proj_bias

  __magic_name__    					=	k_proj
  __magic_name__    					=	k_proj_bias

  __magic_name__    					=	v_proj
  __magic_name__    					=	v_proj_bias

  __magic_name__    					=	out_proj_weights
  __magic_name__    					=	out_proj_bias

def a__   (	A_,					A_ ):






  '''simple docstring'''





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

def a__   (	A_,					A_ ):






  '''simple docstring'''





  __magic_name__    					=	pt_linear.weight
  __magic_name__    					=	pt_linear.bias

def a__   (	A_,					A_ ):






  '''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__   (	A_,					A_ ):






  '''simple docstring'''





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

def a__   (	A_,					A_ ):






  '''simple docstring'''





  __magic_name__    					=	pt_model.token_embedding.weight
  __magic_name__    					=	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__   (	A_,					A_ ):






  '''simple docstring'''





  __magic_name__    					=	pt_model.text_projection.data.T

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

def a__   (	A_,					A_ ):






  '''simple docstring'''





  __magic_name__    					=	pt_model.visual.proj.data.T

  # copy layer norms
  copy_linear(hf_model.vision_model.pre_layrnorm,					pt_model.visual.ln_pre )
  copy_linear(hf_model.vision_model.post_layernorm,					pt_model.visual.ln_post )

  # copy embeds
  __magic_name__    					=	pt_model.visual.conva.weight.data
  __magic_name__    					=	pt_model.visual.class_embedding
  __magic_name__    					=	pt_model.visual.positional_embedding.data

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

@torch.no_grad()
def a__   (	A_,					A_,					A_=None ):






  '''simple docstring'''





  if config_path is not None:
    __magic_name__    					=	CLIPConfig.from_pretrained(A_ )
  else:
    __magic_name__    					=	CLIPConfig(projection_dim=512,					text_config={},					vision_config={} )

  __magic_name__    					=	CLIPModel(A_ ).eval()

  __magic_name__					,   __magic_name__    					=	load(A_,					device="""cpu""",					jit=A_ )
  __magic_name__    					=	pt_model.eval()

  copy_text_model_and_projection(A_,					A_ )
  copy_vison_model_and_projection(A_,					A_ )
  __magic_name__    					=	pt_model.logit_scale

  __magic_name__    					=	torch.arange(0,					77 ).unsqueeze(0 )
  __magic_name__    					=	torch.randn(1,					3,					224,					224 )

  __magic_name__    					=	hf_model(input_ids=A_,					pixel_values=A_,					return_dict=A_ )
  __magic_name__    					=	hf_outputs.logits_per_image
  __magic_name__    					=	hf_outputs.logits_per_text
  __magic_name__					,   __magic_name__    					=	pt_model(A_,					A_ )

  assert torch.allclose(A_,					A_,					atol=1e-3 )
  assert torch.allclose(A_,					A_,					atol=1e-3 )

  hf_model.save_pretrained(A_ )


if __name__ == "__main__":
    __lowerCAmelCase      :					Tuple   	=       argparse.ArgumentParser()
    parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
    parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint')
    parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
    __lowerCAmelCase      :					Union[str, Any]   	=       parser.parse_args()

    convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)



def a__   (	A_ ):






  '''simple docstring'''





  __magic_name__    					=	str(A_ ).strip()
  if not bin_string:
    raise ValueError("""Empty string was passed to the function""" )
  __magic_name__    					=	bin_string[0] == """-"""
  if is_negative:
    __magic_name__    					=	bin_string[1:]
  if not all(char in """01""" for char in bin_string ):
    raise ValueError("""Non-binary value was passed to the function""" )
  __magic_name__    					=	0
  for char in bin_string:
    __magic_name__    					=	2 * decimal_number + int(A_ )
  return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
    from doctest import testmod

    testmod()

