





'''simple docstring'''






import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
lowerCAmelCase       		=      data_utils.TransfoXLTokenizer
lowerCAmelCase       		=      data_utils.TransfoXLCorpus
lowerCAmelCase       		=      data_utils
lowerCAmelCase       		=      data_utils






def      __A						(							a_						:  Any      ,a_						:  Optional[int]      ,a_						:  Dict      ,a_						:  Union[str, Any]	):
						if transfo_xl_dataset_file:
												# Convert a pre-processed corpus (see original TensorFlow repo)
												with open(_SCREAMING_SNAKE_CASE      ,"rb"	) as fp:
																		lowerCAmelCase     :    Optional[Any]						=   pickle.load(_SCREAMING_SNAKE_CASE      ,encoding="latin1"	)
												# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
												lowerCAmelCase     :    Dict						=   pytorch_dump_folder_path + "/" + VOCAB_FILES_NAMES["pretrained_vocab_file"]
												print(f'''Save vocabulary to {pytorch_vocab_dump_path}'''	)
												lowerCAmelCase     :    List[str]						=   corpus.vocab.__dict__
												torch.save(_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE	)

												lowerCAmelCase     :    Dict						=   corpus.__dict__
												corpus_dict_no_vocab.pop("vocab"      ,_SCREAMING_SNAKE_CASE	)
												lowerCAmelCase     :    Tuple						=   pytorch_dump_folder_path + "/" + CORPUS_NAME
												print(f'''Save dataset to {pytorch_dataset_dump_path}'''	)
												torch.save(_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE	)

						if tf_checkpoint_path:
												# Convert a pre-trained TensorFlow model
												lowerCAmelCase     :    str						=   os.path.abspath(_SCREAMING_SNAKE_CASE	)
												lowerCAmelCase     :    str						=   os.path.abspath(_SCREAMING_SNAKE_CASE	)

												print(f'''Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'''	)
												# Initialise PyTorch model
												if transfo_xl_config_file == "":
																		lowerCAmelCase     :    Optional[int]						=   TransfoXLConfig()
												else:
																		lowerCAmelCase     :    Optional[int]						=   TransfoXLConfig.from_json_file(_SCREAMING_SNAKE_CASE	)
												print(f'''Building PyTorch model from configuration: {config}'''	)
												lowerCAmelCase     :    Any						=   TransfoXLLMHeadModel(_SCREAMING_SNAKE_CASE	)

												lowerCAmelCase     :    Union[str, Any]						=   load_tf_weights_in_transfo_xl(_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE	)
												# Save pytorch-model
												lowerCAmelCase     :    Tuple						=   os.path.join(_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE	)
												lowerCAmelCase     :    List[Any]						=   os.path.join(_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE	)
												print(f'''Save PyTorch model to {os.path.abspath(_SCREAMING_SNAKE_CASE	)}'''	)
												torch.save(model.state_dict()      ,_SCREAMING_SNAKE_CASE	)
												print(f'''Save configuration file to {os.path.abspath(_SCREAMING_SNAKE_CASE	)}'''	)
												with open(_SCREAMING_SNAKE_CASE      ,"w"      ,encoding="utf-8"	) as f:
																		f.write(config.to_json_string()	)


if __name__ == "__main__":
					lowerCAmelCase       		=      argparse.ArgumentParser()
					parser.add_argument(
					    """--pytorch_dump_folder_path""",
					    default=None,
					    type=str,
					    required=True,
					    help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
					)
					parser.add_argument(
					    """--tf_checkpoint_path""",
					    default="""""",
					    type=str,
					    help="""An optional path to a TensorFlow checkpoint path to be converted.""",
					)
					parser.add_argument(
					    """--transfo_xl_config_file""",
					    default="""""",
					    type=str,
					    help=(
					        """An optional config json file corresponding to the pre-trained BERT model. \n"""
					        """This specifies the model architecture."""
					    ),
					)
					parser.add_argument(
					    """--transfo_xl_dataset_file""",
					    default="""""",
					    type=str,
					    help="""An optional dataset file to be converted in a vocabulary.""",
					)
					lowerCAmelCase       		=      parser.parse_args()
					convert_transfo_xl_checkpoint_to_pytorch(
					    args.tf_checkpoint_path,
					    args.transfo_xl_config_file,
					    args.pytorch_dump_folder_path,
					    args.transfo_xl_dataset_file,
					)










'''simple docstring'''






import numpy as np






def      __A						(							a_						:  np.array	):
		return (2 / (1 + np.exp(-2 * vector	))) - 1


if __name__ == "__main__":
					import doctest

					doctest.testmod()



