



import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized, parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
						from sagemaker import Session, TrainingJobAnalytics
						from sagemaker.huggingface import HuggingFace



@pytest.mark.skipif(
    literal_eval(os.getenv('TEST_SAGEMAKER'     ,      'False')) is not True     ,      reason='Skipping test because should only be run when releasing minor transformers version'     ,      )
@pytest.mark.usefixtures('sm_env')
@parameterized_class(
    [
        {
            'framework': 'pytorch',
            'script': 'run_glue.py',
            'model_name_or_path': 'distilbert-base-cased',
            'instance_type': 'ml.p3.16xlarge',
            'results': {'train_runtime': 650, 'eval_accuracy': 0.7, 'eval_loss': 0.6},
        },
        {
            'framework': 'pytorch',
            'script': 'run_ddp.py',
            'model_name_or_path': 'distilbert-base-cased',
            'instance_type': 'ml.p3.16xlarge',
            'results': {'train_runtime': 600, 'eval_accuracy': 0.7, 'eval_loss': 0.6},
        },
        {
            'framework': 'tensorflow',
            'script': 'run_tf_dist.py',
            'model_name_or_path': 'distilbert-base-cased',
            'instance_type': 'ml.p3.16xlarge',
            'results': {'train_runtime': 600, 'eval_accuracy': 0.6, 'eval_loss': 0.7},
        },
    ])
class 						UpperCAmelCase_					( unittest.TestCase):







							def      snake_case__   (     self):

														'''simple docstring'''

														if self.framework == "pytorch":
																					subprocess.run(
																					    f"cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py".split(),    encoding="utf-8",    check=__a,    )
														assert hasattr(self,    "env")







							def      snake_case__   (     self,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[Any]				     =					f"{self.env.base_job_name}-{instance_count}-{'ddp' if 'ddp' in self.script else 'smd'}"
														# distributed data settings
														_lowerCAmelCase  :							List[Any]				     =					{"smdistributed": {"dataparallel": {"enabled": True}}} if self.script != "run_ddp.py" else None

														# creates estimator
														return HuggingFace(
														    entry_point=self.script,    source_dir=self.env.test_path,    role=self.env.role,    image_uri=self.env.image_uri,    base_job_name=__a,    instance_count=__a,    instance_type=self.instance_type,    debugger_hook_config=__a,    hyperparameters={**self.env.distributed_hyperparameters, "model_name_or_path": self.model_name_or_path},    metric_definitions=self.env.metric_definitions,    distribution=__a,    py_version="py36",    )







							def      snake_case__   (     self,    __a):

														'''simple docstring'''

														TrainingJobAnalytics(__a).export_csv(f"{self.env.test_path}/{job_name}_metrics.csv")







							@parameterized.expand([(2,)])
							def      snake_case__   (     self,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							Tuple				     =					self.create_estimator(__a)

														# run training
														estimator.fit()

														# result dataframe
														_lowerCAmelCase  :							List[str]				     =					TrainingJobAnalytics(estimator.latest_training_job.name).dataframe()

														# extract kpis
														_lowerCAmelCase  :							str				     =					list(result_metrics_df[result_metrics_df.metric_name == "eval_accuracy"]["value"])
														_lowerCAmelCase  :							str				     =					list(result_metrics_df[result_metrics_df.metric_name == "eval_loss"]["value"])
														# get train time from SageMaker job, this includes starting, preprocessing, stopping
														_lowerCAmelCase  :							Optional[int]				     =					(
														    Session().describe_training_job(estimator.latest_training_job.name).get("TrainingTimeInSeconds",    99_9999)
														)

														# assert kpis
														assert train_runtime <= self.results["train_runtime"]
														assert all(t >= self.results["eval_accuracy"] for t in eval_accuracy)
														assert all(t <= self.results["eval_loss"] for t in eval_loss)

														# dump tests result into json file to share in PR
														with open(f"{estimator.latest_training_job.name}.json",    "w") as outfile:
																					json.dump({"train_time": train_runtime, "eval_accuracy": eval_accuracy, "eval_loss": eval_loss},    __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


_snake_case	=						{
    "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        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase=None						):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					XLNetConfig.from_json_file(_lowerCamelCase						)

							_lowerCAmelCase  :							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}"						)
														_lowerCAmelCase  :							Any				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					GLUE_TASKS_NUM_LABELS[finetuning_task]
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetForSequenceClassification(_lowerCamelCase						)
							elif "squad" in finetuning_task:
														_lowerCAmelCase  :							Union[str, Any]				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					XLNetForQuestionAnswering(_lowerCamelCase						)
							else:
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetLMHeadModel(_lowerCamelCase						)

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

							# Save pytorch-model
							_lowerCAmelCase  :							Optional[int]				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							_lowerCAmelCase  :							Dict				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							print(F"Save PyTorch model to {os.path.abspath(_lowerCamelCase						)}"						)
							torch.save(model.state_dict()       ,				_lowerCamelCase						)
							print(F"Save configuration file to {os.path.abspath(_lowerCamelCase						)}"						)
							with open(_lowerCamelCase       ,				"w"       ,				encoding="utf-8"						) as f:
														f.write(config.to_json_string()						)


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