


import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch




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






from math import pow




def        snake_case_					(  snake_case      ,							snake_case      ,							snake_case      ,							snake_case      ,							snake_case      ,							)  ->    tuple[int, int]:
       if current_sum == needed_sum:
              # If the sum of the powers is equal to needed_sum, then we have a solution.
              solutions_count += 1
              return current_sum, solutions_count

       lowercase__:       int        =       int(pow(snake_case      ,							snake_case					)					)
       if current_sum + i_to_n <= needed_sum:
              # If the sum of the powers is less than needed_sum, then continue adding powers.
              current_sum += i_to_n
              lowercase__      ,						lowercase__:       Any        =       backtrack(
                  snake_case      ,							snake_case      ,							current_number + 1      ,							snake_case      ,							snake_case					)
              current_sum -= i_to_n
       if i_to_n < needed_sum:
              # If the power of i is less than needed_sum, then try with the next power.
              lowercase__      ,						lowercase__:       Optional[int]        =       backtrack(
                  snake_case      ,							snake_case      ,							current_number + 1      ,							snake_case      ,							snake_case					)
       return current_sum, solutions_count




def        snake_case_					(  snake_case      ,							snake_case					)  ->    int:
       if not (1 <= needed_sum <= 10_00 and 2 <= power <= 10):
              raise ValueError(
                  'Invalid input\n'
                  'needed_sum must be between 1 and 1000, power between 2 and 10.'					)

       return backtrack(snake_case      ,							snake_case      ,							1      ,							0      ,							0					)[1]  # Return the solutions_count


if __name__ == "__main__":
 import doctest

 doctest.testmod()


