






"""simple docstring"""







import unittest

from transformers import AlbertTokenizer, AlbertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


lowerCAmelCase_	:    List[str]            =      get_tests_dir('''fixtures/spiece.model''')





@require_sentencepiece
@require_tokenizers
class   UpperCamelCase_ (       a_   ,					unittest.TestCase  ):
  _A       :					Optional[Any]				=	AlbertTokenizer
  _A       :					Optional[int]				=	AlbertTokenizerFast
  _A       :					List[Any]				=	True
  _A       :					List[str]				=	True
  _A       :					Dict				=	True



  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         super().setUp()

         # We have a SentencePiece fixture for testing
         UpperCAmelCase	    =			AlbertTokenizer(snake_case__				)
         tokenizer.save_pretrained(self.tmpdirname				)



  def 		UpperCamelCase_				(      self ,		snake_case__				)			->			Union[str, Any]:



         """simple docstring"""





         UpperCAmelCase	    =			"""this is a test"""
         UpperCAmelCase	    =			"""this is a test"""
         return input_text, output_text



  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			"""<pad>"""
         UpperCAmelCase	    =			0

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case__				) ,		snake_case__				)
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case__				) ,		snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         UpperCAmelCase	    =			list(self.get_tokenizer().get_vocab().keys()				)

         self.assertEqual(vocab_keys[0] ,		"""<pad>"""				)
         self.assertEqual(vocab_keys[1] ,		"""<unk>"""				)
         self.assertEqual(vocab_keys[-1] ,		"""▁eloquent"""				)
         self.assertEqual(len(snake_case__				) ,		3_00_00				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         self.assertEqual(self.get_tokenizer().vocab_size ,		3_00_00				)



  def 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         if not self.test_rust_tokenizer:
                return

         UpperCAmelCase	    =			self.get_tokenizer()
         UpperCAmelCase	    =			self.get_rust_tokenizer()

         UpperCAmelCase	    =			"""I was born in 92000, and this is falsé."""

         UpperCAmelCase	    =			tokenizer.tokenize(snake_case__				)
         UpperCAmelCase	    =			rust_tokenizer.tokenize(snake_case__				)
         self.assertListEqual(snake_case__ ,		snake_case__				)

         UpperCAmelCase	    =			tokenizer.encode(snake_case__ ,		add_special_tokens=snake_case__				)
         UpperCAmelCase	    =			rust_tokenizer.encode(snake_case__ ,		add_special_tokens=snake_case__				)
         self.assertListEqual(snake_case__ ,		snake_case__				)

         UpperCAmelCase	    =			self.get_rust_tokenizer()
         UpperCAmelCase	    =			tokenizer.encode(snake_case__				)
         UpperCAmelCase	    =			rust_tokenizer.encode(snake_case__				)
         self.assertListEqual(snake_case__ ,		snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase	    =			AlbertTokenizer(snake_case__ ,		keep_accents=snake_case__				)

         UpperCAmelCase	    =			tokenizer.tokenize("""This is a test"""				)
         self.assertListEqual(snake_case__ ,		["""▁this""", """▁is""", """▁a""", """▁test"""]				)

         self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__				) ,		[48, 25, 21, 12_89]				)

         UpperCAmelCase	    =			tokenizer.tokenize("""I was born in 92000, and this is falsé."""				)
         self.assertListEqual(
             snake_case__ ,		["""▁i""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """é""", """."""]				)
         UpperCAmelCase	    =			tokenizer.convert_tokens_to_ids(snake_case__				)
         self.assertListEqual(snake_case__ ,		[31, 23, 3_86, 19, 5_61, 30_50, 15, 17, 48, 25, 82_56, 18, 1, 9]				)

         UpperCAmelCase	    =			tokenizer.convert_ids_to_tokens(snake_case__				)
         self.assertListEqual(
             snake_case__ ,		["""▁i""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """."""] ,		)



  def 		UpperCamelCase_				(      self				)			->			Any:



         """simple docstring"""





         UpperCAmelCase	    =			AlbertTokenizer(snake_case__				)

         UpperCAmelCase	    =			tokenizer.encode("""sequence builders"""				)
         UpperCAmelCase	    =			tokenizer.encode("""multi-sequence build"""				)

         UpperCAmelCase	    =			tokenizer.build_inputs_with_special_tokens(snake_case__				)
         UpperCAmelCase	    =			tokenizer.build_inputs_with_special_tokens(snake_case__ ,		snake_case__				)

         assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
         assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
             tokenizer.sep_token_id
         ]



  @slow
  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			{"""attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """input_ids""": [[2, 2_19_70, 13, 5, 60_92, 1_67, 28, 71_03, 21_53, 6_73, 8, 70_28, 1_20_51, 18, 17, 71_03, 21_53, 6_73, 8, 35_15, 1_86_84, 8, 44_61, 6, 19_27, 2_97, 8, 1_20_60, 26_07, 18, 13, 5, 44_61, 15, 1_05_38, 38, 8, 1_35, 15, 8_22, 58, 15, 9_93, 1_03_63, 15, 14_60, 80_05, 44_61, 15, 9_93, 2_55, 23_28, 9, 9, 9, 6, 26, 11_12, 8_16, 32_60, 13, 5, 1_03, 23_77, 6, 17, 11_12, 8_16, 27_82, 13, 5, 1_03, 1_06_41, 6, 29, 84, 25_12, 24_30, 7_82, 1_86_84, 27_61, 19, 8_08, 24_30, 25_56, 17, 8_55, 14_80, 94_77, 40_91, 1_28, 1_17_12, 15, 71_03, 21_53, 6_73, 17, 2_48_83, 99_90, 9, 3], [2, 1_15_02, 25, 10_06, 20, 7_82, 8, 1_18_09, 8_55, 17_32, 1_93_93, 1_86_67, 37, 3_67, 2_10_18, 69, 18_54, 34, 1_18_60, 1_91_24, 27, 1_56, 2_25, 17, 1_93, 41_41, 19, 65, 91_24, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 14, 22_31, 8_86, 23_85, 1_76_59, 84, 14, 1_67_92, 19_52, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """token_type_ids""": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=snake_case__ ,		model_name="""albert-base-v2""" ,		revision="""6b6560eaf5ff2e250b00c50f380c5389a9c2d82e""" ,		)








"""simple docstring"""







import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch






def       _lowerCAmelCase       (      lowerCAmelCase		):







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


if __name__ == "__main__":
 lowerCAmelCase_	:    Union[str, Any]            =      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_	:    Any            =      parser.parse_args()
 convert_tf_gptsan_to_pt(args)
