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


_lowercase		:				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 							lowerCamelCase			(   UpperCAmelCase__ :      Tuple   ,   UpperCAmelCase__ :      Optional[Any]   ,   UpperCAmelCase__ :      str   ,   UpperCAmelCase__ :      Dict=None				)    ->   List[str]:
							# Initialise PyTorch model
							lowercase_      :    Optional[Any]       		= XLNetConfig.from_json_file(UpperCAmelCase__				)

							lowercase_      :    int       		= 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_      :    int       		= finetuning_task
														lowercase_      :    List[str]       		= GLUE_TASKS_NUM_LABELS[finetuning_task]
														lowercase_      :    Any       		= XLNetForSequenceClassification(UpperCAmelCase__				)
							elif "squad" in finetuning_task:
														lowercase_      :    Union[str, Any]       		= finetuning_task
														lowercase_      :    str       		= XLNetForQuestionAnswering(UpperCAmelCase__				)
							else:
														lowercase_      :    Union[str, Any]       		= XLNetLMHeadModel(UpperCAmelCase__				)

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

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


if __name__ == "__main__":
						_lowercase		:				Union[str, Any]	       =		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",
						)
						_lowercase		:				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
						)






'''simple docstring'''




from collections.abc import Callable

import numpy as np




def 							lowerCamelCase			(   UpperCAmelCase__ :      Callable   ,   UpperCAmelCase__ :      float   ,   UpperCAmelCase__ :      float   ,   UpperCAmelCase__ :      float   ,   UpperCAmelCase__ :      float				)    ->   np.array:
							lowercase_      :    Any       		= int(np.ceil((x_end - xa) / step_size				)				)
							lowercase_      :    List[Any]       		= np.zeros((n + 1,)				)
							lowercase_      :    List[Any]       		= ya
							lowercase_      :    List[str]       		= xa

							for k in range(UpperCAmelCase__				):
														lowercase_      :    Optional[Any]       		= y[k] + step_size * ode_func(UpperCAmelCase__   ,   y[k]				)
														lowercase_      :    List[Any]       		= y[k] + (
														    (step_size / 2) * (ode_func(UpperCAmelCase__   ,   y[k]				) + ode_func(x + step_size   ,   UpperCAmelCase__				))
														)
														x += step_size

							return y


if __name__ == "__main__":
						import doctest

						doctest.testmod()





