






"""simple docstring"""



__A		:       str  				=		tuple[float, float, float]
__A		:       str  				=		tuple[float, float, float]



def 						lowercase    (				__snake_case				: Pointad		,					__snake_case				: Pointad	):
		lowercase_ : List[Any]							       =   end_pointa[0] - end_pointa[0]
		lowercase_ : List[Any]							       =   end_pointa[1] - end_pointa[1]
		lowercase_ : List[str]							       =   end_pointa[2] - end_pointa[2]
		return (x, y, z)



def 						lowercase    (				__snake_case				: Vectorad		,					__snake_case				: Vectorad	):
		lowercase_ : Any							       =   ab[1] * ac[2] - ab[2] * ac[1]  # *i
		lowercase_ : Optional[Any]							       =   (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
		lowercase_ : int							       =   ab[0] * ac[1] - ab[1] * ac[0]  # *k
		return (x, y, z)



def 						lowercase    (				__snake_case				: Vectorad		,					__snake_case				: int	):
		return tuple(round(__snake_case		,					__snake_case	) for x in vector	) == (0, 0, 0)






def 						lowercase    (				__snake_case				: Pointad		,					__snake_case				: Pointad		,					__snake_case				: Pointad		,					__snake_case				: int = 1_0	):
		lowercase_ : Any							       =   create_vector(__snake_case		,					__snake_case	)
		lowercase_ : Any							       =   create_vector(__snake_case		,					__snake_case	)
		return is_zero_vector(get_ad_vectors_cross(__snake_case		,					__snake_case	)		,					__snake_case	)






import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

def 						UpperCamelCase					(lowercase_: int    ,      lowercase_: Dict    ,      lowercase_: Tuple					)     ->      Any:
	# Construct model
	if gpta_config_file == "":
		A__							:    Dict        =		GPTaConfig()
	else:
		A__							:    List[Any]        =		GPTaConfig.from_json_file(lowercase_					)
	A__							:    Tuple        =		GPTaModel(lowercase_					)

	# Load weights from numpy
	load_tf_weights_in_gpta(lowercase_    ,      lowercase_    ,      lowercase_					)

	# Save pytorch-model
	A__							:    Optional[Any]        =		pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
	A__							:    Optional[Any]        =		pytorch_dump_folder_path + """/""" + CONFIG_NAME
	print(f"""Save PyTorch model to {pytorch_weights_dump_path}"""					)
	torch.save(model.state_dict()    ,      lowercase_					)
	print(f"""Save configuration file to {pytorch_config_dump_path}"""					)
	with open(lowercase_    ,      """w"""    ,      encoding="""utf-8"""					) as f:
		f.write(config.to_json_string()					)


if __name__ == "__main__":
	A_       : Union[str, Any]         =			argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--gpt2_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
	)
	parser.add_argument(
	    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
	)
	parser.add_argument(
	    '--gpt2_config_file',
	    default='',
	    type=str,
	    help=(
	        'An optional config json file corresponding to the pre-trained OpenAI model. \n'
	        'This specifies the model architecture.'
	    ),
	)
	A_       : str         =			parser.parse_args()
	convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)



