





'''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 					_a						(       _lowerCamelCase ) ->				str:



			"""simple docstring"""


			return TrainCommand(_lowerCamelCase )




class  _A (					__lowercase		):

		@staticmethod
		def 	lowercase__     (   __magic_name__					:   ArgumentParser			)					->    Tuple:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     parser.add_parser("""train"""  ,      help="""CLI tool to train a model on a task."""			)

					train_parser.add_argument(
					    """--train_data"""  ,      type=__magic_name__  ,      required=__magic_name__  ,      help="""path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences."""  ,      )
					train_parser.add_argument(
					    """--column_label"""  ,      type=__magic_name__  ,      default=0  ,      help="""Column of the dataset csv file with example labels."""			)
					train_parser.add_argument(
					    """--column_text"""  ,      type=__magic_name__  ,      default=1  ,      help="""Column of the dataset csv file with example texts."""			)
					train_parser.add_argument(
					    """--column_id"""  ,      type=__magic_name__  ,      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=__magic_name__  ,      default=""""""  ,      help="""path to validation dataset."""			)
					train_parser.add_argument(
					    """--validation_split"""  ,      type=__magic_name__  ,      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=__magic_name__  ,      default="""./"""  ,      help="""path to saved the trained model."""			)

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

		def __init__(   self					:   Dict  ,      __magic_name__					:   Namespace			)					->    List[Any]:


					"""simple docstring"""

					__snake_case					:      List[str]							      =     logging.get_logger("""transformers-cli/training"""			)

					__snake_case					:      Dict							      =     """tf""" if is_tf_available() else """torch"""

					os.makedirs(args.output  ,      exist_ok=__magic_name__			)
					__snake_case					:      int							      =     args.output

					__snake_case					:      Optional[int]							      =     args.column_label
					__snake_case					:      List[str]							      =     args.column_text
					__snake_case					:      Union[str, Any]							      =     args.column_id

					self.logger.info(f'''Loading {args.task} pipeline for {args.model}'''			)
					if args.task == "text_classification":
								__snake_case					:      List[Any]							      =     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}'''			)
					__snake_case					:      Optional[int]							      =     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  ,      )
					__snake_case					:      Optional[int]							      =     None
					if args.validation_data:
								self.logger.info(f'''Loading validation dataset from {args.validation_data}'''			)
								__snake_case					:      List[str]							      =     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  ,      )

					__snake_case					:      int							      =     args.validation_split
					__snake_case					:      Tuple							      =     args.train_batch_size
					__snake_case					:      List[str]							      =     args.valid_batch_size
					__snake_case					:      int							      =     args.learning_rate
					__snake_case					:      Any							      =     args.adam_epsilon

		def 	lowercase__     (   self					:   Dict			)					->    Tuple:


					"""simple docstring"""

					if self.framework == "tf":
								return self.run_tf()
					return self.run_torch()

		def 	lowercase__     (   self					:   List[str]			)					->    Union[str, Any]:


					"""simple docstring"""

					raise NotImplementedError

		def 	lowercase__     (   self					:   str			)					->    str:


					"""simple docstring"""

					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			)









"""simple docstring"""






import pytest

import datasets


# Import fixture modules as plugins
__UpperCAmelCase						=			['''tests.fixtures.files''', '''tests.fixtures.hub''', '''tests.fixtures.fsspec''']






def      lowercase__ (					lowerCAmelCase__   :			Optional[Any]							,			lowerCAmelCase__   :			str			)    ->			str:



			'''simple docstring'''
			# Mark tests as "unit" by default if not marked as "integration" (or already marked as "unit")
			for item in items:
						if any(marker in item.keywords for marker in ["integration", "unit"]			):
									continue
						item.add_marker(pytest.mark.unit			)






def      lowercase__ (					lowerCAmelCase__   :			List[Any]			)    ->			Any:



			'''simple docstring'''
			config.addinivalue_line("markers"							,			"torchaudio_latest: mark test to run with torchaudio>=0.12"			)






@pytest.fixture(autouse=lowerCAmelCase__			)
def      lowercase__ (					lowerCAmelCase__   :			Optional[Any]							,			lowerCAmelCase__   :			Dict			)    ->			List[str]:



			'''simple docstring'''
			# test_hf_cache_home = tmp_path_factory.mktemp("cache")  # TODO: why a cache dir per test function does not work?
			a__  :	Dict		 =			tmp_path_factory.getbasetemp() / "cache"
			a__  :	int		 =			test_hf_cache_home / "datasets"
			a__  :	Tuple		 =			test_hf_cache_home / "metrics"
			a__  :	Any		 =			test_hf_cache_home / "modules"
			monkeypatch.setattr("datasets.config.HF_DATASETS_CACHE"							,			str(lowerCAmelCase__			)			)
			monkeypatch.setattr("datasets.config.HF_METRICS_CACHE"							,			str(lowerCAmelCase__			)			)
			monkeypatch.setattr("datasets.config.HF_MODULES_CACHE"							,			str(lowerCAmelCase__			)			)
			a__  :	Optional[int]		 =			test_hf_datasets_cache / "downloads"
			monkeypatch.setattr("datasets.config.DOWNLOADED_DATASETS_PATH"							,			str(lowerCAmelCase__			)			)
			a__  :	Tuple		 =			test_hf_datasets_cache / "downloads" / "extracted"
			monkeypatch.setattr("datasets.config.EXTRACTED_DATASETS_PATH"							,			str(lowerCAmelCase__			)			)






@pytest.fixture(autouse=lowerCAmelCase__							,			scope="session"			)
def      lowercase__ (					)    ->			Union[str, Any]:



			'''simple docstring'''
			datasets.disable_progress_bar()






@pytest.fixture(autouse=lowerCAmelCase__			)
def      lowercase__ (					lowerCAmelCase__   :			Union[str, Any]			)    ->			Optional[Any]:



			'''simple docstring'''
			# don't take tests into account when counting downloads
			monkeypatch.setattr("datasets.config.HF_UPDATE_DOWNLOAD_COUNTS"							,			lowerCAmelCase__			)






@pytest.fixture
def      lowercase__ (					lowerCAmelCase__   :			Optional[Any]			)    ->			str:



			'''simple docstring'''
			# Required to suppress RemovedIn20Warning when feature(s) are not compatible with SQLAlchemy 2.0
			# To be removed once SQLAlchemy 2.0 supported
			monkeypatch.setattr("sqlalchemy.util.deprecations.SILENCE_UBER_WARNING"							,			lowerCAmelCase__			)