



import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


class   snake_case_ (unittest.TestCase  ):




       """simple docstring"""






       @parameterized.expand([(None,), ("foo.json",)])
       def  A_   (     self     ,lowercase):

             """simple docstring"""





             UpperCAmelCase_  :	Any				      =		GenerationConfig(
                 do_sample=lowercase     ,temperature=0.7     ,length_penalty=1.0     ,bad_words_ids=[[1, 2, 3], [4, 5]]     ,)
             with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(lowercase     ,config_name=lowercase)
                   UpperCAmelCase_  :	Optional[int]				      =		GenerationConfig.from_pretrained(lowercase     ,config_name=lowercase)

             # Checks parameters that were specified
             self.assertEqual(loaded_config.do_sample     ,lowercase)
             self.assertEqual(loaded_config.temperature     ,0.7)
             self.assertEqual(loaded_config.length_penalty     ,1.0)
             self.assertEqual(loaded_config.bad_words_ids     ,[[1, 2, 3], [4, 5]])

             # Checks parameters that were not specified (defaults)
             self.assertEqual(loaded_config.top_k     ,50)
             self.assertEqual(loaded_config.max_length     ,20)
             self.assertEqual(loaded_config.max_time     ,lowercase)



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	List[Any]				      =		AutoConfig.from_pretrained("gpt2")
             UpperCAmelCase_  :	int				      =		GenerationConfig.from_model_config(lowercase)
             UpperCAmelCase_  :	Union[str, Any]				      =		GenerationConfig()

             # The generation config has loaded a few non-default parameters from the model config
             self.assertNotEqual(lowercase     ,lowercase)

             # One of those parameters is eos_token_id -- check if it matches
             self.assertNotEqual(generation_config_from_model.eos_token_id     ,default_generation_config.eos_token_id)
             self.assertEqual(generation_config_from_model.eos_token_id     ,model_config.eos_token_id)



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	List[Any]				      =		GenerationConfig()
             UpperCAmelCase_  :	Union[str, Any]				      =		{
                 "max_new_tokens": 1024,
                 "foo": "bar",
             }
             UpperCAmelCase_  :	str				      =		copy.deepcopy(lowercase)
             UpperCAmelCase_  :	int				      =		generation_config.update(**lowercase)

             # update_kwargs was not modified (no side effects)
             self.assertEqual(lowercase     ,lowercase)

             # update_kwargs was used to update the config on valid attributes
             self.assertEqual(generation_config.max_new_tokens     ,1024)

             # `.update()` returns a dictionary of unused kwargs
             self.assertEqual(lowercase     ,{"foo": "bar"})



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		GenerationConfig()
             UpperCAmelCase_  :	int				      =		"bar"

             with tempfile.TemporaryDirectory("test-generation-config") as tmp_dir:
                   generation_config.save_pretrained(lowercase)

                   UpperCAmelCase_  :	str				      =		GenerationConfig.from_pretrained(lowercase)
             # update_kwargs was used to update the config on valid attributes
             self.assertEqual(new_config.foo     ,"bar")

             UpperCAmelCase_  :	str				      =		GenerationConfig.from_model_config(lowercase)
             assert not hasattr(lowercase     ,"foo")  # no new kwargs should be initialized if from config



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	List[str]				      =		GenerationConfig()
             self.assertEqual(default_config.temperature     ,1.0)
             self.assertEqual(default_config.do_sample     ,lowercase)
             self.assertEqual(default_config.num_beams     ,1)

             UpperCAmelCase_  :	Optional[int]				      =		GenerationConfig(
                 do_sample=lowercase     ,temperature=0.7     ,length_penalty=1.0     ,bad_words_ids=[[1, 2, 3], [4, 5]]     ,)
             self.assertEqual(config.temperature     ,0.7)
             self.assertEqual(config.do_sample     ,lowercase)
             self.assertEqual(config.num_beams     ,1)

             with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(lowercase)
                   UpperCAmelCase_  :	Dict				      =		GenerationConfig.from_pretrained(lowercase     ,temperature=1.0)

             self.assertEqual(loaded_config.temperature     ,1.0)
             self.assertEqual(loaded_config.do_sample     ,lowercase)
             self.assertEqual(loaded_config.num_beams     ,1)  # default value


@is_staging_test
class   snake_case_ (unittest.TestCase  ):




       """simple docstring"""






       @classmethod
       def  A_   (     cls):

             """simple docstring"""





             UpperCAmelCase_  :	Any				      =		TOKEN
             HfFolder.save_token(lowercase)



       @classmethod
       def  A_   (     cls):

             """simple docstring"""





             try:
                   delete_repo(token=cls._token     ,repo_id="test-generation-config")
             except HTTPError:
                   pass

             try:
                   delete_repo(token=cls._token     ,repo_id="valid_org/test-generation-config-org")
             except HTTPError:
                   pass



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Optional[Any]				      =		GenerationConfig(
                 do_sample=lowercase     ,temperature=0.7     ,length_penalty=1.0     ,)
             config.push_to_hub("test-generation-config"     ,use_auth_token=self._token)

             UpperCAmelCase_  :	Tuple				      =		GenerationConfig.from_pretrained(F"""{USER}/test-generation-config""")
             for k, v in config.to_dict().items():
                   if k != "transformers_version":
                         self.assertEqual(lowercase     ,getattr(lowercase     ,lowercase))

        # Reset repo
             delete_repo(token=self._token     ,repo_id="test-generation-config")

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(
                       lowercase     ,repo_id="test-generation-config"     ,push_to_hub=lowercase     ,use_auth_token=self._token)

             UpperCAmelCase_  :	str				      =		GenerationConfig.from_pretrained(F"""{USER}/test-generation-config""")
             for k, v in config.to_dict().items():
                   if k != "transformers_version":
                         self.assertEqual(lowercase     ,getattr(lowercase     ,lowercase))



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	str				      =		GenerationConfig(
                 do_sample=lowercase     ,temperature=0.7     ,length_penalty=1.0     ,)
             config.push_to_hub("valid_org/test-generation-config-org"     ,use_auth_token=self._token)

             UpperCAmelCase_  :	List[Any]				      =		GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
             for k, v in config.to_dict().items():
                   if k != "transformers_version":
                         self.assertEqual(lowercase     ,getattr(lowercase     ,lowercase))

        # Reset repo
             delete_repo(token=self._token     ,repo_id="valid_org/test-generation-config-org")

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(
                       lowercase     ,repo_id="valid_org/test-generation-config-org"     ,push_to_hub=lowercase     ,use_auth_token=self._token)

             UpperCAmelCase_  :	Any				      =		GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
             for k, v in config.to_dict().items():
                   if k != "transformers_version":
                         self.assertEqual(lowercase     ,getattr(lowercase     ,lowercase))





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
__lowerCamelCase         =			False
__lowerCamelCase         =			False







def    _snake_case (       __snake_case    )     ->     Any:






      '''simple docstring'''







      return TrainCommand(__snake_case    )





class   snake_case_ (lowercase__  ):




       """simple docstring"""






       @staticmethod
       def  A_   (     lowercase):

             """simple docstring"""





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

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

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



       def __init__(     self     ,lowercase):

             """simple docstring"""





             UpperCAmelCase_  :	Optional[Any]				      =		logging.get_logger("transformers-cli/training")

             UpperCAmelCase_  :	List[Any]				      =		"tf" if is_tf_available() else "torch"

             os.makedirs(args.output     ,exist_ok=lowercase)
             UpperCAmelCase_  :	Union[str, Any]				      =		args.output

             UpperCAmelCase_  :	Optional[int]				      =		args.column_label
             UpperCAmelCase_  :	Dict				      =		args.column_text
             UpperCAmelCase_  :	Optional[Any]				      =		args.column_id

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

             UpperCAmelCase_  :	List[str]				      =		args.validation_split
             UpperCAmelCase_  :	Tuple				      =		args.train_batch_size
             UpperCAmelCase_  :	Optional[int]				      =		args.valid_batch_size
             UpperCAmelCase_  :	Dict				      =		args.learning_rate
             UpperCAmelCase_  :	List[str]				      =		args.adam_epsilon



       def  A_   (     self):

             """simple docstring"""





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



       def  A_   (     self):

             """simple docstring"""





             raise NotImplementedError



       def  A_   (     self):

             """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)
