

import logging
import os
import random
import sys
from dataclasses import dataclass, field
from typing import Optional

import datasets
import evaluate
import numpy as np
from datasets import load_dataset

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version


# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.31.0")

require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")

_lowerCamelCase							       =logging.getLogger(__name__)



@dataclass
class 		a_       :



      """simple docstring"""







      __UpperCAmelCase					=      field(
          default=128 ,			metadata={
              'help': (
                  'The maximum total input sequence length after tokenization. Sequences longer '
                  'than this will be truncated, sequences shorter will be padded.'
              )
          } ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Overwrite the cached preprocessed datasets or not.'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={
              'help': (
                  'Whether to pad all samples to `max_seq_length`. '
                  'If False, will pad the samples dynamically when batching to the maximum length in the batch.'
              )
          } ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={
              'help': (
                  'For debugging purposes or quicker training, truncate the number of training examples to this '
                  'value if set.'
              )
          } ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={
              'help': (
                  'For debugging purposes or quicker training, truncate the number of evaluation examples to this '
                  'value if set.'
              )
          } ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={
              'help': (
                  'For debugging purposes or quicker training, truncate the number of prediction examples to this '
                  'value if set.'
              )
          } ,			)







@dataclass
class 		a_       :



      """simple docstring"""







      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Evaluation language. Also train language if `train_language` is set to None.'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Train language if it is different from the evaluation language.'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Pretrained config name or path if not the same as model_name'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'}     )
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'} ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'arg to indicate if tokenizer should do lower case in AutoTokenizer.from_pretrained()'} ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'} ,			)
      __UpperCAmelCase					=      field(
          default='main' ,			metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'} ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={
              'help': (
                  'Will use the token generated when running `huggingface-cli login` (necessary to use this script '
                  'with private models).'
              )
          } ,			)
      __UpperCAmelCase					=      field(
          default=SCREAMING_SNAKE_CASE_ ,			metadata={'help': 'Will enable to load a pretrained model whose head dimensions are different.'} ,			)







def 			snake_case__				(   ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE      						=HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)			)
     SCREAMING_SNAKE_CASE      						=parser.parse_args_into_dataclasses()

     # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
     # information sent is the one passed as arguments along with your Python/PyTorch versions.
     send_example_telemetry('run_xnli',    _lowerCamelCase			)

     # Setup logging
     logging.basicConfig(
         format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',    datefmt='%m/%d/%Y %H:%M:%S',    handlers=[logging.StreamHandler(sys.stdout			)],    )

     if training_args.should_log:
          # The default of training_args.log_level is passive, so we set log level at info here to have that default.
          transformers.utils.logging.set_verbosity_info()

     SCREAMING_SNAKE_CASE      						=training_args.get_process_log_level()
     logger.setLevel(_lowerCamelCase			)
     datasets.utils.logging.set_verbosity(_lowerCamelCase			)
     transformers.utils.logging.set_verbosity(_lowerCamelCase			)
     transformers.utils.logging.enable_default_handler()
     transformers.utils.logging.enable_explicit_format()

     # Log on each process the small summary:
     logger.warning(
         F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
         + F'distributed training: {bool(training_args.local_rank != -1			)}, 16-bits training: {training_args.fpaa}'			)
     logger.info(F'Training/evaluation parameters {training_args}'			)

     # Detecting last checkpoint.
     SCREAMING_SNAKE_CASE      						=None
     if os.path.isdir(training_args.output_dir			) and training_args.do_train and not training_args.overwrite_output_dir:
          SCREAMING_SNAKE_CASE      						=get_last_checkpoint(training_args.output_dir			)
          if last_checkpoint is None and len(os.listdir(training_args.output_dir			)			) > 0:
               raise ValueError(
                   F'Output directory ({training_args.output_dir}) already exists and is not empty. '
                   'Use --overwrite_output_dir to overcome.'			)
          elif last_checkpoint is not None:
               logger.info(
                   F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
                   'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.'			)

          # Set seed before initializing model.
     set_seed(training_args.seed			)

     # In distributed training, the load_dataset function guarantees that only one local process can concurrently
     # download the dataset.
     # Downloading and loading xnli dataset from the hub.
     if training_args.do_train:
          if model_args.train_language is None:
               SCREAMING_SNAKE_CASE      						=load_dataset(
                   'xnli',    model_args.language,    split='train',    cache_dir=model_args.cache_dir,    use_auth_token=True if model_args.use_auth_token else None,    )
          else:
               SCREAMING_SNAKE_CASE      						=load_dataset(
                   'xnli',    model_args.train_language,    split='train',    cache_dir=model_args.cache_dir,    use_auth_token=True if model_args.use_auth_token else None,    )
          SCREAMING_SNAKE_CASE      						=train_dataset.features["""label"""].names

     if training_args.do_eval:
          SCREAMING_SNAKE_CASE      						=load_dataset(
              'xnli',    model_args.language,    split='validation',    cache_dir=model_args.cache_dir,    use_auth_token=True if model_args.use_auth_token else None,    )
          SCREAMING_SNAKE_CASE      						=eval_dataset.features["""label"""].names

     if training_args.do_predict:
          SCREAMING_SNAKE_CASE      						=load_dataset(
              'xnli',    model_args.language,    split='test',    cache_dir=model_args.cache_dir,    use_auth_token=True if model_args.use_auth_token else None,    )
          SCREAMING_SNAKE_CASE      						=predict_dataset.features["""label"""].names

     # Labels
     SCREAMING_SNAKE_CASE      						=len(_lowerCamelCase			)

     # Load pretrained model and tokenizer
     # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently
     # download model & vocab.
     SCREAMING_SNAKE_CASE      						=AutoConfig.from_pretrained(
         model_args.config_name if model_args.config_name else model_args.model_name_or_path,    num_labels=_lowerCamelCase,    idalabel={str(_lowerCamelCase			): label for i, label in enumerate(_lowerCamelCase			)},    labelaid={label: i for i, label in enumerate(_lowerCamelCase			)},    finetuning_task='xnli',    cache_dir=model_args.cache_dir,    revision=model_args.model_revision,    use_auth_token=True if model_args.use_auth_token else None,    )
     SCREAMING_SNAKE_CASE      						=AutoTokenizer.from_pretrained(
         model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,    do_lower_case=model_args.do_lower_case,    cache_dir=model_args.cache_dir,    use_fast=model_args.use_fast_tokenizer,    revision=model_args.model_revision,    use_auth_token=True if model_args.use_auth_token else None,    )
     SCREAMING_SNAKE_CASE      						=AutoModelForSequenceClassification.from_pretrained(
         model_args.model_name_or_path,    from_tf=bool('.ckpt' in model_args.model_name_or_path			),    config=_lowerCamelCase,    cache_dir=model_args.cache_dir,    revision=model_args.model_revision,    use_auth_token=True if model_args.use_auth_token else None,    ignore_mismatched_sizes=model_args.ignore_mismatched_sizes,    )

     # Preprocessing the datasets
     # Padding strategy
     if data_args.pad_to_max_length:
          SCREAMING_SNAKE_CASE      						="""max_length"""
     else:
          # We will pad later, dynamically at batch creation, to the max sequence length in each batch
          SCREAMING_SNAKE_CASE      						=False

     def preprocess_function(lowerCAmelCase_			):
          # Tokenize the texts
          return tokenizer(
              examples['premise'],    examples['hypothesis'],    padding=_lowerCamelCase,    max_length=data_args.max_seq_length,    truncation=_lowerCamelCase,    )

     if training_args.do_train:
          if data_args.max_train_samples is not None:
               SCREAMING_SNAKE_CASE      						=min(len(_lowerCamelCase			),    data_args.max_train_samples			)
               SCREAMING_SNAKE_CASE      						=train_dataset.select(range(_lowerCamelCase			)			)
          with training_args.main_process_first(desc='train dataset map pre-processing'			):
               SCREAMING_SNAKE_CASE      						=train_dataset.map(
                   _lowerCamelCase,    batched=_lowerCamelCase,    load_from_cache_file=not data_args.overwrite_cache,    desc='Running tokenizer on train dataset',    )
          # Log a few random samples from the training set:
          for index in random.sample(range(len(_lowerCamelCase			)			),    3			):
               logger.info(F'Sample {index} of the training set: {train_dataset[index]}.'			)

     if training_args.do_eval:
          if data_args.max_eval_samples is not None:
               SCREAMING_SNAKE_CASE      						=min(len(_lowerCamelCase			),    data_args.max_eval_samples			)
               SCREAMING_SNAKE_CASE      						=eval_dataset.select(range(_lowerCamelCase			)			)
          with training_args.main_process_first(desc='validation dataset map pre-processing'			):
               SCREAMING_SNAKE_CASE      						=eval_dataset.map(
                   _lowerCamelCase,    batched=_lowerCamelCase,    load_from_cache_file=not data_args.overwrite_cache,    desc='Running tokenizer on validation dataset',    )

     if training_args.do_predict:
          if data_args.max_predict_samples is not None:
               SCREAMING_SNAKE_CASE      						=min(len(_lowerCamelCase			),    data_args.max_predict_samples			)
               SCREAMING_SNAKE_CASE      						=predict_dataset.select(range(_lowerCamelCase			)			)
          with training_args.main_process_first(desc='prediction dataset map pre-processing'			):
               SCREAMING_SNAKE_CASE      						=predict_dataset.map(
                   _lowerCamelCase,    batched=_lowerCamelCase,    load_from_cache_file=not data_args.overwrite_cache,    desc='Running tokenizer on prediction dataset',    )

          # Get the metric function
     SCREAMING_SNAKE_CASE      						=evaluate.load('xnli'			)

     # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a
     # predictions and label_ids field) and has to return a dictionary string to float.
     def compute_metrics(lowerCAmelCase_			):
          SCREAMING_SNAKE_CASE      						=p.predictions[0] if isinstance(p.predictions,    _lowerCamelCase			) else p.predictions
          SCREAMING_SNAKE_CASE      						=np.argmax(_lowerCamelCase,    axis=1			)
          return metric.compute(predictions=_lowerCamelCase,    references=p.label_ids			)

     # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding.
     if data_args.pad_to_max_length:
          SCREAMING_SNAKE_CASE      						=default_data_collator
     elif training_args.fpaa:
          SCREAMING_SNAKE_CASE      						=DataCollatorWithPadding(_lowerCamelCase,    pad_to_multiple_of=8			)
     else:
          SCREAMING_SNAKE_CASE      						=None

     # Initialize our Trainer
     SCREAMING_SNAKE_CASE      						=Trainer(
         model=_lowerCamelCase,    args=_lowerCamelCase,    train_dataset=train_dataset if training_args.do_train else None,    eval_dataset=eval_dataset if training_args.do_eval else None,    compute_metrics=_lowerCamelCase,    tokenizer=_lowerCamelCase,    data_collator=_lowerCamelCase,    )

     # Training
     if training_args.do_train:
          SCREAMING_SNAKE_CASE      						=None
          if training_args.resume_from_checkpoint is not None:
               SCREAMING_SNAKE_CASE      						=training_args.resume_from_checkpoint
          elif last_checkpoint is not None:
               SCREAMING_SNAKE_CASE      						=last_checkpoint
          SCREAMING_SNAKE_CASE      						=trainer.train(resume_from_checkpoint=_lowerCamelCase			)
          SCREAMING_SNAKE_CASE      						=train_result.metrics
          SCREAMING_SNAKE_CASE      						=(
              data_args.max_train_samples if data_args.max_train_samples is not None else len(_lowerCamelCase			)
          )
          SCREAMING_SNAKE_CASE      						=min(_lowerCamelCase,    len(_lowerCamelCase			)			)

          trainer.save_model()  # Saves the tokenizer too for easy upload

          trainer.log_metrics('train',    _lowerCamelCase			)
          trainer.save_metrics('train',    _lowerCamelCase			)
          trainer.save_state()

     # Evaluation
     if training_args.do_eval:
          logger.info('*** Evaluate ***'			)
          SCREAMING_SNAKE_CASE      						=trainer.evaluate(eval_dataset=_lowerCamelCase			)

          SCREAMING_SNAKE_CASE      						=data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_lowerCamelCase			)
          SCREAMING_SNAKE_CASE      						=min(_lowerCamelCase,    len(_lowerCamelCase			)			)

          trainer.log_metrics('eval',    _lowerCamelCase			)
          trainer.save_metrics('eval',    _lowerCamelCase			)

     # Prediction
     if training_args.do_predict:
          logger.info('*** Predict ***'			)
          SCREAMING_SNAKE_CASE      						=trainer.predict(_lowerCamelCase,    metric_key_prefix='predict'			)

          SCREAMING_SNAKE_CASE      						=(
              data_args.max_predict_samples if data_args.max_predict_samples is not None else len(_lowerCamelCase			)
          )
          SCREAMING_SNAKE_CASE      						=min(_lowerCamelCase,    len(_lowerCamelCase			)			)

          trainer.log_metrics('predict',    _lowerCamelCase			)
          trainer.save_metrics('predict',    _lowerCamelCase			)

          SCREAMING_SNAKE_CASE      						=np.argmax(_lowerCamelCase,    axis=1			)
          SCREAMING_SNAKE_CASE      						=os.path.join(training_args.output_dir,    'predictions.txt'			)
          if trainer.is_world_process_zero():
               with open(_lowerCamelCase,    'w'			) as writer:
                    writer.write('index\tprediction\n'			)
                    for index, item in enumerate(_lowerCamelCase			):
                         SCREAMING_SNAKE_CASE      						=label_list[item]
                         writer.write(F'{index}\t{item}\n'			)


if __name__ == "__main__":
 main()


"""simple docstring"""




from math import ceil





def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       Union[str, Any]			,_lowerCamelCase						:       Union[str, Any]	)       ->      int:
  _lowerCAmelCase						:       Dict  			=     list(range(0			,_lowerCamelCase	)	)

  _lowerCAmelCase						:       Tuple  			=     [item for sublist in list(device_map.values()	) for item in sublist]

  # Duplicate check
  _lowerCAmelCase						:       Union[str, Any]  			=     []
  for i in device_map_blocks:
    if device_map_blocks.count(_lowerCamelCase	) > 1 and i not in duplicate_blocks:
      duplicate_blocks.append(_lowerCamelCase	)
    # Missing blocks
  _lowerCAmelCase						:       int  			=     [i for i in blocks if i not in device_map_blocks]
  _lowerCAmelCase						:       List[Any]  			=     [i for i in device_map_blocks if i not in blocks]

  if len(_lowerCamelCase	) != 0:
    raise ValueError(
        """Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device."""
        """ These attention blocks were specified more than once: """ + str(_lowerCamelCase	)	)
  if len(_lowerCamelCase	) != 0:
    raise ValueError(
        """There are attention blocks for this model that are not specified in the device_map. Add these attention """
        """blocks to a device on the device_map: """ + str(_lowerCamelCase	)	)
  if len(_lowerCamelCase	) != 0:
    raise ValueError(
        """The device_map contains more attention blocks than this model has. Remove these from the device_map:"""
        + str(_lowerCamelCase	)	)






def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       int			,_lowerCamelCase						:       Tuple	)       ->      str:
  _lowerCAmelCase						:       Optional[Any]  			=     list(range(_lowerCamelCase	)	)
  _lowerCAmelCase						:       Optional[Any]  			=     int(ceil(n_layers / len(_lowerCamelCase	)	)	)
  _lowerCAmelCase						:       Optional[int]  			=     [layers[i : i + n_blocks] for i in range(0			,_lowerCamelCase			,_lowerCamelCase	)]

  return dict(zip(_lowerCamelCase			,_lowerCamelCase	)	)




