


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


SCREAMING_SNAKE_CASE       :		Tuple         =				{
    "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     UpperCamelCase    (      _a       ,		_a       ,		_a       ,		_a=None		)					->							Optional[int]:
     '''simple docstring'''





     lowercase_       :Dict     =       XLNetConfig.from_json_file(_a		)

     lowercase_       :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}"		)
          lowercase_       :List[str]     =       finetuning_task
          lowercase_       :Optional[Any]     =       GLUE_TASKS_NUM_LABELS[finetuning_task]
          lowercase_       :str     =       XLNetForSequenceClassification(_a		)
     elif "squad" in finetuning_task:
          lowercase_       :Tuple     =       finetuning_task
          lowercase_       :List[str]     =       XLNetForQuestionAnswering(_a		)
     else:
          lowercase_       :List[Any]     =       XLNetLMHeadModel(_a		)

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

     # Save pytorch-model
     lowercase_       :str     =       os.path.join(_a       ,		_a		)
     lowercase_       :str     =       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__":
   SCREAMING_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",
   )
   SCREAMING_SNAKE_CASE       :		Tuple         =				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
   )





from torch import nn




def     UpperCamelCase    (      _a		)					->							str:
     '''simple docstring'''





     if act_fn in ["swish", "silu"]:
          return nn.SiLU()
     elif act_fn == "mish":
          return nn.Mish()
     elif act_fn == "gelu":
          return nn.GELU()
     else:
          raise ValueError(f"Unsupported activation function: {act_fn}"		)

