


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

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


lowerCAmelCase__  :List[Any]             =							logging.getLogger(__name__)

def 	lowerCAmelCase__			(      a__:		Dict      ,  a__:		Union[str, Any]	)  ->		List[Any]:


							'''simple docstring'''





							return (preds == labels).mean()

@dataclass
class 		__a				:
		_a     :  str           =     field(
		    metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}      )
		_a     :  Optional[str]           =     field(
		    default=UpperCAmelCase   ,				metadata={'help': 'Pretrained config name or path if not the same as model_name'}      )
		_a     :  Optional[str]           =     field(
		    default=UpperCAmelCase   ,				metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'}      )
		_a     :  Optional[str]           =     field(
		    default=UpperCAmelCase   ,				metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}   ,				)



@dataclass
class 		__a				:
		_a     :  str           =     field(metadata={'help': 'The name of the task to train on: ' + ', '.join(processors.keys()      )}      )
		_a     :  str           =     field(metadata={'help': 'Should contain the data files for the task.'}      )
		_a     :  int           =     field(
		    default=1_28   ,				metadata={
		        'help': (
		            'The maximum total input sequence length after tokenization. Sequences longer '
		            'than this will be truncated, sequences shorter will be padded.'
		        )
		    }   ,				)
		_a     :  bool           =     field(
		    default=UpperCAmelCase   ,				metadata={'help': 'Overwrite the cached training and evaluation sets'}      )



def 	lowerCAmelCase__			(      )  ->		List[str]:


							'''simple docstring'''





							_UpperCAmelCase					=      HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)	)
							_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'      ,  a__	)

							# Set seed
							set_seed(training_args.seed	)

							try:
														_UpperCAmelCase					=      processors[data_args.task_name]()
														_UpperCAmelCase					=      processor.get_labels()
														_UpperCAmelCase					=      len(a__	)
							except KeyError:
														raise ValueError('Task not found: %s' % (data_args.task_name)	)

							# 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      ,  num_labels=a__      ,  finetuning_task=data_args.task_name      ,  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      ,  )
							_UpperCAmelCase					=      AutoModelForMultipleChoice.from_pretrained(
							    model_args.model_name_or_path      ,  from_tf=bool('.ckpt' in model_args.model_name_or_path	)      ,  config=a__      ,  cache_dir=model_args.cache_dir      ,  )

							# Get datasets
							_UpperCAmelCase					=      (
							    MultipleChoiceDataset(
							        data_dir=data_args.data_dir      ,  tokenizer=a__      ,  task=data_args.task_name      ,  max_seq_length=data_args.max_seq_length      ,  overwrite_cache=data_args.overwrite_cache      ,  mode=Split.train      ,  )
							    if training_args.do_train
							    else None
							)
							_UpperCAmelCase					=      (
							    MultipleChoiceDataset(
							        data_dir=data_args.data_dir      ,  tokenizer=a__      ,  task=data_args.task_name      ,  max_seq_length=data_args.max_seq_length      ,  overwrite_cache=data_args.overwrite_cache      ,  mode=Split.dev      ,  )
							    if training_args.do_eval
							    else None
							)

							def compute_metrics(a__:		EvalPrediction	) -> Dict:
														_UpperCAmelCase					=      np.argmax(p.predictions      ,  axis=1	)
														return {"acc": simple_accuracy(a__      ,  p.label_ids	)}

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

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

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

    # Evaluation
							_UpperCAmelCase					=      {}
							if training_args.do_eval:
														logger.info('*** Evaluate ***'	)

														_UpperCAmelCase					=      trainer.evaluate()

														_UpperCAmelCase					=      os.path.join(training_args.output_dir      ,  'eval_results.txt'	)
														if trainer.is_world_master():
																					with open(a__      ,  'w'	) as writer:
																												logger.info('***** Eval results *****'	)
																												for key, value in result.items():
																																			logger.info('  %s = %s'      ,  a__      ,  a__	)
																																			writer.write('%s = %s\n' % (key, value)	)

																												results.update(a__	)

							return results

def 	lowerCAmelCase__			(      a__:		int	)  ->		List[str]:


							'''simple docstring'''





							main()


if __name__ == "__main__":
					main()




import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin

class 		__a				(    UpperCAmelCase      ):
		_a     :  Optional[int]           =     'MCTCTFeatureExtractor'
		_a     :  int           =     'AutoTokenizer'
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	List[str]:




									"""simple docstring"""





									super().__init__(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      self.feature_extractor
									_UpperCAmelCase					=      False
		def __call__(      self      ,   *_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)			->	Tuple:




									"""simple docstring"""





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

									if "raw_speech" in kwargs:
																warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'						)
																_UpperCAmelCase					=      kwargs.pop('raw_speech'						)
									else:
																_UpperCAmelCase					=      kwargs.pop('audio'      ,   _SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      kwargs.pop('sampling_rate'      ,   _SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      kwargs.pop('text'      ,   _SCREAMING_SNAKE_CASE						)
									if len(_SCREAMING_SNAKE_CASE						) > 0:
																_UpperCAmelCase					=      args[0]
																_UpperCAmelCase					=      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:
																_UpperCAmelCase					=      self.feature_extractor(_SCREAMING_SNAKE_CASE      ,   *_SCREAMING_SNAKE_CASE      ,   sampling_rate=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
									if text is not None:
																_UpperCAmelCase					=      self.tokenizer(_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)

									if text is None:
																return inputs
									elif audio is None:
																return encodings
									else:
																_UpperCAmelCase					=      encodings['input_ids']
																return inputs
		def      UpperCAmelCase__    (      self      ,   *_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)			->	Optional[int]:




									"""simple docstring"""





									return self.tokenizer.batch_decode(*_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self      ,   *_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)			->	str:




									"""simple docstring"""





									if self._in_target_context_manager:
																return self.current_processor.pad(*_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      kwargs.pop('input_features'      ,   _SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      kwargs.pop('labels'      ,   _SCREAMING_SNAKE_CASE						)
									if len(_SCREAMING_SNAKE_CASE						) > 0:
																_UpperCAmelCase					=      args[0]
																_UpperCAmelCase					=      args[1:]

									if input_features is not None:
																_UpperCAmelCase					=      self.feature_extractor.pad(_SCREAMING_SNAKE_CASE      ,   *_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)
									if labels is not None:
																_UpperCAmelCase					=      self.tokenizer.pad(_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)

									if labels is None:
																return input_features
									elif input_features is None:
																return labels
									else:
																_UpperCAmelCase					=      labels['input_ids']
																return input_features
		def      UpperCAmelCase__    (      self      ,   *_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE						)			->	int:




									"""simple docstring"""





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






		@contextmanager
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""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.'						)
									_UpperCAmelCase					=      True
									_UpperCAmelCase					=      self.tokenizer
									yield
									_UpperCAmelCase					=      self.feature_extractor
									_UpperCAmelCase					=      False
