

def 						UpperCamelCase					(lowercase_: str    ,      lowercase_: Optional[int]					)     ->      Union[str, Any]:
	# "extended trapezoidal rule"
	# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
	A__							:    Optional[int]        =		(boundary[1] - boundary[0]) / steps
	A__							:    Dict        =		boundary[0]
	A__							:    int        =		boundary[1]
	A__							:    Tuple        =		make_points(lowercase_    ,      lowercase_    ,      lowercase_					)
	A__							:    Any        =		0.0
	y += (h / 2.0) * f(lowercase_					)
	for i in x_i:
		# print(i)
		y += h * f(lowercase_					)
	y += (h / 2.0) * f(lowercase_					)
	return y

def 						UpperCamelCase					(lowercase_: Optional[Any]    ,      lowercase_: int    ,      lowercase_: Dict					)     ->      Optional[int]:
	A__							:    Optional[Any]        =		a + h
	while x < (b - h):
		yield x
		A__							:    Union[str, Any]        =		x + h

def 						UpperCamelCase					(lowercase_: Optional[Any]					)     ->      List[Any]:  # enter your function here
	A__							:    Union[str, Any]        =		(x - 0) * (x - 0)
	return y

def 						UpperCamelCase					()     ->      List[str]:
	A__							:    int        =		0.0  # Lower bound of integration
	A__							:    Tuple        =		1.0  # Upper bound of integration
	A__							:    List[str]        =		10.0  # define number of steps or resolution
	A__							:    Optional[int]        =		[a, b]  # define boundary of integration
	A__							:    List[Any]        =		method_a(lowercase_    ,      lowercase_					)
	print(f"""y = {y}"""					)


if __name__ == "__main__":
	main()






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)



