

import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel





def 							__a       (					__A ,       __A	):
    SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__					     =						pt_attn_layer.in_proj_weight.chunk(3 ,       dim=0	)
    SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__					     =						pt_attn_layer.in_proj_bias.chunk(3 ,       dim=0	)

    SCREAMING_SNAKE_CASE__					     =						pt_attn_layer.out_proj.weight
    SCREAMING_SNAKE_CASE__					     =						pt_attn_layer.out_proj.bias

    SCREAMING_SNAKE_CASE__					     =						q_proj
    SCREAMING_SNAKE_CASE__					     =						q_proj_bias

    SCREAMING_SNAKE_CASE__					     =						k_proj
    SCREAMING_SNAKE_CASE__					     =						k_proj_bias

    SCREAMING_SNAKE_CASE__					     =						v_proj
    SCREAMING_SNAKE_CASE__					     =						v_proj_bias

    SCREAMING_SNAKE_CASE__					     =						out_proj_weights
    SCREAMING_SNAKE_CASE__					     =						out_proj_bias





def 							__a       (					__A ,       __A	):
    copy_linear(hf_mlp.fca ,       pt_mlp.c_fc	)
    copy_linear(hf_mlp.fca ,       pt_mlp.c_proj	)





def 							__a       (					__A ,       __A	):
    SCREAMING_SNAKE_CASE__					     =						pt_linear.weight
    SCREAMING_SNAKE_CASE__					     =						pt_linear.bias





def 							__a       (					__A ,       __A	):
    # 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 							__a       (					__A ,       __A	):
    for hf_layer, pt_layer in zip(__A ,       __A	):
        copy_layer(__A ,       __A	)





def 							__a       (					__A ,       __A	):
    # copy  embeds
    SCREAMING_SNAKE_CASE__					     =						pt_model.token_embedding.weight
    SCREAMING_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 							__a       (					__A ,       __A	):
    # copy projection
    SCREAMING_SNAKE_CASE__					     =						pt_model.text_projection.data.T

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





def 							__a       (					__A ,       __A	):
    # copy projection
    SCREAMING_SNAKE_CASE__					     =						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
    SCREAMING_SNAKE_CASE__					     =						pt_model.visual.conva.weight.data
    SCREAMING_SNAKE_CASE__					     =						pt_model.visual.class_embedding
    SCREAMING_SNAKE_CASE__					     =						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	):
    if config_path is not None:
        SCREAMING_SNAKE_CASE__					     =						CLIPConfig.from_pretrained(__A	)
    else:
        SCREAMING_SNAKE_CASE__					     =						CLIPConfig(projection_dim=512 ,       text_config={} ,       vision_config={}	)

    SCREAMING_SNAKE_CASE__					     =						CLIPModel(__A	).eval()

    SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__					     =						load(__A ,       device="cpu" ,       jit=__A	)
    SCREAMING_SNAKE_CASE__					     =						pt_model.eval()

    copy_text_model_and_projection(__A ,       __A	)
    copy_vison_model_and_projection(__A ,       __A	)
    SCREAMING_SNAKE_CASE__					     =						pt_model.logit_scale

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

    SCREAMING_SNAKE_CASE__					     =						hf_model(input_ids=__A ,       pixel_values=__A ,       return_dict=__A	)
    SCREAMING_SNAKE_CASE__					     =						hf_outputs.logits_per_image
    SCREAMING_SNAKE_CASE__					     =						hf_outputs.logits_per_text
    SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__					     =						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__":
      A__        =			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")
      A__        =			parser.parse_args()

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





from collections import namedtuple

A__        =			namedtuple("from_to", "from_ to")

A__        =			{
    "atm": from_to(1, 1),
    "pascal": from_to(0.0_000_098, 10_1325),
    "bar": from_to(0.986_923, 1.01_325),
    "kilopascal": from_to(0.00_986_923, 101.325),
    "megapascal": from_to(9.86_923, 0.101_325),
    "psi": from_to(0.068_046, 14.6_959),
    "inHg": from_to(0.0_334_211, 29.9_213),
    "torr": from_to(0.00_131_579, 760),
}





def 							__a       (					__A ,       __A ,       __A	):
    if from_type not in PRESSURE_CONVERSION:
        raise ValueError(
            f"Invalid 'from_type' value: {from_type!r}  Supported values are:\n"
            + ", ".join(__A	)	)
    if to_type not in PRESSURE_CONVERSION:
        raise ValueError(
            f"Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"
            + ", ".join(__A	)	)
    return (
        value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
    )


if __name__ == "__main__":
  import doctest

  doctest.testmod()


