






import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
  UpperCamelCase_   ,UpperCamelCase_   ,UpperCamelCase_:      Dict					   =       pt_attn_layer.in_proj_weight.chunk(3			,					dim=0						)
  UpperCamelCase_   ,UpperCamelCase_   ,UpperCamelCase_:      Optional[Any]					   =       pt_attn_layer.in_proj_bias.chunk(3			,					dim=0						)

  UpperCamelCase_:      int					   =       pt_attn_layer.out_proj.weight
  UpperCamelCase_:      Union[str, Any]					   =       pt_attn_layer.out_proj.bias

  UpperCamelCase_:      List[Any]					   =       q_proj
  UpperCamelCase_:      Tuple					   =       q_proj_bias

  UpperCamelCase_:      List[str]					   =       k_proj
  UpperCamelCase_:      Dict					   =       k_proj_bias

  UpperCamelCase_:      Tuple					   =       v_proj
  UpperCamelCase_:      Optional[int]					   =       v_proj_bias

  UpperCamelCase_:      Union[str, Any]					   =       out_proj_weights
  UpperCamelCase_:      Dict					   =       out_proj_bias

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Optional[int]:
  copy_linear(hf_mlp.fca			,					pt_mlp.c_fc						)
  copy_linear(hf_mlp.fca			,					pt_mlp.c_proj						)

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Optional[Any]:
  UpperCamelCase_:      Tuple					   =       pt_linear.weight
  UpperCamelCase_:      Dict					   =       pt_linear.bias

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       str:
  # 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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       List[Any]:
  for hf_layer, pt_layer in zip(UpperCAmelCase__			,					UpperCAmelCase__						):
    copy_layer(UpperCAmelCase__			,					UpperCAmelCase__						)

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
  # copy  embeds
  UpperCamelCase_:      int					   =       pt_model.token_embedding.weight
  UpperCamelCase_:      Union[str, Any]					   =       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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
  # copy projection
  UpperCamelCase_:      Optional[Any]					   =       pt_model.text_projection.data.T

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

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Any:
  # copy projection
  UpperCamelCase_:      List[str]					   =       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
  UpperCamelCase_:      Optional[int]					   =       pt_model.visual.conva.weight.data
  UpperCamelCase_:      Optional[int]					   =       pt_model.visual.class_embedding
  UpperCamelCase_:      int					   =       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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__			,					UpperCAmelCase__=None						) ->       Dict:
  if config_path is not None:
    UpperCamelCase_:      Tuple					   =       CLIPConfig.from_pretrained(UpperCAmelCase__						)
  else:
    UpperCamelCase_:      List[Any]					   =       CLIPConfig(projection_dim=5_1_2			,					text_config={}			,					vision_config={}						)

  UpperCamelCase_:      Any					   =       CLIPModel(UpperCAmelCase__						).eval()

  UpperCamelCase_   ,UpperCamelCase_:      Any					   =       load(UpperCAmelCase__			,					device='cpu'			,					jit=UpperCAmelCase__						)
  UpperCamelCase_:      Any					   =       pt_model.eval()

  copy_text_model_and_projection(UpperCAmelCase__			,					UpperCAmelCase__						)
  copy_vison_model_and_projection(UpperCAmelCase__			,					UpperCAmelCase__						)
  UpperCamelCase_:      List[Any]					   =       pt_model.logit_scale

  UpperCamelCase_:      List[Any]					   =       torch.arange(0			,					7_7						).unsqueeze(0						)
  UpperCamelCase_:      int					   =       torch.randn(1			,					3			,					2_2_4			,					2_2_4						)

  UpperCamelCase_:      int					   =       hf_model(input_ids=UpperCAmelCase__			,					pixel_values=UpperCAmelCase__			,					return_dict=UpperCAmelCase__						)
  UpperCamelCase_:      Union[str, Any]					   =       hf_outputs.logits_per_image
  UpperCamelCase_:      Union[str, Any]					   =       hf_outputs.logits_per_text
  UpperCamelCase_   ,UpperCamelCase_:      List[str]					   =       pt_model(UpperCAmelCase__			,					UpperCAmelCase__						)

  assert torch.allclose(UpperCAmelCase__			,					UpperCAmelCase__			,					atol=1E-3						)
  assert torch.allclose(UpperCAmelCase__			,					UpperCAmelCase__			,					atol=1E-3						)

  hf_model.save_pretrained(UpperCAmelCase__						)


if __name__ == "__main__":
   A_	:	List[Any]				=				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_	:	str				=				parser.parse_args()

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







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A_	:	List[Any]				=				{
    'configuration_openai': ['OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OpenAIGPTConfig'],
    'tokenization_openai': ['OpenAIGPTTokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	List[str]				=				['OpenAIGPTTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	Any				=				[
       'OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'OpenAIGPTDoubleHeadsModel',
       'OpenAIGPTForSequenceClassification',
       'OpenAIGPTLMHeadModel',
       'OpenAIGPTModel',
       'OpenAIGPTPreTrainedModel',
       'load_tf_weights_in_openai_gpt',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	str				=				[
       'TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFOpenAIGPTDoubleHeadsModel',
       'TFOpenAIGPTForSequenceClassification',
       'TFOpenAIGPTLMHeadModel',
       'TFOpenAIGPTMainLayer',
       'TFOpenAIGPTModel',
       'TFOpenAIGPTPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
   from .tokenization_openai import OpenAIGPTTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_openai_fast import OpenAIGPTTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_openai import (
          OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          OpenAIGPTDoubleHeadsModel,
          OpenAIGPTForSequenceClassification,
          OpenAIGPTLMHeadModel,
          OpenAIGPTModel,
          OpenAIGPTPreTrainedModel,
          load_tf_weights_in_openai_gpt,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_openai import (
          TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFOpenAIGPTDoubleHeadsModel,
          TFOpenAIGPTForSequenceClassification,
          TFOpenAIGPTLMHeadModel,
          TFOpenAIGPTMainLayer,
          TFOpenAIGPTModel,
          TFOpenAIGPTPreTrainedModel,
      )

else:
   import sys

   A_	:	str				=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)