





"""simple docstring"""
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


__UpperCamelCase			:		Optional[Any]		    =   logging.getLogger(__name__)







@dataclass
class 	a				:
 snake_case__    	=    field(
     metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}   )
 snake_case__    	=    field(
     default=a__					,      metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}   )
 snake_case__    	=    field(
     default=a__					,      metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}   )
 snake_case__    	=    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.
 snake_case__    	=    field(
     default=a__					,      metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}					,      )


def 						_SCREAMING_SNAKE_CASE       ():
 # See all possible arguments in src/transformers/training_args.py
 # or by passing the --help flag to this script.
 # We now keep distinct sets of args, for a cleaner separation of concerns.

 lowerCAmelCase  							=      HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)       )

 if len(sys.argv       ) == 2 and sys.argv[1].endswith('.json'       ):
  # If we pass only one argument to the script and it's the path to a json file,
  # let's parse it to get our arguments.
  lowerCAmelCase							,lowerCAmelCase							,lowerCAmelCase  							=      parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]       )       )
 else:
  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 if training_args.local_rank in [-1, 0] else logging.WARN   ,			)
 logger.warning(
     'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'   ,			training_args.local_rank   ,			training_args.device   ,			training_args.n_gpu   ,			bool(training_args.local_rank != -1       )   ,			training_args.fpaa   ,			)
 # Set the verbosity to info of the Transformers logger (on main process only):
 if is_main_process(training_args.local_rank       ):
  transformers.utils.logging.set_verbosity_info()
  transformers.utils.logging.enable_default_handler()
  transformers.utils.logging.enable_explicit_format()
 logger.info('Training/evaluation parameters %s'   ,			_UpperCAmelCase       )

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

 lowerCAmelCase  							=      AutoConfig.from_pretrained(
     model_args.config_name if model_args.config_name else model_args.model_name_or_path   ,			cache_dir=model_args.cache_dir   ,			)
 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   ,			use_fast=_UpperCAmelCase   ,			)
 lowerCAmelCase  							=      AutoModelForQuestionAnswering.from_pretrained(
     model_args.model_name_or_path   ,			from_tf=bool('.ckpt' in model_args.model_name_or_path       )   ,			config=_UpperCAmelCase   ,			cache_dir=model_args.cache_dir   ,			)

 # Get datasets
 lowerCAmelCase  							=      hasattr(model.config   ,			'lang2id'       )
 lowerCAmelCase  							=      (
     SquadDataset(
         _UpperCAmelCase   ,			tokenizer=_UpperCAmelCase   ,			is_language_sensitive=_UpperCAmelCase   ,			cache_dir=model_args.cache_dir       )
     if training_args.do_train
     else None
 )
 lowerCAmelCase  							=      (
     SquadDataset(
         _UpperCAmelCase   ,			tokenizer=_UpperCAmelCase   ,			mode='dev'   ,			is_language_sensitive=_UpperCAmelCase   ,			cache_dir=model_args.cache_dir   ,			)
     if training_args.do_eval
     else None
 )

 # Data collator
 lowerCAmelCase  							=      DataCollatorWithPadding(_UpperCAmelCase   ,			pad_to_multiple_of=8       ) if training_args.fpaa else None

 # Initialize our Trainer
 lowerCAmelCase  							=      Trainer(
     model=_UpperCAmelCase   ,			args=_UpperCAmelCase   ,			train_dataset=_UpperCAmelCase   ,			eval_dataset=_UpperCAmelCase   ,			data_collator=_UpperCAmelCase   ,			)

 # Training
 if training_args.do_train:
  trainer.train(
      model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path       ) else None       )
  trainer.save_model()
  # For convenience, we also re-save the tokenizer to the same directory,
  # so that you can share your model easily on huggingface.co/models =)
  if trainer.is_world_master():
   tokenizer.save_pretrained(training_args.output_dir       )

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  Any       ):
 # For xla_spawn (TPUs)
 main()


if __name__ == "__main__":
       main()












"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin







class 	a				(					a__   ):
 snake_case__    	=    '''AutoFeatureExtractor'''
 snake_case__    	=    '''Speech2Text2Tokenizer'''



 def __init__(			self							,    _snake_case							,    _snake_case			):







  """simple docstring"""






  super().__init__(_snake_case							,    _snake_case			)
  lowerCAmelCase  							=      self.feature_extractor
  lowerCAmelCase  							=      False



 def __call__(			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  if self._in_target_context_manager:
   return self.current_processor(*_snake_case							,    **_snake_case			)

  if "raw_speech" in kwargs:
   warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
   lowerCAmelCase  							=      kwargs.pop('raw_speech'			)
  else:
   lowerCAmelCase  							=      kwargs.pop('audio'							,    _snake_case			)
  lowerCAmelCase  							=      kwargs.pop('sampling_rate'							,    _snake_case			)
  lowerCAmelCase  							=      kwargs.pop('text'							,    _snake_case			)
  if len(_snake_case			) > 0:
   lowerCAmelCase  							=      args[0]
   lowerCAmelCase  							=      args[1:]

  if audio is None and text is None:
   raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

  if audio is not None:
   lowerCAmelCase  							=      self.feature_extractor(_snake_case							,    *_snake_case							,    sampling_rate=_snake_case							,    **_snake_case			)
  if text is not None:
   lowerCAmelCase  							=      self.tokenizer(_snake_case							,    **_snake_case			)

  if text is None:
   return inputs
  elif audio is None:
   return encodings
  else:
   lowerCAmelCase  							=      encodings['input_ids']
   return inputs



 def 					UpperCamelCase__   (			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  return self.tokenizer.batch_decode(*_snake_case							,    **_snake_case			)



 def 					UpperCamelCase__   (			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  return self.tokenizer.decode(*_snake_case							,    **_snake_case			)



 @contextmanager
 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  warnings.warn(
      '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
      'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
      'your audio inputs, or in a separate call.'			)
  lowerCAmelCase  							=      True
  lowerCAmelCase  							=      self.tokenizer
  yield
  lowerCAmelCase  							=      self.feature_extractor
  lowerCAmelCase  							=      False





