



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
__snake_case     :Optional[int]			       =data_utils.TransfoXLTokenizer
__snake_case     :List[str]			       =data_utils.TransfoXLCorpus
__snake_case     :List[str]			       =data_utils
__snake_case     :List[Any]			       =data_utils






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Tuple			,	lowerCAmelCase__	:	Any				)       ->							Tuple:

							'''simple docstring'''






							if transfo_xl_dataset_file:
														# Convert a pre-processed corpus (see original TensorFlow repo)
														with open(lowerCAmelCase__			,	'rb'				) as fp:
																					A      						=    pickle.load(lowerCAmelCase__			,	encoding='latin1'				)
														# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
														A      						=    pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
														print(F'''Save vocabulary to {pytorch_vocab_dump_path}'''				)
														A      						=    corpus.vocab.__dict__
														torch.save(lowerCAmelCase__			,	lowerCAmelCase__				)

														A      						=    corpus.__dict__
														corpus_dict_no_vocab.pop('vocab'			,	lowerCAmelCase__				)
														A      						=    pytorch_dump_folder_path + '/' + CORPUS_NAME
														print(F'''Save dataset to {pytorch_dataset_dump_path}'''				)
														torch.save(lowerCAmelCase__			,	lowerCAmelCase__				)

							if tf_checkpoint_path:
														# Convert a pre-trained TensorFlow model
														A      						=    os.path.abspath(lowerCAmelCase__				)
														A      						=    os.path.abspath(lowerCAmelCase__				)

														print(F'''Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'''				)
														# Initialise PyTorch model
														if transfo_xl_config_file == "":
																					A      						=    TransfoXLConfig()
														else:
																					A      						=    TransfoXLConfig.from_json_file(lowerCAmelCase__				)
														print(F'''Building PyTorch model from configuration: {config}'''				)
														A      						=    TransfoXLLMHeadModel(lowerCAmelCase__				)

														A      						=    load_tf_weights_in_transfo_xl(lowerCAmelCase__			,	lowerCAmelCase__			,	lowerCAmelCase__				)
														# Save pytorch-model
														A      						=    os.path.join(lowerCAmelCase__			,	lowerCAmelCase__				)
														A      						=    os.path.join(lowerCAmelCase__			,	lowerCAmelCase__				)
														print(F'''Save PyTorch model to {os.path.abspath(lowerCAmelCase__				)}'''				)
														torch.save(model.state_dict()			,	lowerCAmelCase__				)
														print(F'''Save configuration file to {os.path.abspath(lowerCAmelCase__				)}'''				)
														with open(lowerCAmelCase__			,	'w'			,	encoding='utf-8'				) as f:
																					f.write(config.to_json_string()				)


if __name__ == "__main__":
				__snake_case     :Tuple			       =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.',
				)
				__snake_case     :Optional[int]			       =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,
				)




from ...configuration_utils import PretrainedConfig
from ...utils import logging


__snake_case     :List[str]			       =logging.get_logger(__name__)

__snake_case     :int			       ={'openai-gpt': 'https://huggingface.co/openai-gpt/resolve/main/config.json'}



class        lowerCAmelCase__					(  _lowerCamelCase       ):
				A_   :     Optional[Any]								=     'openai-gpt'
				A_   :     Any								=     {
				    'max_position_embeddings': 'n_positions',
				    'hidden_size': 'n_embd',
				    'num_attention_heads': 'n_head',
				    'num_hidden_layers': 'n_layer',
				}


				def __init__(							self      :  List[Any]						, __UpperCamelCase      :  List[str]=40_478						, __UpperCamelCase      :  List[Any]=512						, __UpperCamelCase      :  List[Any]=768						, __UpperCamelCase      :  Optional[int]=12						, __UpperCamelCase      :  Dict=12						, __UpperCamelCase      :  List[str]="gelu"						, __UpperCamelCase      :  str=0.1						, __UpperCamelCase      :  Optional[Any]=0.1						, __UpperCamelCase      :  Union[str, Any]=0.1						, __UpperCamelCase      :  List[str]=1e-5						, __UpperCamelCase      :  List[Any]=0.0_2						, __UpperCamelCase      :  str="cls_index"						, __UpperCamelCase      :  int=True						, __UpperCamelCase      :  int=None						, __UpperCamelCase      :  Optional[int]=True						, __UpperCamelCase      :  Tuple=0.1						, **__UpperCamelCase      :  List[Any]						, )		->     List[str]:
											A      						=    vocab_size
											A      						=    n_positions
											A      						=    n_embd
											A      						=    n_layer
											A      						=    n_head
											A      						=    afn
											A      						=    resid_pdrop
											A      						=    embd_pdrop
											A      						=    attn_pdrop
											A      						=    layer_norm_epsilon
											A      						=    initializer_range
											A      						=    summary_type
											A      						=    summary_use_proj
											A      						=    summary_activation
											A      						=    summary_first_dropout
											A      						=    summary_proj_to_labels
											super().__init__(**__UpperCamelCase       )