





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										=					logging.getLogger(__name__)



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




def 			lowerCAmelCase_			(				)  ->		Any:
       # 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.

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

       UpperCamelCase_ 							=	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       ,		)
       UpperCamelCase_ 							=	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_       ,		)
       UpperCamelCase_ 							=	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
       UpperCamelCase_ 							=	hasattr(model.config       ,		"lang2id"	)
       UpperCamelCase_ 							=	(
           SquadDataset(
               UpperCamelCase_       ,		tokenizer=UpperCamelCase_       ,		is_language_sensitive=UpperCamelCase_       ,		cache_dir=model_args.cache_dir	)
           if training_args.do_train
           else None
       )
       UpperCamelCase_ 							=	(
           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
       UpperCamelCase_ 							=	DataCollatorWithPadding(UpperCamelCase_       ,		pad_to_multiple_of=8	) if training_args.fpaa else None

       # Initialize our Trainer
       UpperCamelCase_ 							=	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 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		Union[str, Any]:
       # For xla_spawn (TPUs)
       main()


if __name__ == "__main__":
     main()







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


UpperCamelCase__       				=	logging.get_logger(__name__)
class 							__lowercase   (			a__    ):
     _lowerCAmelCase		       =						["input_values", "attention_mask"]



     def __init__(  self   :							Union[str, Any]      ,		lowercase__   :							str=1      ,		lowercase__   :							int=1_6_0_0_0      ,		lowercase__   :							Optional[int]=0.0      ,		lowercase__   :							List[Any]=False      ,		lowercase__   :							Dict=True      ,		**lowercase__   :							Any      ,		):
       super().__init__(feature_size=lowercase__      ,		sampling_rate=lowercase__      ,		padding_value=lowercase__      ,		**lowercase__       )
       a_		    =  return_attention_mask
       a_		    =  do_normalize



     @staticmethod
     def 				__magic_name__		(  lowercase__   :							List[np.ndarray]      ,		lowercase__   :							List[np.ndarray]      ,		lowercase__   :							float = 0.0       ):
       if attention_mask is not None:
         a_		    =  np.array(lowercase__      ,		np.intaa       )
         a_		    =  []

         for vector, length in zip(lowercase__      ,		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(lowercase__       )
       else:
         a_		    =  [(x - x.mean()) / np.sqrt(x.var() + 1e-7       ) for x in input_values]

       return normed_input_values



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

       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(lowercase__      ,		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(lowercase__      ,		(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(
           lowercase__      ,		padding=lowercase__      ,		max_length=lowercase__      ,		truncation=lowercase__      ,		pad_to_multiple_of=lowercase__      ,		return_attention_mask=lowercase__      ,		)

       # convert input values to correct format
       a_		    =  padded_inputs['''input_values''']
       if not isinstance(input_values[0]      ,		np.ndarray       ):
         a_		    =  [np.asarray(lowercase__      ,		dtype=np.floataa       ) for array in input_values]
       elif (
           not isinstance(lowercase__      ,		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(lowercase__      ,		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(lowercase__      ,		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(lowercase__      ,		max_length=lowercase__       ) is not PaddingStrategy.DO_NOT_PAD
             else None
         )
         a_		    =  self.zero_mean_unit_var_norm(
             padded_inputs['''input_values''']      ,		attention_mask=lowercase__      ,		padding_value=self.padding_value       )

       if return_tensors is not None:
         a_		    =  padded_inputs.convert_to_tensors(lowercase__       )

       return padded_inputs
