






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


lowerCamelCase_							      =      logging.getLogger(__name__)

@dataclass
class      _UpperCAmelCase    :




   """simple docstring"""

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





def       __lowercase		(    ) ->		Optional[int]:

      '''simple docstring'''


      _A      =			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.
            _A  ,			_A  ,			_A      =			parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) )
      else:
            _A  ,			_A  ,			_A      =			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"     ,						__lowercase )

      # 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.

      _A      =			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     ,						)
      _A      =			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=__lowercase     ,						)
      _A      =			AutoModelForQuestionAnswering.from_pretrained(
          model_args.model_name_or_path     ,						from_tf=bool(".ckpt" in model_args.model_name_or_path )     ,						config=__lowercase     ,						cache_dir=model_args.cache_dir     ,						)

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

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

      # Initialize our Trainer
      _A      =			Trainer(
          model=__lowercase     ,						args=__lowercase     ,						train_dataset=__lowercase     ,						eval_dataset=__lowercase     ,						data_collator=__lowercase     ,						)

      # 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       __lowercase		(    __lowercase ) ->		Any:

      '''simple docstring'''


      main()


if __name__ == "__main__":
    main()













'''simple docstring'''




from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCamelCase_							      =      logging.get_logger(__name__)

class      _UpperCAmelCase    (  snake_case_		):




   """simple docstring"""

   snake_case					       =		['''input_values''', '''attention_mask''']

   def __init__(	self				:			int   ,   __UpperCAmelCase				:			Optional[int]=1   ,   __UpperCAmelCase				:			List[str]=16000   ,   __UpperCAmelCase				:			Optional[Any]=0.0   ,   __UpperCAmelCase				:			Union[str, Any]=False   ,   __UpperCAmelCase				:			Dict=True   ,   **__UpperCAmelCase				:			int   ,   ):





         '''simple docstring'''





         super().__init__(feature_size=__UpperCAmelCase   ,   sampling_rate=__UpperCAmelCase   ,   padding_value=__UpperCAmelCase   ,   **__UpperCAmelCase	)
         _A      =			return_attention_mask
         _A      =			do_normalize

   @staticmethod
   def 		lowerCAmelCase				(	__UpperCAmelCase				:			List[np.ndarray]   ,   __UpperCAmelCase				:			List[np.ndarray]   ,   __UpperCAmelCase				:			float = 0.0	):





         '''simple docstring'''





         if attention_mask is not None:
               _A      =			np.array(__UpperCAmelCase   ,   np.intaa	)
               _A      =			[]

               for vector, length in zip(__UpperCAmelCase   ,   attention_mask.sum(-1	)	):
                     _A      =			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7	)
                     if length < normed_slice.shape[0]:
                           _A      =			padding_value

                     normed_input_values.append(__UpperCAmelCase	)
         else:
               _A      =			[(x - x.mean()) / np.sqrt(x.var() + 1E-7	) for x in input_values]

         return normed_input_values

   def __call__(	self				:			Dict   ,   __UpperCAmelCase				:			Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]   ,   __UpperCAmelCase				:			Union[bool, str, PaddingStrategy] = False   ,   __UpperCAmelCase				:			Optional[int] = None   ,   __UpperCAmelCase				:			bool = False   ,   __UpperCAmelCase				:			Optional[int] = None   ,   __UpperCAmelCase				:			Optional[bool] = None   ,   __UpperCAmelCase				:			Optional[Union[str, TensorType]] = None   ,   __UpperCAmelCase				:			Optional[int] = None   ,   **__UpperCAmelCase				:			str   ,   ):





         '''simple docstring'''





         if sampling_rate is not None:
               if sampling_rate != self.sampling_rate:
                     raise ValueError(
                         f'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
                         f''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
                         f''' {self.sampling_rate} and not {sampling_rate}.'''	)
         else:
               logger.warning(
                   "It is strongly recommended to pass the ``sampling_rate`` argument to this function. "
                   "Failing to do so can result in silent errors that might be hard to debug."	)

         _A      =			isinstance(__UpperCAmelCase   ,   np.ndarray	) and len(raw_speech.shape	) > 1
         if is_batched_numpy and len(raw_speech.shape	) > 2:
               raise ValueError(f'''Only mono-channel audio is supported for input to {self}'''	)
         _A      =			is_batched_numpy or (
             isinstance(__UpperCAmelCase   ,   (list, tuple)	) and (isinstance(raw_speech[0]   ,   (np.ndarray, tuple, list)	))
         )

         # always return batch
         if not is_batched:
               _A      =			[raw_speech]

         # convert into correct format for padding
         _A      =			BatchFeature({"input_values": raw_speech}	)

         _A      =			self.pad(
             __UpperCAmelCase   ,   padding=__UpperCAmelCase   ,   max_length=__UpperCAmelCase   ,   truncation=__UpperCAmelCase   ,   pad_to_multiple_of=__UpperCAmelCase   ,   return_attention_mask=__UpperCAmelCase   ,   )

         # convert input values to correct format
         _A      =			padded_inputs["input_values"]
         if not isinstance(input_values[0]   ,   np.ndarray	):
               _A      =			[np.asarray(__UpperCAmelCase   ,   dtype=np.floataa	) for array in input_values]
         elif (
             not isinstance(__UpperCAmelCase   ,   np.ndarray	)
             and isinstance(input_values[0]   ,   np.ndarray	)
             and input_values[0].dtype is np.dtype(np.floataa	)
         ):
               _A      =			[array.astype(np.floataa	) for array in input_values]
         elif isinstance(__UpperCAmelCase   ,   np.ndarray	) and input_values.dtype is np.dtype(np.floataa	):
               _A      =			input_values.astype(np.floataa	)

         # convert attention_mask to correct format
         _A      =			padded_inputs.get("attention_mask"	)
         if attention_mask is not None:
               _A      =			[np.asarray(__UpperCAmelCase   ,   dtype=np.intaa	) for array in attention_mask]

         # zero-mean and unit-variance normalization
         if self.do_normalize:
               _A      =			(
                   attention_mask
                   if self._get_padding_strategies(__UpperCAmelCase   ,   max_length=__UpperCAmelCase	) is not PaddingStrategy.DO_NOT_PAD
                   else None
               )
               _A      =			self.zero_mean_unit_var_norm(
                   padded_inputs["input_values"]   ,   attention_mask=__UpperCAmelCase   ,   padding_value=self.padding_value	)

         if return_tensors is not None:
               _A      =			padded_inputs.convert_to_tensors(__UpperCAmelCase	)

         return padded_inputs





