






"""simple docstring"""



import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    List[str]						,   __snake_case     :    Any       ):





  '''simple docstring'''





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

  lowercase				       =			pt_attn_layer.out_proj.weight
  lowercase				       =			pt_attn_layer.out_proj.bias

  lowercase				       =			q_proj
  lowercase				       =			q_proj_bias

  lowercase				       =			k_proj
  lowercase				       =			k_proj_bias

  lowercase				       =			v_proj
  lowercase				       =			v_proj_bias

  lowercase				       =			out_proj_weights
  lowercase				       =			out_proj_bias
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Dict						,   __snake_case     :    str       ):





  '''simple docstring'''





  copy_linear(hf_mlp.fca						,   pt_mlp.c_fc       )
  copy_linear(hf_mlp.fca						,   pt_mlp.c_proj       )
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Dict						,   __snake_case     :    Tuple       ):





  '''simple docstring'''





  lowercase				       =			pt_linear.weight
  lowercase				       =			pt_linear.bias
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Union[str, Any]						,   __snake_case     :    Optional[int]       ):





  '''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 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    int						,   __snake_case     :    Union[str, Any]       ):





  '''simple docstring'''





  for hf_layer, pt_layer in zip(__snake_case						,   __snake_case       ):
    copy_layer(__snake_case						,   __snake_case       )
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Optional[int]						,   __snake_case     :    Any       ):





  '''simple docstring'''





  lowercase				       =			pt_model.token_embedding.weight
  lowercase				       =			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 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Optional[Any]						,   __snake_case     :    List[str]       ):





  '''simple docstring'''





  lowercase				       =			pt_model.text_projection.data.T

  # copy text encoder
  copy_encoder(hf_model.text_model						,   __snake_case       )
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Dict						,   __snake_case     :    List[Any]       ):





  '''simple docstring'''





  lowercase				       =			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
  lowercase				       =			pt_model.visual.conva.weight.data
  lowercase				       =			pt_model.visual.class_embedding
  lowercase				       =			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 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    Any						,   __snake_case     :    Any						,   __snake_case     :    int=None       ):





  '''simple docstring'''





  if config_path is not None:
    lowercase				       =			CLIPConfig.from_pretrained(__snake_case       )
  else:
    lowercase				       =			CLIPConfig(projection_dim=5_12						,   text_config={}						,   vision_config={}       )

  lowercase				       =			CLIPModel(__snake_case       ).eval()

  lowercase       ,	lowercase				       =			load(__snake_case						,   device='cpu'						,   jit=__snake_case       )
  lowercase				       =			pt_model.eval()

  copy_text_model_and_projection(__snake_case						,   __snake_case       )
  copy_vison_model_and_projection(__snake_case						,   __snake_case       )
  lowercase				       =			pt_model.logit_scale

  lowercase				       =			torch.arange(0						,   77       ).unsqueeze(0       )
  lowercase				       =			torch.randn(1						,   3						,   2_24						,   2_24       )

  lowercase				       =			hf_model(input_ids=__snake_case						,   pixel_values=__snake_case						,   return_dict=__snake_case       )
  lowercase				       =			hf_outputs.logits_per_image
  lowercase				       =			hf_outputs.logits_per_text
  lowercase       ,	lowercase				       =			pt_model(__snake_case						,   __snake_case       )

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

  hf_model.save_pretrained(__snake_case       )


if __name__ == "__main__":
    _UpperCamelCase						:    int		=						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')
    _UpperCamelCase						:    Dict		=						parser.parse_args()

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



"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


lowerCAmelCase_:       List[str]			     =       logging.get_logger(__name__)






class  a__     ( _a						):
   snake_case_				=   "speech-encoder-decoder"
   snake_case_				=   True


   def __init__(  self,					**_UpperCAmelCase	):
        '''simple docstring'''



        super().__init__(**_UpperCAmelCase	)
        if "encoder" not in kwargs or "decoder" not in kwargs:
             raise ValueError(
                 F'''A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'''
                 F''' `decoder` sub-configurations are passed, but only {kwargs}'''	)

        lowercase__								=				kwargs.pop("encoder"	)
        lowercase__								=				encoder_config.pop("model_type"	)
        lowercase__								=				kwargs.pop("decoder"	)
        lowercase__								=				decoder_config.pop("model_type"	)

        lowercase__								=				AutoConfig.for_model(_UpperCAmelCase,					**_UpperCAmelCase	)
        lowercase__								=				AutoConfig.for_model(_UpperCAmelCase,					**_UpperCAmelCase	)
        lowercase__								=				True


   @classmethod
   def 						snake_case__						(  cls,					_UpperCAmelCase,					_UpperCAmelCase,					**_UpperCAmelCase	):
        '''simple docstring'''



        logger.info("Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"	)
        lowercase__								=				True
        lowercase__								=				True

        return cls(encoder=encoder_config.to_dict(),					decoder=decoder_config.to_dict(),					**_UpperCAmelCase	)


   def 						snake_case__						(  self	):
        '''simple docstring'''



        lowercase__								=				copy.deepcopy(self.__dict__	)
        lowercase__								=				self.encoder.to_dict()
        lowercase__								=				self.decoder.to_dict()
        lowercase__								=				self.__class__.model_type
        return output




