




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						:							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 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=None   ):
			'''simple docstring'''
			# Initialise PyTorch model
			SCREAMING_SNAKE_CASE           =					XLNetConfig.from_json_file(SCREAMING_SNAKE_CASE   )

			SCREAMING_SNAKE_CASE           =					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}"""   )
						SCREAMING_SNAKE_CASE           =					finetuning_task
						SCREAMING_SNAKE_CASE           =					GLUE_TASKS_NUM_LABELS[finetuning_task]
						SCREAMING_SNAKE_CASE           =					XLNetForSequenceClassification(SCREAMING_SNAKE_CASE   )
			elif "squad" in finetuning_task:
						SCREAMING_SNAKE_CASE           =					finetuning_task
						SCREAMING_SNAKE_CASE           =					XLNetForQuestionAnswering(SCREAMING_SNAKE_CASE   )
			else:
						SCREAMING_SNAKE_CASE           =					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
			SCREAMING_SNAKE_CASE           =					os.path.join(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   )
			SCREAMING_SNAKE_CASE           =					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						:							str							=  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						:							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 __future__ import annotations
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			create_state_space_tree(SCREAMING_SNAKE_CASE					,	[]					,	0					,	[0 for i in range(len(SCREAMING_SNAKE_CASE   )   )]   )
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	):
			'''simple docstring'''

			if index == len(SCREAMING_SNAKE_CASE   ):
						print(SCREAMING_SNAKE_CASE   )
						return

			for i in range(len(SCREAMING_SNAKE_CASE   )   ):
						if not index_used[i]:
									current_sequence.append(sequence[i]   )
									SCREAMING_SNAKE_CASE           =					True
									create_state_space_tree(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	index + 1					,	SCREAMING_SNAKE_CASE   )
									current_sequence.pop()
									SCREAMING_SNAKE_CASE           =					False
__A						:							list[int | str]							=  [3, 1, 2, 4]
generate_all_permutations(sequence)

__A						:							list[int | str]							=  ["A", "B", "C"]




generate_all_permutations(sequence_a)






