





import argparse

import torch

from transformers import ChineseCLIPConfig, ChineseCLIPModel
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case      )    ->		Union[str, Any]:


   '''simple docstring'''







   __A   ,		__A   ,		__A    =  pt_weights[F"{prefix}.in_proj_weight"].chunk(3							,			dim=0      )
   __A   ,		__A   ,		__A    =  pt_weights[F"{prefix}.in_proj_bias"].chunk(3							,			dim=0      )

   __A    =  pt_weights[F"{prefix}.out_proj.weight"]
   __A    =  pt_weights[F"{prefix}.out_proj.bias"]

   __A    =  q_proj
   __A    =  q_proj_bias

   __A    =  k_proj
   __A    =  k_proj_bias

   __A    =  v_proj
   __A    =  v_proj_bias

   __A    =  out_proj_weights
   __A    =  out_proj_bias
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case      )    ->		Tuple:


   '''simple docstring'''







   copy_linear(hf_mlp.fca							,			_A							,			F"{prefix}.c_fc"      )
   copy_linear(hf_mlp.fca							,			_A							,			F"{prefix}.c_proj"      )
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case      )    ->		Any:


   '''simple docstring'''







   __A    =  pt_weights[F"{prefix}.weight"].data
   __A    =  pt_weights[F"{prefix}.bias"].data
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case      )    ->		Any:


   '''simple docstring'''







   copy_linear(hf_layer.layer_norma							,			_A							,			F"{prefix}.ln_1"      )
   copy_linear(hf_layer.layer_norma							,			_A							,			F"{prefix}.ln_2"      )

   # copy MLP
   copy_mlp(hf_layer.mlp							,			_A							,			F"{prefix}.mlp"      )

   # copy attn
   copy_attn_layer(hf_layer.self_attn							,			_A							,			F"{prefix}.attn"      )
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case      )    ->		Any:


   '''simple docstring'''







   for layer_id, hf_layer in enumerate(_A      ):
      copy_layer(_A							,			_A							,			F"{prefix}.{layer_id}"      )
def  __UpperCamelCase    (						snake_case							,			snake_case      )    ->		Optional[int]:


   '''simple docstring'''







   __A    =  pt_weights['''text_projection'''].data.T

   # copy text encoder
   for name, param in hf_model.text_model.named_parameters():
      __A    =  pt_weights[F"bert.{name}"].data
def  __UpperCamelCase    (						snake_case							,			snake_case      )    ->		Optional[int]:


   '''simple docstring'''







   __A    =  pt_weights['''visual.proj'''].data.T

   # copy layer norms
   copy_linear(hf_model.vision_model.pre_layrnorm							,			_A							,			'''visual.ln_pre'''      )
   copy_linear(hf_model.vision_model.post_layernorm							,			_A							,			'''visual.ln_post'''      )

   # copy embeddings
   __A    =  pt_weights['''visual.conv1.weight'''].data
   __A    =  pt_weights['''visual.class_embedding'''].data
   __A    =  pt_weights['''visual.positional_embedding'''].data

   # copy encoder
   copy_layers(hf_model.vision_model.encoder.layers							,			_A							,			'''visual.transformer.resblocks'''      )
@torch.no_grad()
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case=None      )    ->		Optional[int]:


   '''simple docstring'''







   assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
   __A    =  ChineseCLIPConfig.from_pretrained(_A      )

   __A    =  ChineseCLIPModel(_A      ).eval()

   __A    =  torch.load(_A							,			map_location='''cpu'''      )['''state_dict''']
   __A    =  {(name[7:] if name.startswith('''module.'''      ) else name): value for name, value in pt_weights.items()}

   copy_text_model_and_projection(_A							,			_A      )
   copy_vision_model_and_projection(_A							,			_A      )
   __A    =  pt_weights['''logit_scale'''].data

   hf_model.save_pretrained(_A      )


if __name__ == "__main__":
    _UpperCamelCase       :				int           =			argparse.ArgumentParser()
    parser.add_argument(
        """--pytorch_dump_folder_path""",
        default=None,
        type=str,
        help="""Path to the output folder storing converted hf PyTorch model.""",
    )
    parser.add_argument(
        """--checkpoint_path""", default=None, type=str, help="""Path to original github format ChineseCLIP checkpoint."""
    )
    parser.add_argument(
        """--config_path""", default=None, required=True, type=str, help="""Path to hf config.json of model to convert."""
    )
    _UpperCamelCase       :				Any           =			parser.parse_args()

    convert_chinese_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
    print("""The conversion is finished!""")




def      UpperCAmelCase__							(     _A :					Optional[int]      , _A :					Optional[int]				):





  '''simple docstring'''







  sequence.append(_A				)

  a__    =0
  while sequence[index] != target:
    index += 1

  sequence.pop()

  if index == len(_A				):
    return None

  return index


if __name__ == "__main__":
       lowerCamelCase 	=   input('''Enter numbers separated by comma:\n''').strip()
       lowerCamelCase 	=   [int(item) for item in user_input.split(''',''')]

       lowerCamelCase 	=   input('''Enter a single number to be found in the list:\n''')
       lowerCamelCase 	=   int(target_input)
       lowerCamelCase 	=   sentinel_linear_search(sequence, target)
       if result is not None:
              print(f"""{target} found at positions: {result}""")
       else:
              print('''Not found''')
