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

def a__       (			A_,	A_   ):






  '''simple docstring'''





  return (preds == labels).mean()




@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""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}    ,			)







@dataclass
class 			UpperCAmelCase_     :


  '''simple docstring'''







  a__       			=						field(metadata={"""help""": """The name of the task to train on: """ + """, """.join(processors.keys()	)}	)
  a__       			=						field(metadata={"""help""": """Should contain the data files for the task."""}	)
  a__       			=						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__       			=						field(
      default=_A    ,			metadata={"""help""": """Overwrite the cached training and evaluation sets"""}	)







def a__       (			):






  '''simple docstring'''





  __magic_name__								=			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)   )
  __magic_name__	,       __magic_name__	,       __magic_name__								=			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:
    __magic_name__								=			processors[data_args.task_name]()
    __magic_name__								=			processor.get_labels()
    __magic_name__								=			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.

  __magic_name__								=			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,	)
  __magic_name__								=			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,	)
  __magic_name__								=			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
  __magic_name__								=			(
      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
  )
  __magic_name__								=			(
      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_   ) -> Dict:
    __magic_name__								=			np.argmax(p.predictions,	axis=1   )
    return {"acc": simple_accuracy(A_,	p.label_ids   )}

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

  # Initialize our Trainer
  __magic_name__								=			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
  __magic_name__								=			{}
  if training_args.do_eval:
    logger.info("""*** Evaluate ***"""   )

    __magic_name__								=			trainer.evaluate()

    __magic_name__								=			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 a__       (			A_   ):






  '''simple docstring'''





  main()


if __name__ == "__main__":
    main()



def a__       (			A_=28123   ):






  '''simple docstring'''





  __magic_name__								=			[1] * (limit + 1)

  for i in range(2,	int(limit**0.5   ) + 1   ):
    sum_divs[i * i] += i
    for k in range(i + 1,	limit // i + 1   ):
      sum_divs[k * i] += k + i

  __magic_name__								=			set()
  __magic_name__								=			0

  for n in range(1,	limit + 1   ):
    if sum_divs[n] > n:
      abundants.add(A_   )

    if not any((n - a in abundants) for a in abundants   ):
      res += n

  return res


if __name__ == "__main__":
    print(solution())

