






"""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'''

def 				UpperCamelCase__      (      a__ = 1_0_0_0   ):


						'''simple docstring'''






						_lowerCAmelCase					    =[]
						_lowerCAmelCase					    =[]
						_lowerCAmelCase					    =3
						_lowerCAmelCase					    =5
						_lowerCAmelCase					    =1
						while True:
												_lowerCAmelCase					    =z * temp
												if result < n:
																		zmulti.append(a__   )
																		temp += 1
												else:
																		_lowerCAmelCase					    =1
																		break
						while True:
												_lowerCAmelCase					    =x * temp
												if result < n:
																		xmulti.append(a__   )
																		temp += 1
												else:
																		break
						_lowerCAmelCase					    =list(set(xmulti + zmulti   )   )
						return sum(a__   )


if __name__ == "__main__":
							print(F'{solution() = }')





