





'''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
A__							:  List[Any]    =False
A__							:  List[str]    =False
def   UpperCamelCase__ (						lowerCAmelCase    ):





      """simple docstring"""


      return TrainCommand(lowerCAmelCase    )





class 					UpperCAmelCase	(     snake_case_  ):




      @staticmethod
      def 							lowercase__       (     __snake_case     :					ArgumentParser    )							-> str:
            _lowerCAmelCase					=				parser.add_parser("""train"""     ,     help="""CLI tool to train a model on a task."""    )

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

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




      def __init__(     self     :					Optional[int]     ,     __snake_case     :					Namespace    )							-> Any:
            _lowerCAmelCase					=				logging.get_logger("""transformers-cli/training"""    )

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

            os.makedirs(args.output     ,     exist_ok=__snake_case    )
            _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 							lowercase__       (     self     :					Tuple    )							-> Any:
            if self.framework == "tf":
                  return self.run_tf()
            return self.run_torch()




      def 							lowercase__       (     self     :					Optional[Any]    )							-> List[str]:
            raise NotImplementedError




      def 							lowercase__       (     self     :					Optional[int]    )							-> List[str]:
            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'''






from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
      from ... import FeatureExtractionMixin, TensorType

A__							:  Tuple    =logging.get_logger(__name__)

A__							:  Any    ={
    '''openai/imagegpt-small''': '''''',
    '''openai/imagegpt-medium''': '''''',
    '''openai/imagegpt-large''': '''''',
}




class 					UpperCAmelCase	(     snake_case_  ):
      _lowercase:     Tuple			=  '''imagegpt'''
      _lowercase:     Optional[int]			=  ['''past_key_values''']
      _lowercase:     str			=  {
          '''hidden_size''': '''n_embd''',
          '''max_position_embeddings''': '''n_positions''',
          '''num_attention_heads''': '''n_head''',
          '''num_hidden_layers''': '''n_layer''',
      }




      def __init__(     self     :					Optional[int]     ,     __snake_case     :					Optional[Any]=5_12 + 1     ,     __snake_case     :					Union[str, Any]=32 * 32     ,     __snake_case     :					List[Any]=5_12     ,     __snake_case     :					Any=24     ,     __snake_case     :					Optional[Any]=8     ,     __snake_case     :					List[Any]=None     ,     __snake_case     :					str="quick_gelu"     ,     __snake_case     :					List[Any]=0.1     ,     __snake_case     :					str=0.1     ,     __snake_case     :					Optional[int]=0.1     ,     __snake_case     :					Tuple=1E-5     ,     __snake_case     :					Optional[int]=0.02     ,     __snake_case     :					str=True     ,     __snake_case     :					Dict=True     ,     __snake_case     :					Union[str, Any]=False     ,     __snake_case     :					Dict=False     ,     __snake_case     :					Union[str, Any]=False     ,     **__snake_case     :					Union[str, Any]     ,     )							-> List[Any]:
            _lowerCAmelCase					=				vocab_size
            _lowerCAmelCase					=				n_positions
            _lowerCAmelCase					=				n_embd
            _lowerCAmelCase					=				n_layer
            _lowerCAmelCase					=				n_head
            _lowerCAmelCase					=				n_inner
            _lowerCAmelCase					=				activation_function
            _lowerCAmelCase					=				resid_pdrop
            _lowerCAmelCase					=				embd_pdrop
            _lowerCAmelCase					=				attn_pdrop
            _lowerCAmelCase					=				layer_norm_epsilon
            _lowerCAmelCase					=				initializer_range
            _lowerCAmelCase					=				scale_attn_weights
            _lowerCAmelCase					=				use_cache
            _lowerCAmelCase					=				scale_attn_by_inverse_layer_idx
            _lowerCAmelCase					=				reorder_and_upcast_attn
            _lowerCAmelCase					=				tie_word_embeddings

            super().__init__(tie_word_embeddings=__snake_case     ,     **__snake_case    )




class 					UpperCAmelCase	(     snake_case_  ):




      @property
      def 							lowercase__       (     self     :					Optional[Any]    )							-> Mapping[str, Mapping[int, str]]:
            return OrderedDict(
                [
                    ("""input_ids""", {0: """batch""", 1: """sequence"""}),
                ]    )




      def 							lowercase__       (     self     :					Union[str, Any]     ,     __snake_case     :					"FeatureExtractionMixin"     ,     __snake_case     :					int = 1     ,     __snake_case     :					int = -1     ,     __snake_case     :					bool = False     ,     __snake_case     :					Optional["TensorType"] = None     ,     __snake_case     :					int = 3     ,     __snake_case     :					int = 32     ,     __snake_case     :					int = 32     ,     )							-> Mapping[str, Any]:
            _lowerCAmelCase					=				self._generate_dummy_images(__snake_case     ,     __snake_case     ,     __snake_case     ,     __snake_case    )
            _lowerCAmelCase					=				dict(preprocessor(images=__snake_case     ,     return_tensors=__snake_case    )    )

            return inputs






