


def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      List[str]	)     ->	List[str]:



	"""simple docstring"""






	a_     			=   [701, 301, 132, 57, 23, 10, 4, 1]
	for gap in gaps:
		for i in range(UpperCAmelCase_     ,					len(UpperCAmelCase_	)	):
			a_     			=   collection[i]
			a_     			=   i
			while j >= gap and collection[j - gap] > insert_value:
				a_     			=   collection[j - gap]
				j -= gap
			if j != i:
				a_     			=   insert_value
	return collection


if __name__ == "__main__":
			from doctest import testmod

			testmod()
			_A							     =       input('Enter numbers separated by a comma:\n').strip()
			_A							     =       [int(item) for item in user_input.split(',')]
			print(shell_sort(unsorted))


import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel






def        lowerCamelCase_  (				UpperCAmelCase_				:  Optional[int]				,							UpperCAmelCase_				:  Tuple						)    ->					str:




	'''simple docstring'''




	_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase :		Tuple								=    pt_attn_layer.in_proj_weight.chunk(3				,							dim=0						)
	_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase :		str								=    pt_attn_layer.in_proj_bias.chunk(3				,							dim=0						)

	_UpperCamelCase :		Dict								=    pt_attn_layer.out_proj.weight
	_UpperCamelCase :		Tuple								=    pt_attn_layer.out_proj.bias

	_UpperCamelCase :		Tuple								=    q_proj
	_UpperCamelCase :		Dict								=    q_proj_bias

	_UpperCamelCase :		Dict								=    k_proj
	_UpperCamelCase :		str								=    k_proj_bias

	_UpperCamelCase :		Dict								=    v_proj
	_UpperCamelCase :		Optional[int]								=    v_proj_bias

	_UpperCamelCase :		Any								=    out_proj_weights
	_UpperCamelCase :		Optional[int]								=    out_proj_bias






def        lowerCamelCase_  (				UpperCAmelCase_				:  Optional[int]				,							UpperCAmelCase_				:  Union[str, Any]						)    ->					List[Any]:




	'''simple docstring'''




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






def        lowerCamelCase_  (				UpperCAmelCase_				:  List[str]				,							UpperCAmelCase_				:  List[str]						)    ->					List[Any]:




	'''simple docstring'''




	_UpperCamelCase :		int								=    pt_linear.weight
	_UpperCamelCase :		int								=    pt_linear.bias






def        lowerCamelCase_  (				UpperCAmelCase_				:  str				,							UpperCAmelCase_				:  Union[str, Any]						)    ->					Dict:




	'''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        lowerCamelCase_  (				UpperCAmelCase_				:  Optional[Any]				,							UpperCAmelCase_				:  List[str]						)    ->					Dict:




	'''simple docstring'''




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






def        lowerCamelCase_  (				UpperCAmelCase_				:  Any				,							UpperCAmelCase_				:  Optional[Any]						)    ->					int:




	'''simple docstring'''




	_UpperCamelCase :		Optional[int]								=    pt_model.token_embedding.weight
	_UpperCamelCase :		Tuple								=    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        lowerCamelCase_  (				UpperCAmelCase_				:  int				,							UpperCAmelCase_				:  Tuple						)    ->					Union[str, Any]:




	'''simple docstring'''




	_UpperCamelCase :		Any								=    pt_model.text_projection.data.T

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






def        lowerCamelCase_  (				UpperCAmelCase_				:  str				,							UpperCAmelCase_				:  Dict						)    ->					Optional[int]:




	'''simple docstring'''




	_UpperCamelCase :		str								=    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
	_UpperCamelCase :		Tuple								=    pt_model.visual.conva.weight.data
	_UpperCamelCase :		Dict								=    pt_model.visual.class_embedding
	_UpperCamelCase :		str								=    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        lowerCamelCase_  (				UpperCAmelCase_				:  Dict				,							UpperCAmelCase_				:  str				,							UpperCAmelCase_				:  List[str]=None						)    ->					Union[str, Any]:




	'''simple docstring'''




	if config_path is not None:
		_UpperCamelCase :		Dict								=    CLIPConfig.from_pretrained(UpperCAmelCase_						)
	else:
		_UpperCamelCase :		Tuple								=    CLIPConfig(projection_dim=5_1_2				,							text_config={}				,							vision_config={}						)

	_UpperCamelCase :		Tuple								=    CLIPModel(UpperCAmelCase_						).eval()

	_UpperCamelCase						,		_UpperCamelCase :		Optional[Any]								=    load(UpperCAmelCase_				,							device='cpu'				,							jit=UpperCAmelCase_						)
	_UpperCamelCase :		Optional[Any]								=    pt_model.eval()

	copy_text_model_and_projection(UpperCAmelCase_				,							UpperCAmelCase_						)
	copy_vison_model_and_projection(UpperCAmelCase_				,							UpperCAmelCase_						)
	_UpperCamelCase :		Optional[Any]								=    pt_model.logit_scale

	_UpperCamelCase :		Optional[int]								=    torch.arange(0				,							7_7						).unsqueeze(0						)
	_UpperCamelCase :		Dict								=    torch.randn(1				,							3				,							2_2_4				,							2_2_4						)

	_UpperCamelCase :		Optional[Any]								=    hf_model(input_ids=UpperCAmelCase_				,							pixel_values=UpperCAmelCase_				,							return_dict=UpperCAmelCase_						)
	_UpperCamelCase :		Optional[Any]								=    hf_outputs.logits_per_image
	_UpperCamelCase :		Optional[int]								=    hf_outputs.logits_per_text
	_UpperCamelCase						,		_UpperCamelCase :		int								=    pt_model(UpperCAmelCase_				,							UpperCAmelCase_						)

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

	hf_model.save_pretrained(UpperCAmelCase_						)


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

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




