


'''simple docstring'''





import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch


def        a__     (					UpperCamelCase_						:      Dict						):
   UpperCAmelCase__	:Optional[Any]      =      os.path.join(args.tf_model_dir,   '''parameters.json'''						)
   UpperCAmelCase__	: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'''						):
      UpperCAmelCase__	:Any      =      args.output + '''.pt'''
   UpperCAmelCase__	:Optional[Any]      =      OrderedDict()
   with tf.device('''/CPU:0'''						):
      UpperCAmelCase__	:Optional[Any]      =      tf.train.load_checkpoint(args.tf_model_dir						)
      UpperCAmelCase__	:List[str]      =      reader.get_variable_to_shape_map()
      for key_name in shapes.keys():
         UpperCAmelCase__	:Optional[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'''						):
               UpperCAmelCase__	:Dict      =      int(key_name[9]						)
            elif key_name.startswith('''pasts/out'''						):
               UpperCAmelCase__	:Union[str, Any]      =      8
            UpperCAmelCase__	:Any      =      '''model.sqout.%d.weight''' % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
            UpperCAmelCase__	:Union[str, Any]      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
            UpperCAmelCase__	:List[str]      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/moe'''						):
            UpperCAmelCase__	:Optional[Any]      =      int(key_name[9:].split('''/'''						)[0]						)
            if key_name.endswith('''/switch_gating/kernel'''						):
               UpperCAmelCase__	:Optional[Any]      =      '''model.blocks.%d.feed_forward.mlp.router.classifier.weight''' % player
               UpperCAmelCase__	:Union[str, Any]      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
               UpperCAmelCase__	:List[Any]      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/softmlp/kernel'''						):
               UpperCAmelCase__	:int      =      '''model.blocks.%d.feed_forward.soft_bypass_mlp.weight''' % player
               UpperCAmelCase__	:Dict      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
               UpperCAmelCase__	:Optional[int]      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/wo/kernel'''						) or key_name.endswith('''/wi/kernel'''						):
               UpperCAmelCase__	:str      =      key_name[-9:-7]
               for i in range(16						):
                  UpperCAmelCase__	:Union[str, Any]      =      '''model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight''' % (player, i, nlayer)
                  UpperCAmelCase__	:Any      =      (
                      vnp[i].transpose([1, 0]						).copy()
                  )  # In Mesh-Tensorflow, it is one array, so it is divided
                  UpperCAmelCase__	:int      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/mlp'''						):
            UpperCAmelCase__	:Dict      =      int(key_name[9:].split('''/'''						)[0]						)
            if key_name.endswith('''/p1/kernel'''						):
               UpperCAmelCase__	:int      =      '''model.blocks.%d.feed_forward.mlp.wi.weight''' % player
               UpperCAmelCase__	:str      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
               UpperCAmelCase__	:Optional[Any]      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/p1/bias'''						):
               UpperCAmelCase__	:Optional[int]      =      '''model.blocks.%d.feed_forward.mlp.wi.bias''' % player
               UpperCAmelCase__	:Union[str, Any]      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:Any      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/p2/kernel'''						):
               UpperCAmelCase__	:Tuple      =      '''model.blocks.%d.feed_forward.mlp.wo.weight''' % player
               UpperCAmelCase__	:Tuple      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
               UpperCAmelCase__	:Union[str, Any]      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/p2/bias'''						):
               UpperCAmelCase__	:Tuple      =      '''model.blocks.%d.feed_forward.mlp.wo.bias''' % player
               UpperCAmelCase__	:List[Any]      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:List[str]      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/ln'''						):
            UpperCAmelCase__	:Optional[int]      =      int(key_name[8:].split('''/'''						)[0]						)
            if key_name.endswith('''/b'''						):
               UpperCAmelCase__	:int      =      '''model.blocks.%d.feed_forward.norm.bias''' % player
               UpperCAmelCase__	:Optional[int]      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:List[Any]      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/g'''						):
               UpperCAmelCase__	:Optional[Any]      =      '''model.blocks.%d.feed_forward.norm.weight''' % player
               UpperCAmelCase__	:Any      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:List[Any]      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/att'''						):
            UpperCAmelCase__	:Dict      =      int(key_name[9:].split('''/'''						)[0]						)
            if key_name.endswith('''/qkv/kernel'''						):
               UpperCAmelCase__	:Any      =      vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
               UpperCAmelCase__	:Dict      =      state[:, 0, :, :]
               UpperCAmelCase__	:str      =      state[:, 1, :, :]
               UpperCAmelCase__	:str      =      state[:, 2, :, :]
               UpperCAmelCase__	: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
               UpperCAmelCase__	:Union[str, Any]      =      (
                   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
               UpperCAmelCase__	: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
               UpperCAmelCase__	:int      =      '''model.blocks.%d.self_attn.self_attn.q_proj.weight''' % player
               UpperCAmelCase__	:Optional[Any]      =      torch.tensor(UpperCamelCase_						)
               UpperCAmelCase__	:List[str]      =      '''model.blocks.%d.self_attn.self_attn.k_proj.weight''' % player
               UpperCAmelCase__	:Optional[Any]      =      torch.tensor(UpperCamelCase_						)
               UpperCAmelCase__	:Optional[int]      =      '''model.blocks.%d.self_attn.self_attn.v_proj.weight''' % player
               UpperCAmelCase__	:Tuple      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/o/kernel'''						):
               UpperCAmelCase__	:Dict      =      '''model.blocks.%d.self_attn.self_attn.out_proj.weight''' % player
               UpperCAmelCase__	:Dict      =      (
                   vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]						).transpose([1, 0]						).copy()
               )  # Mesh-Tensorflow is a diagonal matrix
               UpperCAmelCase__	:int      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/an'''						):
            UpperCAmelCase__	:Optional[Any]      =      int(key_name[8:].split('''/'''						)[0]						)
            if key_name.endswith('''/b'''						):
               UpperCAmelCase__	:Union[str, Any]      =      '''model.blocks.%d.self_attn.norm.bias''' % player
               UpperCAmelCase__	:Dict      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:Any      =      torch.tensor(UpperCamelCase_						)
            elif key_name.endswith('''/g'''						):
               UpperCAmelCase__	:Dict      =      '''model.blocks.%d.self_attn.norm.weight''' % player
               UpperCAmelCase__	:Tuple      =      vnp.copy()  # same because it is one dimensional
               UpperCAmelCase__	:List[str]      =      torch.tensor(UpperCamelCase_						)
         elif (
             key_name.startswith('''model/wte'''						)
             or key_name.startswith('''model/wpe'''						)
             or key_name.startswith('''model/ete'''						)
         ):
            UpperCAmelCase__	:List[str]      =      {'''wte''': '''embed_tokens''', '''wpe''': '''position_embeddings''', '''ete''': '''extra_position_embeddings'''}[
                key_name[-3:]
            ]
            UpperCAmelCase__	:Optional[int]      =      '''model.%s.weight''' % nlayer
            UpperCAmelCase__	:Any      =      vnp.copy()  # same in embedded
            UpperCAmelCase__	:str      =      torch.tensor(UpperCamelCase_						)
            if key_name.startswith('''model/wte'''						):
               UpperCAmelCase__	:int      =      '''lm_head.weight'''
               UpperCAmelCase__	:Any      =      vnp.copy()  # same in embedded
               UpperCAmelCase__	:Any      =      torch.tensor(UpperCamelCase_						)
         elif key_name.startswith('''model/wob'''						):
            UpperCAmelCase__	:List[str]      =      '''final_logits_bias'''
            UpperCAmelCase__	:List[Any]      =      vnp.copy()  # same in embedded
            UpperCAmelCase__	:List[Any]      =      state.reshape((1, -1)						)
            UpperCAmelCase__	:Optional[Any]      =      torch.tensor(UpperCamelCase_						)
         elif key_name == "model/dense/kernel":
            UpperCAmelCase__	:List[Any]      =      '''model.last_project.weight'''
            UpperCAmelCase__	:Any      =      vnp.transpose([1, 0]						).copy()  # Mesh-Tensorflow is a diagonal matrix
            UpperCAmelCase__	:Union[str, Any]      =      torch.tensor(UpperCamelCase_						)
         elif key_name == "model/dense_1/bias":
            UpperCAmelCase__	:Union[str, Any]      =      '''model.last_project.bias'''
            UpperCAmelCase__	:str      =      vnp.copy()  # same because it is one dimensional
            UpperCAmelCase__	:Optional[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'''





def        a__     (					UpperCamelCase_						:      int | float | str						):
   try:
      UpperCAmelCase__	:Union[str, Any]      =      float(UpperCamelCase_						)
   except ValueError:
      raise ValueError('''Please enter a valid number'''						)
   UpperCAmelCase__	:List[str]      =      decimal - int(UpperCamelCase_						)
   if fractional_part == 0:
      return int(UpperCamelCase_						), 1
   else:
      UpperCAmelCase__	:List[Any]      =      len(str(UpperCamelCase_						).split('''.'''						)[1]						)
      UpperCAmelCase__	:Tuple      =      int(decimal * (10**number_of_frac_digits)						)
      UpperCAmelCase__	:int      =      10**number_of_frac_digits
      UpperCAmelCase__   ,						UpperCAmelCase__	:List[str]      =      denominator, numerator
      while True:
         UpperCAmelCase__	:Optional[Any]      =      dividend % divisor
         if remainder == 0:
            break
         UpperCAmelCase__   ,						UpperCAmelCase__	:List[str]      =      divisor, remainder
      UpperCAmelCase__   ,						UpperCAmelCase__	:Tuple      =      numerator / divisor, denominator / divisor
      return int(UpperCamelCase_						), int(UpperCamelCase_						)


if __name__ == "__main__":
    print(F'''{decimal_to_fraction(2) = }''')
    print(F'''{decimal_to_fraction(89.0) = }''')
    print(F'''{decimal_to_fraction("67") = }''')
    print(F'''{decimal_to_fraction("45.0") = }''')
    print(F'''{decimal_to_fraction(1.5) = }''')
    print(F'''{decimal_to_fraction("6.25") = }''')
    print(F'''{decimal_to_fraction("78td") = }''')



