



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			(  _UpperCAmelCase       :     Namespace					)       ->				Dict:







   '''simple docstring'''
   return TrainCommand(_UpperCAmelCase					)







class     __lowerCAmelCase					(    __SCREAMING_SNAKE_CASE		):



   @staticmethod
   def 					_lowerCamelCase (		A     :						ArgumentParser)     ->					Union[str, Any]:



      """simple docstring"""






      _UpperCAmelCase	 =     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     :						Optional[Any]				,	A     :						Namespace)     ->					Tuple:



      """simple docstring"""






      _UpperCAmelCase	 =     logging.get_logger('transformers-cli/training')

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

      os.makedirs(args.output				,	exist_ok=_a)
      _UpperCAmelCase	 =     args.output

      _UpperCAmelCase	 =     args.column_label
      _UpperCAmelCase	 =     args.column_text
      _UpperCAmelCase	 =     args.column_id

      self.logger.info(F"Loading {args.task} pipeline for {args.model}")
      if args.task == "text_classification":
         _UpperCAmelCase	 =     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	 =     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	 =     None
      if args.validation_data:
         self.logger.info(F"Loading validation dataset from {args.validation_data}")
         _UpperCAmelCase	 =     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	 =     args.validation_split
      _UpperCAmelCase	 =     args.train_batch_size
      _UpperCAmelCase	 =     args.valid_batch_size
      _UpperCAmelCase	 =     args.learning_rate
      _UpperCAmelCase	 =     args.adam_epsilon



   def 					_lowerCamelCase (		self     :						Optional[int])     ->					Optional[int]:



      """simple docstring"""






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



   def 					_lowerCamelCase (		self     :						List[Any])     ->					Tuple:



      """simple docstring"""






      raise NotImplementedError



   def 					_lowerCamelCase (		self     :						Dict)     ->					Any:



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





import qiskit





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     int					)       ->				qiskit.result.counts.Counts:







			'''simple docstring'''
			_UpperCAmelCase	 =     qiskit.Aer.get_backend('aer_simulator'					)

			# Create a Quantum Circuit acting on the q register
			_UpperCAmelCase	 =     qiskit.QuantumCircuit(_UpperCAmelCase							,     _UpperCAmelCase					)

			# Apply X (NOT) Gate to Qubits 0 & 1
			circuit.x(0					)
			circuit.x(1					)

			# Map the quantum measurement to the classical bits
			circuit.measure([0, 1]							,     [0, 1]					)

			# Execute the circuit on the qasm simulator
			_UpperCAmelCase	 =     qiskit.execute(_UpperCAmelCase							,     _UpperCAmelCase							,     shots=1_000					)

			# Return the histogram data of the results of the experiment.
			return job.result().get_counts(_UpperCAmelCase					)


if __name__ == "__main__":
							UpperCAmelCase__     = single_qubit_measure(2, 2)
							print(f"""Total count for various states are: {counts}""")
