






import re

import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey

from ..utils import logging


lowercase  							=					logging.get_logger(__name__)





def 						__UpperCAmelCase			(     a_):
							snake_case_				=							R'\w+[.]\d+'
							snake_case_				=							re.findall(a_							,     a_)
							for pat in pats:
														snake_case_				=							key.replace(a_							,     '_'.join(pat.split('.')))
							return key





def 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							pt_tuple_key[:-1] + ('scale',)
							if (
							    any('norm' in str_ for str_ in pt_tuple_key)
							    and (pt_tuple_key[-1] == "bias")
							    and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
							    and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
							):
														snake_case_				=							pt_tuple_key[:-1] + ('scale',)
														return renamed_pt_tuple_key, pt_tensor
							elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
														snake_case_				=							pt_tuple_key[:-1] + ('scale',)
														return renamed_pt_tuple_key, pt_tensor

							# embedding
							if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
														snake_case_				=							pt_tuple_key[:-1] + ('embedding',)
														return renamed_pt_tuple_key, pt_tensor

							# conv layer
							snake_case_				=							pt_tuple_key[:-1] + ('kernel',)
							if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4:
														snake_case_				=							pt_tensor.transpose(2							,     3							,     1							,     0)
														return renamed_pt_tuple_key, pt_tensor

							# linear layer
							snake_case_				=							pt_tuple_key[:-1] + ('kernel',)
							if pt_tuple_key[-1] == "weight":
														snake_case_				=							pt_tensor.T
														return renamed_pt_tuple_key, pt_tensor

							# old PyTorch layer norm weight
							snake_case_				=							pt_tuple_key[:-1] + ('weight',)
							if pt_tuple_key[-1] == "gamma":
														return renamed_pt_tuple_key, pt_tensor

							# old PyTorch layer norm bias
							snake_case_				=							pt_tuple_key[:-1] + ('bias',)
							if pt_tuple_key[-1] == "beta":
														return renamed_pt_tuple_key, pt_tensor

							return pt_tuple_key, pt_tensor





def 						__UpperCAmelCase			(     a_							,     a_							,     a_=42):
							# Step 1: Convert pytorch tensor to numpy
							snake_case_				=							{k: v.numpy() for k, v in pt_state_dict.items()}

							# Step 2: Since the model is stateless, get random Flax params
							snake_case_				=							flax_model.init_weights(PRNGKey(a_))

							snake_case_				=							flatten_dict(a_)
							snake_case_				=							{}

							# Need to change some parameters name to match Flax names
							for pt_key, pt_tensor in pt_state_dict.items():
														snake_case_				=							rename_key(a_)
														snake_case_				=							tuple(renamed_pt_key.split('.'))

														# Correctly rename weight parameters
														snake_case_			,		snake_case_				=							rename_key_and_reshape_tensor(a_							,     a_							,     a_)

														if flax_key in random_flax_state_dict:
																					if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
																												raise ValueError(
																												    f'''PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '''
																												    f'''{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.''')

        # also add unexpected weight so that warning is thrown
														snake_case_				=							jnp.asarray(a_)

							return unflatten_dict(a_)













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  							=					{
    "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):
							# Initialise PyTorch model
							snake_case_				=							XLNetConfig.from_json_file(a_)

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

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

							# Save pytorch-model
							snake_case_				=							os.path.join(a_							,     a_)
							snake_case_				=							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__":
	lowercase  							=					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  							=					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
	)





