




import argparse
import glob
import logging
import os
import time
from argparse import Namespace

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from torch.utils.data import DataLoader, TensorDataset

from transformers import glue_compute_metrics as compute_metrics
from transformers import glue_convert_examples_to_features as convert_examples_to_features
from transformers import glue_output_modes, glue_tasks_num_labels
from transformers import glue_processors as processors


a_		:						Union[str, Any]             =    logging.getLogger(__name__)

class 		_snake_case  (  lowercase_					):
			_lowercase		:    Optional[int]			     =							'''sequence-classification'''






			def __init__(       self		,					a)      ->       Dict:



						if type(lowerCamelCase_) == dict:
									SCREAMING_SNAKE_CASE						= Namespace(**lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= glue_output_modes[hparams.task]
						SCREAMING_SNAKE_CASE						= glue_tasks_num_labels[hparams.task]

						super().__init__(lowerCamelCase_		,					lowerCamelCase_		,					self.mode)






			def    SCREAMING_SNAKE_CASE__    (       self		,					**a)      ->       int:
						return self.model(**lowerCamelCase_)






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       List[str]:
						SCREAMING_SNAKE_CASE						= {"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}

						if self.config.model_type not in ["distilbert", "bart"]:
									SCREAMING_SNAKE_CASE						= batch[2] if self.config.model_type in ["""bert""", """xlnet""", """albert"""] else None

						SCREAMING_SNAKE_CASE						= self(**lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= outputs[0]

						SCREAMING_SNAKE_CASE						= self.trainer.lr_schedulers[0]["""scheduler"""]
						SCREAMING_SNAKE_CASE						= {"""loss""": loss, """rate""": lr_scheduler.get_last_lr()[-1]}
						return {"loss": loss, "log": tensorboard_logs}






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						SCREAMING_SNAKE_CASE						= self.hparams
						SCREAMING_SNAKE_CASE						= processors[args.task]()
						SCREAMING_SNAKE_CASE						= processor.get_labels()

						for mode in ["train", "dev"]:
									SCREAMING_SNAKE_CASE						= self._feature_file(lowerCamelCase_)
									if os.path.exists(lowerCamelCase_) and not args.overwrite_cache:
												logger.info('Loading features from cached file %s'		,					lowerCamelCase_)
									else:
												logger.info('Creating features from dataset file at %s'		,					args.data_dir)
												SCREAMING_SNAKE_CASE						= (
												    processor.get_dev_examples(args.data_dir)
												    if mode == """dev"""
												    else processor.get_train_examples(args.data_dir)
												)
												SCREAMING_SNAKE_CASE						= convert_examples_to_features(
												    lowerCamelCase_		,					self.tokenizer		,					max_length=args.max_seq_length		,					label_list=self.labels		,					output_mode=args.glue_output_mode		,					)
												logger.info('Saving features into cached file %s'		,					lowerCamelCase_)
												torch.save(lowerCamelCase_		,					lowerCamelCase_)






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a = False)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= """dev""" if mode == """test""" else mode

						SCREAMING_SNAKE_CASE						= self._feature_file(lowerCamelCase_)
						logger.info('Loading features from cached file %s'		,					lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= torch.load(lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= torch.tensor([f.input_ids for f in features]		,					dtype=torch.long)
						SCREAMING_SNAKE_CASE						= torch.tensor([f.attention_mask for f in features]		,					dtype=torch.long)
						SCREAMING_SNAKE_CASE						= torch.tensor([f.token_type_ids for f in features]		,					dtype=torch.long)
						if self.hparams.glue_output_mode == "classification":
									SCREAMING_SNAKE_CASE						= torch.tensor([f.label for f in features]		,					dtype=torch.long)
						elif self.hparams.glue_output_mode == "regression":
									SCREAMING_SNAKE_CASE						= torch.tensor([f.label for f in features]		,					dtype=torch.float)

						return DataLoader(
						    TensorDataset(lowerCamelCase_		,					lowerCamelCase_		,					lowerCamelCase_		,					lowerCamelCase_)		,					batch_size=lowerCamelCase_		,					shuffle=lowerCamelCase_		,					)






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       str:
						SCREAMING_SNAKE_CASE						= {"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}

						if self.config.model_type not in ["distilbert", "bart"]:
									SCREAMING_SNAKE_CASE						= batch[2] if self.config.model_type in ["""bert""", """xlnet""", """albert"""] else None

						SCREAMING_SNAKE_CASE						= self(**lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= outputs[:2]
						SCREAMING_SNAKE_CASE						= logits.detach().cpu().numpy()
						SCREAMING_SNAKE_CASE						= inputs["""labels"""].detach().cpu().numpy()

						return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}






			def    SCREAMING_SNAKE_CASE__    (       self		,					a)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= torch.stack([x['val_loss'] for x in outputs]).mean().detach().cpu().item()
						SCREAMING_SNAKE_CASE						= np.concatenate([x['pred'] for x in outputs]		,					axis=0)

						if self.hparams.glue_output_mode == "classification":
									SCREAMING_SNAKE_CASE						= np.argmax(lowerCamelCase_		,					axis=1)
						elif self.hparams.glue_output_mode == "regression":
									SCREAMING_SNAKE_CASE						= np.squeeze(lowerCamelCase_)

						SCREAMING_SNAKE_CASE						= np.concatenate([x['target'] for x in outputs]		,					axis=0)
						SCREAMING_SNAKE_CASE						= [[] for _ in range(out_label_ids.shape[0])]
						SCREAMING_SNAKE_CASE						= [[] for _ in range(out_label_ids.shape[0])]

						SCREAMING_SNAKE_CASE						= {**{"""val_loss""": val_loss_mean}, **compute_metrics(self.hparams.task		,					lowerCamelCase_		,					lowerCamelCase_)}

						SCREAMING_SNAKE_CASE						= dict(results.items())
						SCREAMING_SNAKE_CASE						= results
						return ret, preds_list, out_label_list






			def    SCREAMING_SNAKE_CASE__    (       self		,					a)      ->       List[Any]:
						SCREAMING_SNAKE_CASE						= self._eval_end(lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= ret["""log"""]
						return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}






			def    SCREAMING_SNAKE_CASE__    (       self		,					a)      ->       int:
						SCREAMING_SNAKE_CASE						= self._eval_end(lowerCamelCase_)
						SCREAMING_SNAKE_CASE						= ret["""log"""]
						# `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
						return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}







			@staticmethod
			def    SCREAMING_SNAKE_CASE__    (       a		,					a)      ->       Dict:
						BaseTransformer.add_model_specific_args(lowerCamelCase_		,					lowerCamelCase_)
						parser.add_argument(
						    '--max_seq_length'		,					default=128		,					type=lowerCamelCase_		,					help=(
						        'The maximum total input sequence length after tokenization. Sequences longer '
						        'than this will be truncated, sequences shorter will be padded.'
						    )		,					)

						parser.add_argument(
						    '--task'		,					default=''		,					type=lowerCamelCase_		,					required=lowerCamelCase_		,					help='The GLUE task to run'		,					)
						parser.add_argument(
						    '--gpus'		,					default=0		,					type=lowerCamelCase_		,					help='The number of GPUs allocated for this, it is by default 0 meaning none'		,					)

						parser.add_argument(
						    '--overwrite_cache'		,					action='store_true'		,					help='Overwrite the cached training and evaluation sets')

						return parser






def 				lowerCamelCase__				():
			SCREAMING_SNAKE_CASE						= argparse.ArgumentParser()
			add_generic_args(lowerCamelCase_							,       os.getcwd())
			SCREAMING_SNAKE_CASE						= GLUETransformer.add_model_specific_args(lowerCamelCase_							,       os.getcwd())
			SCREAMING_SNAKE_CASE						= parser.parse_args()

			# If output_dir not provided, a folder will be generated in pwd
			if args.output_dir is None:
						SCREAMING_SNAKE_CASE						= os.path.join(
						    './results'							,       F'''{args.task}_{time.strftime('%Y%m%d_%H%M%S')}'''							,       )
						os.makedirs(args.output_dir)

			SCREAMING_SNAKE_CASE						= GLUETransformer(lowerCamelCase_)
			SCREAMING_SNAKE_CASE						= generic_train(lowerCamelCase_							,       lowerCamelCase_)

			# Optionally, predict on dev set and write to output_dir
			if args.do_predict:
						SCREAMING_SNAKE_CASE						= sorted(glob.glob(os.path.join(args.output_dir							,       'checkpoint-epoch=*.ckpt')							,       recursive=lowerCamelCase_))
						SCREAMING_SNAKE_CASE						= model.load_from_checkpoint(checkpoints[-1])
						return trainer.test(lowerCamelCase_)


if __name__ == "__main__":
				main()












# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
a_		:						List[str]             =    abspath(join(dirname(__file__), 'src'))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)






def 				lowerCamelCase__				(_UpperCAmelCase):
			config.addinivalue_line(
			    'markers'							,       'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested')
			config.addinivalue_line(
			    'markers'							,       'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested')
			config.addinivalue_line('markers'							,       'is_pipeline_test: mark test to run only when pipelines are tested')
			config.addinivalue_line('markers'							,       'is_staging_test: mark test to run only in the staging environment')
			config.addinivalue_line('markers'							,       'accelerate_tests: mark test that require accelerate')
			config.addinivalue_line('markers'							,       'tool_tests: mark the tool tests that are run on their specific schedule')






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_addoption_shared

			pytest_addoption_shared(_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_terminal_summary_main

			SCREAMING_SNAKE_CASE						= terminalreporter.config.getoption('--make-reports')
			if make_reports:
						pytest_terminal_summary_main(_UpperCAmelCase							,       id=_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			# If no tests are collected, pytest exists with code 5, which makes the CI fail.
			if exitstatus == 5:
						SCREAMING_SNAKE_CASE						= 0


# Doctest custom flag to ignore output.
a_		:						List[Any]             =    doctest.register_optionflag('IGNORE_RESULT')

a_		:						Any             =    doctest.OutputChecker

class 		_snake_case  (  A__					):






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a)      ->       List[Any]:
						if IGNORE_RESULT & optionflags:
									return True
						return OutputChecker.check_output(self		,					a		,					a		,					a)



a_		:						int             =    CustomOutputChecker
a_		:						List[str]             =    HfDoctestModule







a_		:						Optional[int]             =    HfDocTestParser




