'''simple docstring'''

import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel







def 					UpperCamelCase_						( snake_case_	:	Optional[Any]						,		snake_case_	:	str				) ->					int:






 '''simple docstring'''

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

 __lowerCAmelCase    							=						pt_attn_layer.out_proj.weight
 __lowerCAmelCase    							=						pt_attn_layer.out_proj.bias

 __lowerCAmelCase    							=						q_proj
 __lowerCAmelCase    							=						q_proj_bias

 __lowerCAmelCase    							=						k_proj
 __lowerCAmelCase    							=						k_proj_bias

 __lowerCAmelCase    							=						v_proj
 __lowerCAmelCase    							=						v_proj_bias

 __lowerCAmelCase    							=						out_proj_weights
 __lowerCAmelCase    							=						out_proj_bias







def 					UpperCamelCase_						( snake_case_	:	Any						,		snake_case_	:	int				) ->					List[str]:






 '''simple docstring'''

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







def 					UpperCamelCase_						( snake_case_	:	Any						,		snake_case_	:	Any				) ->					Any:






 '''simple docstring'''

 __lowerCAmelCase    							=						pt_linear.weight
 __lowerCAmelCase    							=						pt_linear.bias







def 					UpperCamelCase_						( snake_case_	:	Optional[Any]						,		snake_case_	:	Any				) ->					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 					UpperCamelCase_						( snake_case_	:	Dict						,		snake_case_	:	Dict				) ->					Tuple:






 '''simple docstring'''

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







def 					UpperCamelCase_						( snake_case_	:	int						,		snake_case_	:	int				) ->					str:






 '''simple docstring'''

 __lowerCAmelCase    							=						pt_model.token_embedding.weight
 __lowerCAmelCase    							=						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 					UpperCamelCase_						( snake_case_	:	List[Any]						,		snake_case_	:	Union[str, Any]				) ->					Union[str, Any]:






 '''simple docstring'''

 __lowerCAmelCase    							=						pt_model.text_projection.data.T

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







def 					UpperCamelCase_						( snake_case_	:	Any						,		snake_case_	:	Optional[Any]				) ->					Optional[int]:






 '''simple docstring'''

 __lowerCAmelCase    							=						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
 __lowerCAmelCase    							=						pt_model.visual.conva.weight.data
 __lowerCAmelCase    							=						pt_model.visual.class_embedding
 __lowerCAmelCase    							=						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 					UpperCamelCase_						( snake_case_	:	Union[str, Any]						,		snake_case_	:	str						,		snake_case_	:	Union[str, Any]=None				) ->					List[Any]:






 '''simple docstring'''

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

 __lowerCAmelCase    							=						CLIPModel(snake_case_				).eval()

 __lowerCAmelCase							,	__lowerCAmelCase    							=						load(snake_case_						,		device="""cpu"""						,		jit=snake_case_				)
 __lowerCAmelCase    							=						pt_model.eval()

 copy_text_model_and_projection(snake_case_						,		snake_case_				)
 copy_vison_model_and_projection(snake_case_						,		snake_case_				)
 __lowerCAmelCase    							=						pt_model.logit_scale

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

 __lowerCAmelCase    							=						hf_model(input_ids=snake_case_						,		pixel_values=snake_case_						,		return_dict=snake_case_				)
 __lowerCAmelCase    							=						hf_outputs.logits_per_image
 __lowerCAmelCase    							=						hf_outputs.logits_per_text
 __lowerCAmelCase							,	__lowerCAmelCase    							=						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__":
 _A      :				Optional[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      :				Optional[Any] 				=    parser.parse_args()

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







'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


_A      :				Optional[int] 				=    {
    '''configuration_speech_to_text_2''': ['''SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Speech2Text2Config'''],
    '''processing_speech_to_text_2''': ['''Speech2Text2Processor'''],
    '''tokenization_speech_to_text_2''': ['''Speech2Text2Tokenizer'''],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _A      :				Any 				=    [
     '''SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''Speech2Text2ForCausalLM''',
     '''Speech2Text2PreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_speech_to_text_a import SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextaConfig
 from .processing_speech_to_text_a import SpeechaTextaProcessor
 from .tokenization_speech_to_text_a import SpeechaTextaTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_speech_to_text_a import (
      SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      SpeechaTextaForCausalLM,
      SpeechaTextaPreTrainedModel,
  )

else:
 import sys

 _A      :				Tuple 				=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






