

'''simple docstring'''

from collections import Counter




def  UpperCamelCase(	UpperCAmelCase_      ):
 return sum(socks_by_color // 2 for socks_by_color in Counter(UpperCAmelCase_      ).values()      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 lowercase__            =     [int(x) for x in input("Enter socks by color :").rstrip().split()]
 print(f'''sock_merchant({colors}) = {sock_merchant(colors)}''')







'''simple docstring'''

import argparse

import torch

from transformers import ChineseCLIPConfig, ChineseCLIPModel




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 UpperCAmelCase   ,					UpperCAmelCase   ,					UpperCAmelCase			:      Optional[Any]		   =					pt_weights[F"""{prefix}.in_proj_weight"""].chunk(3    ,			dim=0      )
 UpperCAmelCase   ,					UpperCAmelCase   ,					UpperCAmelCase			:      str		   =					pt_weights[F"""{prefix}.in_proj_bias"""].chunk(3    ,			dim=0      )

 UpperCAmelCase			:      Dict		   =					pt_weights[F"""{prefix}.out_proj.weight"""]
 UpperCAmelCase			:      Tuple		   =					pt_weights[F"""{prefix}.out_proj.bias"""]

 UpperCAmelCase			:      Dict		   =					q_proj
 UpperCAmelCase			:      Optional[Any]		   =					q_proj_bias

 UpperCAmelCase			:      Union[str, Any]		   =					k_proj
 UpperCAmelCase			:      Optional[Any]		   =					k_proj_bias

 UpperCAmelCase			:      Dict		   =					v_proj
 UpperCAmelCase			:      Tuple		   =					v_proj_bias

 UpperCAmelCase			:      List[Any]		   =					out_proj_weights
 UpperCAmelCase			:      Any		   =					out_proj_bias




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 copy_linear(hf_mlp.fca    ,			UpperCAmelCase_    ,			F"""{prefix}.c_fc"""      )
 copy_linear(hf_mlp.fca    ,			UpperCAmelCase_    ,			F"""{prefix}.c_proj"""      )




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 UpperCAmelCase			:      Tuple		   =					pt_weights[F"""{prefix}.weight"""].data
 UpperCAmelCase			:      Dict		   =					pt_weights[F"""{prefix}.bias"""].data




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 # copy layer norms
 copy_linear(hf_layer.layer_norma    ,			UpperCAmelCase_    ,			F"""{prefix}.ln_1"""      )
 copy_linear(hf_layer.layer_norma    ,			UpperCAmelCase_    ,			F"""{prefix}.ln_2"""      )

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

 # copy attn
 copy_attn_layer(hf_layer.self_attn    ,			UpperCAmelCase_    ,			F"""{prefix}.attn"""      )




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 for layer_id, hf_layer in enumerate(UpperCAmelCase_      ):
  copy_layer(UpperCAmelCase_    ,			UpperCAmelCase_    ,			F"""{prefix}.{layer_id}"""      )




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 # copy projection
 UpperCAmelCase			:      Optional[int]		   =					pt_weights['text_projection'].data.T

 # copy text encoder
 for name, param in hf_model.text_model.named_parameters():
  UpperCAmelCase			:      int		   =					pt_weights[F"""bert.{name}"""].data




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 # copy projection
 UpperCAmelCase			:      Optional[int]		   =					pt_weights['visual.proj'].data.T

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

 # copy embeddings
 UpperCAmelCase			:      List[str]		   =					pt_weights['visual.conv1.weight'].data
 UpperCAmelCase			:      Tuple		   =					pt_weights['visual.class_embedding'].data
 UpperCAmelCase			:      str		   =					pt_weights['visual.positional_embedding'].data

 # copy encoder
 copy_layers(hf_model.vision_model.encoder.layers    ,			UpperCAmelCase_    ,			'visual.transformer.resblocks'      )




@torch.no_grad()
def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_=None      ):
 assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
 UpperCAmelCase			:      str		   =					ChineseCLIPConfig.from_pretrained(UpperCAmelCase_      )

 UpperCAmelCase			:      List[Any]		   =					ChineseCLIPModel(UpperCAmelCase_      ).eval()

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

 copy_text_model_and_projection(UpperCAmelCase_    ,			UpperCAmelCase_      )
 copy_vision_model_and_projection(UpperCAmelCase_    ,			UpperCAmelCase_      )
 UpperCAmelCase			:      Optional[int]		   =					pt_weights['logit_scale'].data

 hf_model.save_pretrained(UpperCAmelCase_      )


if __name__ == "__main__":
 lowercase__            =     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."
 )
 lowercase__            =     parser.parse_args()

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




