



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


__A   :							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	(      _SCREAMING_SNAKE_CASE   :						Union[str, Any]					,     _SCREAMING_SNAKE_CASE   :						Union[str, Any]					,     _SCREAMING_SNAKE_CASE   :						Dict					,     _SCREAMING_SNAKE_CASE   :						Dict=None				):






				'''simple docstring'''



				_UpperCAmelCase					=    XLNetConfig.from_json_file(_SCREAMING_SNAKE_CASE				)

				_UpperCAmelCase					=    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}'				)
								_UpperCAmelCase					=    finetuning_task
								_UpperCAmelCase					=    GLUE_TASKS_NUM_LABELS[finetuning_task]
								_UpperCAmelCase					=    XLNetForSequenceClassification(_SCREAMING_SNAKE_CASE				)
				elif "squad" in finetuning_task:
								_UpperCAmelCase					=    finetuning_task
								_UpperCAmelCase					=    XLNetForQuestionAnswering(_SCREAMING_SNAKE_CASE				)
				else:
								_UpperCAmelCase					=    XLNetLMHeadModel(_SCREAMING_SNAKE_CASE				)

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

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


if __name__ == "__main__":
					__A   :							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",
					)
					__A   :							List[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"""


from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader
class 			_a (					lowerCAmelCase):
			"""simple docstring"""



			def __init__(		self     :    List[str]				,   __UpperCamelCase     :    NestedDataStructureLike[PathLike]				,   __UpperCamelCase     :    Optional[NamedSplit] = None				,   __UpperCamelCase     :    Optional[Features] = None				,   __UpperCamelCase     :    str = None				,   __UpperCamelCase     :    bool = False				,   __UpperCamelCase     :    bool = False				,   __UpperCamelCase     :    Optional[int] = None				,   **__UpperCamelCase     :    Optional[Any]				,   )->Any:
							super().__init__(
							    __UpperCamelCase				,   split=__UpperCamelCase				,   features=__UpperCamelCase				,   cache_dir=__UpperCamelCase				,   keep_in_memory=__UpperCamelCase				,   streaming=__UpperCamelCase				,   num_proc=__UpperCamelCase				,   **__UpperCamelCase				,   )
							_UpperCAmelCase					=    path_or_paths if isinstance(__UpperCamelCase				,   __UpperCamelCase   ) else {self.split: path_or_paths}
							_UpperCAmelCase					=    Text(
							    cache_dir=__UpperCamelCase				,   data_files=__UpperCamelCase				,   features=__UpperCamelCase				,   **__UpperCamelCase				,   )



			def  lowercase__						(		self     :    Optional[Any]   )->str:
							# Build iterable dataset
							if self.streaming:
											_UpperCAmelCase					=    self.builder.as_streaming_dataset(split=self.split   )
							# Build regular (map-style) dataset
							else:
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None
											_UpperCAmelCase					=    None

											self.builder.download_and_prepare(
											    download_config=__UpperCamelCase				,   download_mode=__UpperCamelCase				,   verification_mode=__UpperCamelCase				,   base_path=__UpperCamelCase				,   num_proc=self.num_proc				,   )
											_UpperCAmelCase					=    self.builder.as_dataset(
											    split=self.split				,   verification_mode=__UpperCamelCase				,   in_memory=self.keep_in_memory   )
							return dataset



