






"""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


_UpperCamelCase    :   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       snake_case  (A_				:Optional[int]     ,      A_				:int     ,      A_				:Union[str, Any]     ,      A_				:List[Any]=None				):







  '''simple docstring'''

  _A					:      Any    =       XLNetConfig.from_json_file(A__				)

  _A					:      Union[str, Any]    =       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}'''				)
    _A					:      Any    =       finetuning_task
    _A					:      int    =       GLUE_TASKS_NUM_LABELS[finetuning_task]
    _A					:      Union[str, Any]    =       XLNetForSequenceClassification(A__				)
  elif "squad" in finetuning_task:
    _A					:      Dict    =       finetuning_task
    _A					:      Optional[Any]    =       XLNetForQuestionAnswering(A__				)
  else:
    _A					:      Dict    =       XLNetLMHeadModel(A__				)

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

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


if __name__ == "__main__":
   _UpperCamelCase    :   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',
   )
   _UpperCamelCase    :   Union[str, 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 os
import sys

_UpperCamelCase    :   str   			=						os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


_UpperCamelCase    :   int   			=						[
    'torch',
    'numpy',
    'tokenizers',
    'filelock',
    'requests',
    'tqdm',
    'regex',
    'sentencepiece',
    'sacremoses',
    'importlib_metadata',
    'huggingface_hub',
]




@add_start_docstrings(AutoConfig.__doc__				)
def       snake_case  (*A_				:Optional[int]     ,      **A_				:int				):







  '''simple docstring'''

  return AutoConfig.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoTokenizer.__doc__				)
def       snake_case  (*A_				:Optional[int]     ,      **A_				:List[Any]				):







  '''simple docstring'''

  return AutoTokenizer.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModel.__doc__				)
def       snake_case  (*A_				:Optional[Any]     ,      **A_				:Tuple				):







  '''simple docstring'''

  return AutoModel.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForCausalLM.__doc__				)
def       snake_case  (*A_				:str     ,      **A_				:Optional[int]				):







  '''simple docstring'''

  return AutoModelForCausalLM.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForMaskedLM.__doc__				)
def       snake_case  (*A_				:Optional[Any]     ,      **A_				:Dict				):







  '''simple docstring'''

  return AutoModelForMaskedLM.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForSequenceClassification.__doc__				)
def       snake_case  (*A_				:Dict     ,      **A_				:str				):







  '''simple docstring'''

  return AutoModelForSequenceClassification.from_pretrained(*A_     ,      **A_				)






@add_start_docstrings(AutoModelForQuestionAnswering.__doc__				)
def       snake_case  (*A_				:Dict     ,      **A_				:List[Any]				):







  '''simple docstring'''

  return AutoModelForQuestionAnswering.from_pretrained(*A_     ,      **A_				)




