import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE  )->    Optional[Any]:
							_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    os.path.join(args.tf_model_dir     ,	"""parameters.json"""  )
							_SCREAMING_SNAKE_CASE		:						List[str]			  =    json.loads(open(__UpperCamelCase  ).read()  )
							if not params:
														raise ValueError(
														    F"""It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file."""  )
							if not args.output.endswith(""".pt"""  ):
														_SCREAMING_SNAKE_CASE		:						Dict			  =    args.output + '''.pt'''
							_SCREAMING_SNAKE_CASE		:						int			  =    OrderedDict()
							with tf.device("""/CPU:0"""  ):
														_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    tf.train.load_checkpoint(args.tf_model_dir  )
														_SCREAMING_SNAKE_CASE		:						List[str]			  =    reader.get_variable_to_shape_map()
														for key_name in shapes.keys():
																					_SCREAMING_SNAKE_CASE		:						int			  =    reader.get_tensor(__UpperCamelCase  ).astype(np.floataa  )
																					if key_name.endswith("""/adam_m"""  ) or key_name.endswith("""/adam_v"""  ):
																												continue
																					if key_name.startswith("""pasts/"""  ):
																												if key_name.startswith("""pasts/mlp"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    int(key_name[9]  )
																												elif key_name.startswith("""pasts/out"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Tuple			  =    8
																												_SCREAMING_SNAKE_CASE		:						Dict			  =    '''model.sqout.%d.weight''' % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
																												_SCREAMING_SNAKE_CASE		:						Dict			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																												_SCREAMING_SNAKE_CASE		:						Dict			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/moe"""  ):
																												_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    int(key_name[9:].split("""/"""  )[0]  )
																												if key_name.endswith("""/switch_gating/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    '''model.blocks.%d.feed_forward.mlp.router.classifier.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						List[str]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/softmlp/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    '''model.blocks.%d.feed_forward.soft_bypass_mlp.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/wo/kernel"""  ) or key_name.endswith("""/wi/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[str]			  =    key_name[-9:-7]
																																			for i in range(16  ):
																																										_SCREAMING_SNAKE_CASE		:						Dict			  =    '''model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight''' % (player, i, nlayer)
																																										_SCREAMING_SNAKE_CASE		:						List[Any]			  =    (
																																										    vnp[i].transpose([1, 0]  ).copy()
																																										)  # In Mesh-Tensorflow, it is one array, so it is divided
																																										_SCREAMING_SNAKE_CASE		:						List[Any]			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/mlp"""  ):
																												_SCREAMING_SNAKE_CASE		:						Tuple			  =    int(key_name[9:].split("""/"""  )[0]  )
																												if key_name.endswith("""/p1/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[str]			  =    '''model.blocks.%d.feed_forward.mlp.wi.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/p1/bias"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    '''model.blocks.%d.feed_forward.mlp.wi.bias''' % player
																																			_SCREAMING_SNAKE_CASE		:						Any			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						Tuple			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/p2/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						str			  =    '''model.blocks.%d.feed_forward.mlp.wo.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Dict			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/p2/bias"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    '''model.blocks.%d.feed_forward.mlp.wo.bias''' % player
																																			_SCREAMING_SNAKE_CASE		:						List[str]			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/ln"""  ):
																												_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    int(key_name[8:].split("""/"""  )[0]  )
																												if key_name.endswith("""/b"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    '''model.blocks.%d.feed_forward.norm.bias''' % player
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/g"""  ):
																																			_SCREAMING_SNAKE_CASE		:						List[str]			  =    '''model.blocks.%d.feed_forward.norm.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						Tuple			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/att"""  ):
																												_SCREAMING_SNAKE_CASE		:						Any			  =    int(key_name[9:].split("""/"""  )[0]  )
																												if key_name.endswith("""/qkv/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    state[:, 0, :, :]
																																			_SCREAMING_SNAKE_CASE		:						str			  =    state[:, 1, :, :]
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    state[:, 2, :, :]
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    (
																																			    state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]]  )
																																			    .transpose([1, 0]  )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    (
																																			    state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]]  )
																																			    .transpose([1, 0]  )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    (
																																			    state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]]  )
																																			    .transpose([1, 0]  )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    '''model.blocks.%d.self_attn.self_attn.q_proj.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    torch.tensor(__UpperCamelCase  )
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    '''model.blocks.%d.self_attn.self_attn.k_proj.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    torch.tensor(__UpperCamelCase  )
																																			_SCREAMING_SNAKE_CASE		:						Dict			  =    '''model.blocks.%d.self_attn.self_attn.v_proj.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Tuple			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/o/kernel"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    '''model.blocks.%d.self_attn.self_attn.out_proj.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    (
																																			    vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]  ).transpose([1, 0]  ).copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			_SCREAMING_SNAKE_CASE		:						List[Any]			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/an"""  ):
																												_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    int(key_name[8:].split("""/"""  )[0]  )
																												if key_name.endswith("""/b"""  ):
																																			_SCREAMING_SNAKE_CASE		:						int			  =    '''model.blocks.%d.self_attn.norm.bias''' % player
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    torch.tensor(__UpperCamelCase  )
																												elif key_name.endswith("""/g"""  ):
																																			_SCREAMING_SNAKE_CASE		:						int			  =    '''model.blocks.%d.self_attn.norm.weight''' % player
																																			_SCREAMING_SNAKE_CASE		:						int			  =    vnp.copy()  # same because it is one dimensional
																																			_SCREAMING_SNAKE_CASE		:						str			  =    torch.tensor(__UpperCamelCase  )
																					elif (
																					    key_name.startswith("""model/wte"""  )
																					    or key_name.startswith("""model/wpe"""  )
																					    or key_name.startswith("""model/ete"""  )
																					):
																												_SCREAMING_SNAKE_CASE		:						List[str]			  =    {'''wte''': '''embed_tokens''', '''wpe''': '''position_embeddings''', '''ete''': '''extra_position_embeddings'''}[
																												    key_name[-3:]
																												]
																												_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    '''model.%s.weight''' % nlayer
																												_SCREAMING_SNAKE_CASE		:						List[str]			  =    vnp.copy()  # same in embedded
																												_SCREAMING_SNAKE_CASE		:						int			  =    torch.tensor(__UpperCamelCase  )
																												if key_name.startswith("""model/wte"""  ):
																																			_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    '''lm_head.weight'''
																																			_SCREAMING_SNAKE_CASE		:						Any			  =    vnp.copy()  # same in embedded
																																			_SCREAMING_SNAKE_CASE		:						str			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name.startswith("""model/wob"""  ):
																												_SCREAMING_SNAKE_CASE		:						Any			  =    '''final_logits_bias'''
																												_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    vnp.copy()  # same in embedded
																												_SCREAMING_SNAKE_CASE		:						Dict			  =    state.reshape((1, -1)  )
																												_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name == "model/dense/kernel":
																												_SCREAMING_SNAKE_CASE		:						Any			  =    '''model.last_project.weight'''
																												_SCREAMING_SNAKE_CASE		:						str			  =    vnp.transpose([1, 0]  ).copy()  # Mesh-Tensorflow is a diagonal matrix
																												_SCREAMING_SNAKE_CASE		:						int			  =    torch.tensor(__UpperCamelCase  )
																					elif key_name == "model/dense_1/bias":
																												_SCREAMING_SNAKE_CASE		:						List[Any]			  =    '''model.last_project.bias'''
																												_SCREAMING_SNAKE_CASE		:						Any			  =    vnp.copy()  # same because it is one dimensional
																												_SCREAMING_SNAKE_CASE		:						int			  =    torch.tensor(__UpperCamelCase  )
							torch.save(__UpperCamelCase     ,	args.output  )


if __name__ == "__main__":
			lowerCAmelCase_     =	argparse.ArgumentParser(
			    description='''model converter.''', formatter_class=argparse.ArgumentDefaultsHelpFormatter
			)
			parser.add_argument('''--tf_model_dir''', metavar='''PATH''', type=str, required=True, help='''import model''')
			parser.add_argument('''--output''', metavar='''PATH''', type=str, required=True, help='''output model''')
			lowerCAmelCase_     =	parser.parse_args()
			convert_tf_gptsan_to_pt(args)



"""simple docstring"""





from decimal import Decimal, getcontext
from math import ceil, factorial



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE  )->    str:

							if not isinstance(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  ):
														raise TypeError("""Undefined for non-integers"""  )
							elif precision < 1:
														raise ValueError("""Undefined for non-natural numbers"""  )

							_SCREAMING_SNAKE_CASE		:						int			  =    precision
							_SCREAMING_SNAKE_CASE		:						Dict			  =    ceil(precision / 14  )
							_SCREAMING_SNAKE_CASE		:						int			  =    426_880 * Decimal(10_005  ).sqrt()
							_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    1
							_SCREAMING_SNAKE_CASE		:						str			  =    13_591_409
							_SCREAMING_SNAKE_CASE		:						Tuple			  =    Decimal(__SCREAMING_SNAKE_CASE  )
							for k in range(1     ,	__SCREAMING_SNAKE_CASE  ):
														_SCREAMING_SNAKE_CASE		:						Tuple			  =    factorial(6 * k  ) // (factorial(3 * k  ) * factorial(__SCREAMING_SNAKE_CASE  ) ** 3)
														linear_term += 545_140_134
														exponential_term *= -262_537_412_640_768_000
														partial_sum += Decimal(multinomial_term * linear_term  ) / exponential_term
							return str(constant_term / partial_sum  )[:-1]


if __name__ == "__main__":
			lowerCAmelCase_     =	50
			print(F"The first {n} digits of pi is: {pi(n)}")


