



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
snake_case__					:     Dict    		=   False
snake_case__					:     Dict    		=   False



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	return TrainCommand(_SCREAMING_SNAKE_CASE   )

class   _A   ( _lowercase	):


						'''simple docstring'''





						@staticmethod
						def     _snake_case	(	lowerCamelCase	:							ArgumentParser	):






							'''simple docstring'''



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

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

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



						def __init__(	self	:							int							,      lowerCamelCase	:							Namespace	):






							'''simple docstring'''



							__lowercase		       =			logging.get_logger("transformers-cli/training"	)

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

							os.makedirs(args.output							,      exist_ok=lowerCamelCase	)
							__lowercase		       =			args.output

							__lowercase		       =			args.column_label
							__lowercase		       =			args.column_text
							__lowercase		       =			args.column_id

							self.logger.info(f"""Loading {args.task} pipeline for {args.model}"""	)
							if args.task == "text_classification":
								__lowercase		       =			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}"""	)
							__lowercase		       =			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							,      )
							__lowercase		       =			None
							if args.validation_data:
								self.logger.info(f"""Loading validation dataset from {args.validation_data}"""	)
								__lowercase		       =			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							,      )

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



						def     _snake_case	(	self	:							Union[str, Any]	):






							'''simple docstring'''



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



						def     _snake_case	(	self	:							Union[str, Any]	):






							'''simple docstring'''



							raise NotImplementedError



						def     _snake_case	(	self	:							int	):






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








# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool

class   _A   ( _lowercase	):


						'''simple docstring'''





						_snake_case			:     Dict      							=      """openai/whisper-base"""
						_snake_case			:     Union[str, Any]      							=      (
						    """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """
						    """transcribed text."""
						)
						_snake_case			:     Any      							=      """transcriber"""
						_snake_case			:     Any      							=      WhisperProcessor
						_snake_case			:     Optional[int]      							=      WhisperForConditionalGeneration

						_snake_case			:     str      							=      ["""audio"""]
						_snake_case			:     Optional[int]      							=      ["""text"""]



						def     _snake_case	(	self	:							List[str]							,      lowerCamelCase	:							Optional[int]	):






							'''simple docstring'''



							return self.pre_processor(lowerCamelCase							,      return_tensors="pt"	).input_features



						def     _snake_case	(	self	:							str							,      lowerCamelCase	:							List[Any]	):






							'''simple docstring'''



							return self.model.generate(inputs=lowerCamelCase	)



						def     _snake_case	(	self	:							List[str]							,      lowerCamelCase	:							Optional[Any]	):






							'''simple docstring'''



							return self.pre_processor.batch_decode(lowerCamelCase							,      skip_special_tokens=lowerCamelCase	)[0]



