



"""simple docstring"""






import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


__snake_case							:     List[str]   =     {
    'cola': 2,
    'mnli': 3,
    'mrpc': 2,
    'sst-2': 2,
    'sts-b': 1,
    'qqp': 2,
    'qnli': 2,
    'rte': 2,
    'wnli': 2,
}


logging.set_verbosity_info()


def     _lowercase       (						__snake_case      ,__snake_case      ,__snake_case      ,__snake_case=None			)		->     int:
			# Initialise PyTorch model
			__lowerCAmelCase   :						int				= XLNetConfig.from_json_file(__snake_case			)

			__lowerCAmelCase   :						Dict				= finetuning_task.lower() if finetuning_task is not None else ""
			if finetuning_task in GLUE_TASKS_NUM_LABELS:
						print(F"""Building PyTorch XLNetForSequenceClassification model from configuration: {config}"""			)
						__lowerCAmelCase   :						Any				= finetuning_task
						__lowerCAmelCase   :						Any				= GLUE_TASKS_NUM_LABELS[finetuning_task]
						__lowerCAmelCase   :						int				= XLNetForSequenceClassification(__snake_case			)
			elif "squad" in finetuning_task:
						__lowerCAmelCase   :						List[str]				= finetuning_task
						__lowerCAmelCase   :						str				= XLNetForQuestionAnswering(__snake_case			)
			else:
						__lowerCAmelCase   :						Any				= XLNetLMHeadModel(__snake_case			)

			# Load weights from tf checkpoint
			load_tf_weights_in_xlnet(__snake_case      ,__snake_case      ,__snake_case			)

			# Save pytorch-model
			__lowerCAmelCase   :						int				= os.path.join(__snake_case      ,__snake_case			)
			__lowerCAmelCase   :						Optional[int]				= os.path.join(__snake_case      ,__snake_case			)
			print(F"""Save PyTorch model to {os.path.abspath(__snake_case			)}"""			)
			torch.save(model.state_dict()      ,__snake_case			)
			print(F"""Save configuration file to {os.path.abspath(__snake_case			)}"""			)
			with open(__snake_case      ,"w"      ,encoding="utf-8"			) as f:
						f.write(config.to_json_string()			)


if __name__ == "__main__":
	__snake_case							:     Optional[int]   =     argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
	)
	parser.add_argument(
	    '--xlnet_config_file',
	    default=None,
	    type=str,
	    required=True,
	    help=(
	        'The config json file corresponding to the pre-trained XLNet model. \n'
	        'This specifies the model architecture.'
	    ),
	)
	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(
	    '--finetuning_task',
	    default=None,
	    type=str,
	    help='Name of a task on which the XLNet TensorFlow model was fine-tuned',
	)
	__snake_case							:     Optional[Any]   =     parser.parse_args()
	print(args)

	convert_xlnet_checkpoint_to_pytorch(
	    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
	)




"""simple docstring"""






import logging

from transformers.configuration_utils import PretrainedConfig


__snake_case							:     Tuple   =					logging.getLogger(__name__)



class     A__     (						__SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			'masked_bert'

	def __init__(  self:	str ,    _SCREAMING_SNAKE_CASE:	Tuple=3_0522 ,    _SCREAMING_SNAKE_CASE:	Optional[int]=768 ,    _SCREAMING_SNAKE_CASE:	List[str]=12 ,    _SCREAMING_SNAKE_CASE:	Any=12 ,    _SCREAMING_SNAKE_CASE:	Optional[int]=3072 ,    _SCREAMING_SNAKE_CASE:	List[str]="gelu" ,    _SCREAMING_SNAKE_CASE:	List[str]=0.1 ,    _SCREAMING_SNAKE_CASE:	str=0.1 ,    _SCREAMING_SNAKE_CASE:	Dict=512 ,    _SCREAMING_SNAKE_CASE:	List[Any]=2 ,    _SCREAMING_SNAKE_CASE:	Tuple=0.02 ,    _SCREAMING_SNAKE_CASE:	int=1e-12 ,    _SCREAMING_SNAKE_CASE:	int=0 ,    _SCREAMING_SNAKE_CASE:	Tuple="topK" ,    _SCREAMING_SNAKE_CASE:	Any="constant" ,    _SCREAMING_SNAKE_CASE:	int=0.0 ,    **_SCREAMING_SNAKE_CASE:	Any ,    )       -> List[str]:

				"""simple docstring"""

				super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE ,    **_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Union[str, Any]				= vocab_size
				__lowerCAmelCase   :						List[str]				= hidden_size
				__lowerCAmelCase   :						Any				= num_hidden_layers
				__lowerCAmelCase   :						Dict				= num_attention_heads
				__lowerCAmelCase   :						Union[str, Any]				= hidden_act
				__lowerCAmelCase   :						Optional[Any]				= intermediate_size
				__lowerCAmelCase   :						int				= hidden_dropout_prob
				__lowerCAmelCase   :						List[Any]				= attention_probs_dropout_prob
				__lowerCAmelCase   :						int				= max_position_embeddings
				__lowerCAmelCase   :						str				= type_vocab_size
				__lowerCAmelCase   :						Any				= initializer_range
				__lowerCAmelCase   :						Optional[int]				= layer_norm_eps
				__lowerCAmelCase   :						Tuple				= pruning_method
				__lowerCAmelCase   :						Union[str, Any]				= mask_init
				__lowerCAmelCase   :						str				= mask_scale