






"""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[Any]										= {
    """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					(    a :				List[str]       ,		a :				Optional[Any]       ,		a :				Optional[int]       ,		a :				Any=None )					->					int:
      # Initialise PyTorch model
      __snake_case      :    Union[str, Any]  			=XLNetConfig.from_json_file(a )

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

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

      # Save pytorch-model
      __snake_case      :    Union[str, Any]  			=os.path.join(a       ,		a )
      __snake_case      :    Optional[int]  			=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_	:				Dict										= 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_	:				List[str]										= 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"""





def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return x if y == 0 else greatest_common_divisor(a       ,		x % y )



def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return (x * y) // greatest_common_divisor(a       ,		a )



def     __lowercase					(    a :				int = 20 )					->					int:
      __snake_case      :    Optional[Any]  			=1
      for i in range(1       ,		n + 1 ):
            __snake_case      :    Optional[int]  			=lcm(a       ,		a )
      return g


if __name__ == "__main__":
    print(F'''{solution() = }''')


