import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()




def       __magic_name__(  __UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase = None ,						)						->    List[Any]:



      '''simple docstring'''

      _lowerCamelCase			    =				{}

      if train_file is not None:
            _lowerCamelCase			    =				[train_file]
      if eval_file is not None:
            _lowerCamelCase			    =				[eval_file]
      if test_file is not None:
            _lowerCamelCase			    =				[test_file]

      _lowerCamelCase			    =				datasets.load_dataset('''csv''' ,						data_files=UpperCAmelCase__		)
      _lowerCamelCase			    =				list(ds[list(files.keys()		)[0]].features.keys()		)
      _lowerCamelCase			    =				features_name.pop(UpperCAmelCase__		)
      _lowerCamelCase			    =				list(set(ds[list(files.keys()		)[0]][label_name]		)		)
      _lowerCamelCase			    =				{label: i for i, label in enumerate(UpperCAmelCase__		)}
      _lowerCamelCase			    =				tokenizer.model_input_names
      _lowerCamelCase			    =				{}

      if len(UpperCAmelCase__		) == 1:
            for k in files.keys():
                  _lowerCamelCase			    =				ds[k].map(
                      lambda __UpperCAmelCase		: tokenizer.batch_encode_plus(
                          example[features_name[0]] ,						truncation=UpperCAmelCase__ ,						max_length=UpperCAmelCase__ ,						padding='''max_length'''		) ,						batched=UpperCAmelCase__ ,						)
      elif len(UpperCAmelCase__		) == 2:
            for k in files.keys():
                  _lowerCamelCase			    =				ds[k].map(
                      lambda __UpperCAmelCase		: tokenizer.batch_encode_plus(
                          (example[features_name[0]], example[features_name[1]]) ,						truncation=UpperCAmelCase__ ,						max_length=UpperCAmelCase__ ,						padding='''max_length''' ,						) ,						batched=UpperCAmelCase__ ,						)

      def gen_train():
            for ex in transformed_ds[datasets.Split.TRAIN]:
                  _lowerCamelCase			    =				{k: v for k, v in ex.items() if k in input_names}
                  _lowerCamelCase			    =				labelaid[ex[label_name]]
                  yield (d, label)

      def gen_val():
            for ex in transformed_ds[datasets.Split.VALIDATION]:
                  _lowerCamelCase			    =				{k: v for k, v in ex.items() if k in input_names}
                  _lowerCamelCase			    =				labelaid[ex[label_name]]
                  yield (d, label)

      def gen_test():
            for ex in transformed_ds[datasets.Split.TEST]:
                  _lowerCamelCase			    =				{k: v for k, v in ex.items() if k in input_names}
                  _lowerCamelCase			    =				labelaid[ex[label_name]]
                  yield (d, label)

      _lowerCamelCase			    =				(
          tf.data.Dataset.from_generator(
              UpperCAmelCase__ ,						({k: tf.intaa for k in input_names}, tf.intaa) ,						({k: tf.TensorShape([None]		) for k in input_names}, tf.TensorShape([]		)) ,						)
          if datasets.Split.TRAIN in transformed_ds
          else None
      )

      if train_ds is not None:
            _lowerCamelCase			    =				train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN]		)		)		)

      _lowerCamelCase			    =				(
          tf.data.Dataset.from_generator(
              UpperCAmelCase__ ,						({k: tf.intaa for k in input_names}, tf.intaa) ,						({k: tf.TensorShape([None]		) for k in input_names}, tf.TensorShape([]		)) ,						)
          if datasets.Split.VALIDATION in transformed_ds
          else None
      )

      if val_ds is not None:
            _lowerCamelCase			    =				val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION]		)		)		)

      _lowerCamelCase			    =				(
          tf.data.Dataset.from_generator(
              UpperCAmelCase__ ,						({k: tf.intaa for k in input_names}, tf.intaa) ,						({k: tf.TensorShape([None]		) for k in input_names}, tf.TensorShape([]		)) ,						)
          if datasets.Split.TEST in transformed_ds
          else None
      )

      if test_ds is not None:
            _lowerCamelCase			    =				test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST]		)		)		)

      return train_ds, val_ds, test_ds, labelaid


snake_case__				= logging.getLogger(__name__)



@dataclass
class  UpperCamelCase				:

     '''simple docstring'''

     A_										=  field(metadata={'help': 'Which column contains the label'} )
     A_										=  field(default=_a   ,  metadata={'help': 'The path of the training file'} )
     A_										=  field(default=_a   ,  metadata={'help': 'The path of the development file'} )
     A_										=  field(default=_a   ,  metadata={'help': 'The path of the test file'} )
     A_										=  field(
         default=128   ,  metadata={
             'help': (
                 'The maximum total input sequence length after tokenization. Sequences longer '
                 'than this will be truncated, sequences shorter will be padded.'
             )
         }   ,  )
     A_										=  field(
         default=_a   ,  metadata={'help': 'Overwrite the cached training and evaluation sets'} )





@dataclass
class  UpperCamelCase				:

     '''simple docstring'''

     A_										=  field(
         metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
     A_										=  field(
         default=_a   ,  metadata={'help': 'Pretrained config name or path if not the same as model_name'} )
     A_										=  field(
         default=_a   ,  metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} )
     A_										=  field(default=_a   ,  metadata={'help': 'Set this flag to use fast tokenization.'} )
     # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
     # or just modify its tokenizer_config.json.
     A_										=  field(
         default=_a   ,  metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}   ,  )





def       __magic_name__(  )						->    Optional[Any]:



      '''simple docstring'''

      _lowerCamelCase			    =				HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)		)
      _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				parser.parse_args_into_dataclasses()

      if (
          os.path.exists(training_args.output_dir		)
          and os.listdir(training_args.output_dir		)
          and training_args.do_train
          and not training_args.overwrite_output_dir
      ):
            raise ValueError(
                F'Output directory ({training_args.output_dir}) already exists and is not empty. Use'
                ''' --overwrite_output_dir to overcome.'''		)

      # Setup logging
      logging.basicConfig(
          format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''' ,						datefmt='''%m/%d/%Y %H:%M:%S''' ,						level=logging.INFO ,						)
      logger.info(
          F'n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1		)}, '
          F'16-bits training: {training_args.fpaa}'		)
      logger.info(F'Training/evaluation parameters {training_args}'		)

      # Load pretrained model and tokenizer
      #
      # Distributed training:
      # The .from_pretrained methods guarantee that only one local process can concurrently
      # download model & vocab.

      _lowerCamelCase			    =				AutoTokenizer.from_pretrained(
          model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path ,						cache_dir=model_args.cache_dir ,						)

      _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				get_tfds(
          train_file=data_args.train_file ,						eval_file=data_args.dev_file ,						test_file=data_args.test_file ,						tokenizer=UpperCAmelCase__ ,						label_column_id=data_args.label_column_id ,						max_seq_length=data_args.max_seq_length ,						)

      _lowerCamelCase			    =				AutoConfig.from_pretrained(
          model_args.config_name if model_args.config_name else model_args.model_name_or_path ,						num_labels=len(UpperCAmelCase__		) ,						labelaid=UpperCAmelCase__ ,						idalabel={id: label for label, id in labelaid.items()} ,						finetuning_task='''text-classification''' ,						cache_dir=model_args.cache_dir ,						)

      with training_args.strategy.scope():
            _lowerCamelCase			    =				TFAutoModelForSequenceClassification.from_pretrained(
                model_args.model_name_or_path ,						from_pt=bool('''.bin''' in model_args.model_name_or_path		) ,						config=UpperCAmelCase__ ,						cache_dir=model_args.cache_dir ,						)

      def compute_metrics(__UpperCAmelCase		) -> Dict:
            _lowerCamelCase			    =				np.argmax(p.predictions ,						axis=1		)

            return {"acc": (preds == p.label_ids).mean()}

      # Initialize our Trainer
      _lowerCamelCase			    =				TFTrainer(
          model=UpperCAmelCase__ ,						args=UpperCAmelCase__ ,						train_dataset=UpperCAmelCase__ ,						eval_dataset=UpperCAmelCase__ ,						compute_metrics=UpperCAmelCase__ ,						)

      # Training
      if training_args.do_train:
            trainer.train()
            trainer.save_model()
            tokenizer.save_pretrained(training_args.output_dir		)

      # Evaluation
      _lowerCamelCase			    =				{}
      if training_args.do_eval:
            logger.info('''*** Evaluate ***'''		)
            _lowerCamelCase			    =				trainer.evaluate()
            _lowerCamelCase			    =				os.path.join(training_args.output_dir ,						'''eval_results.txt'''		)

            with open(UpperCAmelCase__ ,						'''w'''		) as writer:
                  logger.info('''***** Eval results *****'''		)

                  for key, value in result.items():
                        logger.info(F'  {key} = {value}'		)
                        writer.write(F'{key} = {value}\n'		)

                  results.update(UpperCAmelCase__		)

      return results


if __name__ == "__main__":
     main()
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case__				= {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= ['WhisperTokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'WhisperForConditionalGeneration',
         'WhisperModel',
         'WhisperPreTrainedModel',
         'WhisperForAudioClassification',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFWhisperForConditionalGeneration',
         'TFWhisperModel',
         'TFWhisperPreTrainedModel',
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'FlaxWhisperForConditionalGeneration',
         'FlaxWhisperModel',
         'FlaxWhisperPreTrainedModel',
         'FlaxWhisperForAudioClassification',
     ]


if TYPE_CHECKING:
     from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
     from .feature_extraction_whisper import WhisperFeatureExtractor
     from .processing_whisper import WhisperProcessor
     from .tokenization_whisper import WhisperTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_whisper_fast import WhisperTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_whisper import (
              WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              WhisperForAudioClassification,
              WhisperForConditionalGeneration,
              WhisperModel,
              WhisperPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_whisper import (
              TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFWhisperForConditionalGeneration,
              TFWhisperModel,
              TFWhisperPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_whisper import (
              FlaxWhisperForAudioClassification,
              FlaxWhisperForConditionalGeneration,
              FlaxWhisperModel,
              FlaxWhisperPreTrainedModel,
          )

else:
     import sys

     snake_case__				= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)