



'''simple docstring'''

from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


UpperCAmelCase     		=   '\\n@inproceedings{wang2019glue,\n  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n  note={In the Proceedings of ICLR.},\n  year={2019}\n}\n'

UpperCAmelCase     		=   '\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n'

UpperCAmelCase     		=   '\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"pearson\": Pearson Correlation\n    \"spearmanr\": Spearman Correlation\n    \"matthews_correlation\": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'sst2\')  # \'sst2\' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'mrpc\')  # \'mrpc\' or \'qqp\'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'stsb\')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})\n    {\'pearson\': 1.0, \'spearmanr\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'cola\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'matthews_correlation\': 1.0}\n'






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Optional[Any]							,		_SCREAMING_SNAKE_CASE					:						Union[str, Any]							)      ->						Optional[int]:







	"""simple docstring"""
	return float((preds == labels).mean()							)






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						List[str]							,		_SCREAMING_SNAKE_CASE					:						Union[str, Any]							)      ->						str:







	"""simple docstring"""
	lowerCAmelCase   =     simple_accuracy(__SCREAMING_SNAKE_CASE							,		__SCREAMING_SNAKE_CASE							)
	lowerCAmelCase   =     float(fa_score(y_true=__SCREAMING_SNAKE_CASE							,		y_pred=__SCREAMING_SNAKE_CASE							)							)
	return {
	    "accuracy": acc,
	    "f1": fa,
	}






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Optional[int]							,		_SCREAMING_SNAKE_CASE					:						List[str]							)      ->						Union[str, Any]:







	"""simple docstring"""
	lowerCAmelCase   =     float(pearsonr(__SCREAMING_SNAKE_CASE							,		__SCREAMING_SNAKE_CASE							)[0]							)
	lowerCAmelCase   =     float(spearmanr(__SCREAMING_SNAKE_CASE							,		__SCREAMING_SNAKE_CASE							)[0]							)
	return {
	    "pearson": pearson_corr,
	    "spearmanr": spearman_corr,
	}





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,							_KWARGS_DESCRIPTION )
class __snake_case(				datasets.Metric ):


						'''simple docstring'''



						def     __snake_case   ( self				)     ->     int:
							if self.config_name not in [
							    "sst2",
							    "mnli",
							    "mnli_mismatched",
							    "mnli_matched",
							    "cola",
							    "stsb",
							    "mrpc",
							    "qqp",
							    "qnli",
							    "rte",
							    "wnli",
							    "hans",
							]:
								raise KeyError(
								    """You should supply a configuration name selected in """
								    """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
								    """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""				)
							return datasets.MetricInfo(
							    description=_DESCRIPTION     ,	citation=_CITATION     ,	inputs_description=_KWARGS_DESCRIPTION     ,	features=datasets.Features(
							        {
							            """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""				),
							            """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""				),
							        }				)     ,	codebase_urls=[]     ,	reference_urls=[]     ,	format="""numpy"""     ,	)




						def     __snake_case   ( self     ,	A_     ,	A_				)     ->     Any:
							if self.config_name == "cola":
								return {"matthews_correlation": matthews_corrcoef(_lowerCAmelCase     ,	_lowerCAmelCase				)}
							elif self.config_name == "stsb":
								return pearson_and_spearman(_lowerCAmelCase     ,	_lowerCAmelCase				)
							elif self.config_name in ["mrpc", "qqp"]:
								return acc_and_fa(_lowerCAmelCase     ,	_lowerCAmelCase				)
							elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
								return {"accuracy": simple_accuracy(_lowerCAmelCase     ,	_lowerCAmelCase				)}
							else:
								raise KeyError(
								    """You should supply a configuration name selected in """
								    """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
								    """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""				)




'''simple docstring'''

import os
from argparse import ArgumentParser, Namespace

from ..data import SingleSentenceClassificationProcessor as Processor
from ..pipelines import TextClassificationPipeline
from ..utils import is_tf_available, is_torch_available, logging
from . import BaseTransformersCLICommand


if not is_tf_available() and not is_torch_available():
				raise RuntimeError('At least one of PyTorch or TensorFlow 2.0+ should be installed to use CLI training')

# TF training parameters
UpperCAmelCase     		=   False
UpperCAmelCase     		=   False






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						Namespace							)      ->						Tuple:







	"""simple docstring"""
	return TrainCommand(_SCREAMING_SNAKE_CASE							)





class __snake_case(				_lowerCAmelCase ):


						'''simple docstring'''



						@staticmethod
						def     __snake_case   ( A_				)     ->     Optional[int]:
							lowerCAmelCase   =     parser.add_parser("""train"""     ,	help="""CLI tool to train a model on a task."""				)

							train_parser.add_argument(
							    """--train_data"""     ,	type=A_     ,	required=A_     ,	help="""path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences."""     ,	)
							train_parser.add_argument(
							    """--column_label"""     ,	type=A_     ,	default=0     ,	help="""Column of the dataset csv file with example labels."""				)
							train_parser.add_argument(
							    """--column_text"""     ,	type=A_     ,	default=1     ,	help="""Column of the dataset csv file with example texts."""				)
							train_parser.add_argument(
							    """--column_id"""     ,	type=A_     ,	default=2     ,	help="""Column of the dataset csv file with example ids."""				)
							train_parser.add_argument(
							    """--skip_first_row"""     ,	action="""store_true"""     ,	help="""Skip the first row of the csv file (headers)."""				)

							train_parser.add_argument("""--validation_data"""     ,	type=A_     ,	default=""""""     ,	help="""path to validation dataset."""				)
							train_parser.add_argument(
							    """--validation_split"""     ,	type=A_     ,	default=0.1     ,	help="""if validation dataset is not provided, fraction of train dataset to use as validation dataset."""     ,	)

							train_parser.add_argument("""--output"""     ,	type=A_     ,	default="""./"""     ,	help="""path to saved the trained model."""				)

							train_parser.add_argument(
							    """--task"""     ,	type=A_     ,	default="""text_classification"""     ,	help="""Task to train the model on."""				)
							train_parser.add_argument(
							    """--model"""     ,	type=A_     ,	default="""bert-base-uncased"""     ,	help="""Model's name or path to stored model."""				)
							train_parser.add_argument("""--train_batch_size"""     ,	type=A_     ,	default=32     ,	help="""Batch size for training."""				)
							train_parser.add_argument("""--valid_batch_size"""     ,	type=A_     ,	default=64     ,	help="""Batch size for validation."""				)
							train_parser.add_argument("""--learning_rate"""     ,	type=A_     ,	default=3e-5     ,	help="""Learning rate."""				)
							train_parser.add_argument("""--adam_epsilon"""     ,	type=A_     ,	default=1e-08     ,	help="""Epsilon for Adam optimizer."""				)
							train_parser.set_defaults(func=A_				)


						def __init__( self     ,	A_				)     ->     Tuple:
							lowerCAmelCase   =     logging.get_logger("""transformers-cli/training"""				)

							lowerCAmelCase   =     """tf""" if is_tf_available() else """torch"""

							os.makedirs(args.output     ,	exist_ok=A_				)
							lowerCAmelCase   =     args.output

							lowerCAmelCase   =     args.column_label
							lowerCAmelCase   =     args.column_text
							lowerCAmelCase   =     args.column_id

							self.logger.info(f'Loading {args.task} pipeline for {args.model}'				)
							if args.task == "text_classification":
								lowerCAmelCase   =     TextClassificationPipeline.from_pretrained(args.model				)
							elif args.task == "token_classification":
								raise NotImplementedError
							elif args.task == "question_answering":
								raise NotImplementedError

							self.logger.info(f'Loading dataset from {args.train_data}'				)
							lowerCAmelCase   =     Processor.create_from_csv(
							    args.train_data     ,	column_label=args.column_label     ,	column_text=args.column_text     ,	column_id=args.column_id     ,	skip_first_row=args.skip_first_row     ,	)
							lowerCAmelCase   =     None
							if args.validation_data:
								self.logger.info(f'Loading validation dataset from {args.validation_data}'				)
								lowerCAmelCase   =     Processor.create_from_csv(
								    args.validation_data     ,	column_label=args.column_label     ,	column_text=args.column_text     ,	column_id=args.column_id     ,	skip_first_row=args.skip_first_row     ,	)

							lowerCAmelCase   =     args.validation_split
							lowerCAmelCase   =     args.train_batch_size
							lowerCAmelCase   =     args.valid_batch_size
							lowerCAmelCase   =     args.learning_rate
							lowerCAmelCase   =     args.adam_epsilon


						def     __snake_case   ( self				)     ->     Optional[int]:
							if self.framework == "tf":
								return self.run_tf()
							return self.run_torch()


						def     __snake_case   ( self				)     ->     Tuple:
							raise NotImplementedError




						def     __snake_case   ( self				)     ->     Tuple:
							self.pipeline.fit(
							    self.train_dataset     ,	validation_data=self.valid_dataset     ,	validation_split=self.validation_split     ,	learning_rate=self.learning_rate     ,	adam_epsilon=self.adam_epsilon     ,	train_batch_size=self.train_batch_size     ,	valid_batch_size=self.valid_batch_size     ,	)

							# Save trained pipeline
							self.pipeline.save_pretrained(self.output				)