





'''simple docstring'''






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

import numpy as np
import torch
from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import is_main_process


snake_case_     			=						logging.getLogger(__name__)


@dataclass
class 	_lowercase    :
   _UpperCamelCase									= field(
       metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}					)
   _UpperCamelCase									= field(
       default=a		,       metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}					)
   _UpperCamelCase									= field(
       default=a		,       metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}					)
   _UpperCamelCase									= field(
       default=a		,       metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}		,       )







@dataclass
class 	_lowercase    :
   _UpperCamelCase									= field(
       metadata={"""help""": """The name of the task to train selected in the list: """ + """, """.join(hans_processors.keys()					)}					)
   _UpperCamelCase									= field(
       metadata={"""help""": """The input data dir. Should contain the .tsv files (or other data files) for the task."""}					)
   _UpperCamelCase									= 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."""
           )
       }		,       )
   _UpperCamelCase									= field(
       default=a		,       metadata={"""help""": """Overwrite the cached training and evaluation sets"""}					)







def 				_lowerCamelCase(	UpperCamelCase__     :			List[InputFeatures]		)		->	Dict[str, torch.Tensor]:
    A							:							Union[str, Any]				=    default_data_collator(UpperCamelCase__		)
    A							:							Tuple				=    batch.pop('''pairID'''     ,							UpperCamelCase__		)
    return batch
def 				_lowerCamelCase(	)		->	int:
    # 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.

    A							:							Dict				=    HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)		)
    A,						A,						A							:							str				=    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__		)

    # Set seed
    set_seed(training_args.seed		)

    try:
        A							:							int				=    hans_tasks_num_labels[data_args.task_name]
    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.

    A							:							Any				=    AutoConfig.from_pretrained(
        model_args.config_name if model_args.config_name else model_args.model_name_or_path     ,							num_labels=UpperCamelCase__     ,							finetuning_task=data_args.task_name     ,							cache_dir=model_args.cache_dir     ,							)
    A							:							Union[str, Any]				=    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     ,							)
    A							:							Dict				=    AutoModelForSequenceClassification.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
    A							:							Tuple				=    (
        HansDataset(
            data_dir=data_args.data_dir     ,							tokenizer=UpperCamelCase__     ,							task=data_args.task_name     ,							max_seq_length=data_args.max_seq_length     ,							overwrite_cache=data_args.overwrite_cache     ,							)
        if training_args.do_train
        else None
    )
    A							:							str				=    (
        HansDataset(
            data_dir=data_args.data_dir     ,							tokenizer=UpperCamelCase__     ,							task=data_args.task_name     ,							max_seq_length=data_args.max_seq_length     ,							overwrite_cache=data_args.overwrite_cache     ,							evaluate=UpperCamelCase__     ,							)
        if training_args.do_eval
        else None
    )

    # Initialize our Trainer
    A							:							Tuple				=    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		)

    # Evaluation
    if training_args.do_eval:
        logger.info('''*** Evaluate ***'''		)

        A							:							Optional[Any]				=    trainer.predict(UpperCamelCase__		)
        A							:							Optional[int]				=    output.predictions
        A							:							List[Any]				=    np.argmax(UpperCamelCase__     ,							axis=1		)

        A							:							Optional[int]				=    [ex.pairID for ex in eval_dataset]
        A							:							Optional[Any]				=    os.path.join(training_args.output_dir     ,							'''hans_predictions.txt'''		)
        A							:							Optional[int]				=    eval_dataset.get_labels()
        if trainer.is_world_master():
            with open(UpperCamelCase__     ,							'''w'''		) as writer:
                writer.write('''pairID,gold_label\n'''		)
                for pid, pred in zip(UpperCamelCase__     ,							UpperCamelCase__		):
                    writer.write('''ex''' + str(UpperCamelCase__		) + ''',''' + label_list[int(UpperCamelCase__		)] + '''\n'''		)

        trainer._log(output.metrics		)
def 				_lowerCamelCase(	UpperCamelCase__     :			Any		)		->	Optional[Any]:
    # For xla_spawn (TPUs)
    main()


if __name__ == "__main__":
     main()







'''simple docstring'''






import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


snake_case_     			=						logging.get_logger(__name__)


snake_case_     			=						{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all MVP models at https://huggingface.co/models?filter=mvp
snake_case_     			=						{
    """vocab_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json""",
    },
    """added_tokens.json""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json""",
    },
    """merges_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt""",
    },
}

snake_case_     			=						{
    """RUCAIBox/mvp""": 10_24,
}
@lru_cache()
def 				_lowerCamelCase(	)		->	str:
    A							:							Dict				=    (
        list(range(ord('''!'''		)     ,							ord('''~'''		) + 1		)		) + list(range(ord('''¡'''		)     ,							ord('''¬'''		) + 1		)		) + list(range(ord('''®'''		)     ,							ord('''ÿ'''		) + 1		)		)
    )
    A							:							int				=    bs[:]
    A							:							Any				=    0
    for b in range(2**8		):
        if b not in bs:
            bs.append(UpperCamelCase__		)
            cs.append(2**8 + n		)
            n += 1
    A							:							Union[str, Any]				=    [chr(UpperCamelCase__		) for n in cs]
    return dict(zip(UpperCamelCase__     ,							UpperCamelCase__		)		)
def 				_lowerCamelCase(	UpperCamelCase__     :			List[Any]		)		->	str:
    A							:							Tuple				=    set()
    A							:							Optional[Any]				=    word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)		)
        A							:							Tuple				=    char
    return pairs





class 	_lowercase    (				a					):
   _UpperCamelCase									= VOCAB_FILES_NAMES
   _UpperCamelCase									= PRETRAINED_VOCAB_FILES_MAP
   _UpperCamelCase									= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _UpperCamelCase									= ["""input_ids""", """attention_mask"""]


   def __init__(			self     , _UpperCAmelCase     , _UpperCAmelCase     , _UpperCAmelCase="replace"     , _UpperCAmelCase="<s>"     , _UpperCAmelCase="</s>"     , _UpperCAmelCase="</s>"     , _UpperCAmelCase="<s>"     , _UpperCAmelCase="<unk>"     , _UpperCAmelCase="<pad>"     , _UpperCAmelCase="<mask>"     , _UpperCAmelCase=False     , **_UpperCAmelCase     , ):
       A							:							int				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else bos_token
       A							:							List[str]				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else eos_token
       A							:							List[str]				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else sep_token
       A							:							Dict				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else cls_token
       A							:							str				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else unk_token
       A							:							str				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else pad_token

       # Mask token behave like a normal word, i.e. include the space before it
       A							:							Dict				=    AddedToken(_UpperCAmelCase     , lstrip=_UpperCAmelCase     , rstrip=_UpperCAmelCase       ) if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ) else mask_token

       super().__init__(
           errors=_UpperCAmelCase     , bos_token=_UpperCAmelCase     , eos_token=_UpperCAmelCase     , unk_token=_UpperCAmelCase     , sep_token=_UpperCAmelCase     , cls_token=_UpperCAmelCase     , pad_token=_UpperCAmelCase     , mask_token=_UpperCAmelCase     , add_prefix_space=_UpperCAmelCase     , **_UpperCAmelCase     , )
       with open(_UpperCAmelCase     , encoding='''utf-8'''       ) as vocab_handle:
           A							:							List[str]				=    json.load(_UpperCAmelCase       )
       A							:							Optional[int]				=    {v: k for k, v in self.encoder.items()}
       A							:							List[str]				=    errors  # how to handle errors in decoding
       A							:							Optional[Any]				=    bytes_to_unicode()
       A							:							Dict				=    {v: k for k, v in self.byte_encoder.items()}
       with open(_UpperCAmelCase     , encoding='''utf-8'''       ) as merges_handle:
           A							:							Union[str, Any]				=    merges_handle.read().split('''\n'''       )[1:-1]
       A							:							int				=    [tuple(merge.split()       ) for merge in bpe_merges]
       A							:							int				=    dict(zip(_UpperCAmelCase     , range(len(_UpperCAmelCase       )       )       )       )
       A							:							Tuple				=    {}
       A							:							Tuple				=    add_prefix_space

       # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
       A							:							int				=    re.compile(R'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'''       )


   @property
   def        snake_case					(			self       ):
       return len(self.encoder       )


   def        snake_case					(			self       ):
       return dict(self.encoder     , **self.added_tokens_encoder       )


   def        snake_case					(			self     , _UpperCAmelCase       ):
       if token in self.cache:
           return self.cache[token]
       A							:							Dict				=    tuple(_UpperCAmelCase       )
       A							:							Dict				=    get_pairs(_UpperCAmelCase       )

       if not pairs:
           return token

       while True:
           A							:							Optional[int]				=    min(_UpperCAmelCase     , key=lambda _UpperCAmelCase       : self.bpe_ranks.get(_UpperCAmelCase     , float('''inf'''       )       )       )
           if bigram not in self.bpe_ranks:
               break
           A,						A							:							Optional[int]				=    bigram
           A							:							str				=    []
           A							:							Any				=    0
           while i < len(_UpperCAmelCase       ):
               try:
                   A							:							List[Any]				=    word.index(_UpperCAmelCase     , _UpperCAmelCase       )
               except ValueError:
                   new_word.extend(word[i:]       )
                   break
               else:
                   new_word.extend(word[i:j]       )
                   A							:							str				=    j

               if word[i] == first and i < len(_UpperCAmelCase       ) - 1 and word[i + 1] == second:
                   new_word.append(first + second       )
                   i += 2
               else:
                   new_word.append(word[i]       )
                   i += 1
           A							:							Optional[Any]				=    tuple(_UpperCAmelCase       )
           A							:							int				=    new_word
           if len(_UpperCAmelCase       ) == 1:
               break
           else:
               A							:							Union[str, Any]				=    get_pairs(_UpperCAmelCase       )
       A							:							int				=    ''' '''.join(_UpperCAmelCase       )
       A							:							List[Any]				=    word
       return word


   def        snake_case					(			self     , _UpperCAmelCase       ):
       A							:							str				=    []
       for token in re.findall(self.pat     , _UpperCAmelCase       ):
           A							:							Optional[int]				=    ''''''.join(
               self.byte_encoder[b] for b in token.encode('''utf-8'''       )       )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
           bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_UpperCAmelCase       ).split(''' '''       )       )
       return bpe_tokens


   def        snake_case					(			self     , _UpperCAmelCase       ):
       return self.encoder.get(_UpperCAmelCase     , self.encoder.get(self.unk_token       )       )


   def        snake_case					(			self     , _UpperCAmelCase       ):
       return self.decoder.get(_UpperCAmelCase       )


   def        snake_case					(			self     , _UpperCAmelCase       ):
       A							:							int				=    ''''''.join(_UpperCAmelCase       )
       A							:							Any				=    bytearray([self.byte_decoder[c] for c in text]       ).decode('''utf-8'''     , errors=self.errors       )
       return text


   def        snake_case					(			self     , _UpperCAmelCase     , _UpperCAmelCase = None       ):
       if not os.path.isdir(_UpperCAmelCase       ):
           logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''       )
           return
       A							:							Optional[Any]				=    os.path.join(
           _UpperCAmelCase     , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']       )
       A							:							Tuple				=    os.path.join(
           _UpperCAmelCase     , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']       )

       with open(_UpperCAmelCase     , '''w'''     , encoding='''utf-8'''       ) as f:
           f.write(json.dumps(self.encoder     , indent=2     , sort_keys=_UpperCAmelCase     , ensure_ascii=_UpperCAmelCase       ) + '''\n'''       )

       A							:							str				=    0
       with open(_UpperCAmelCase     , '''w'''     , encoding='''utf-8'''       ) as writer:
           writer.write('''#version: 0.2\n'''       )
           for bpe_tokens, token_index in sorted(self.bpe_ranks.items()     , key=lambda _UpperCAmelCase       : kv[1]       ):
               if index != token_index:
                   logger.warning(
                       f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
                       ''' Please check that the tokenizer is not corrupted!'''       )
                   A							:							int				=    token_index
               writer.write(''' '''.join(_UpperCAmelCase       ) + '''\n'''       )
               index += 1

       return vocab_file, merge_file


   def        snake_case					(			self     , _UpperCAmelCase     , _UpperCAmelCase = None       ):
       if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
       A							:							Union[str, Any]				=    [self.cls_token_id]
       A							:							Any				=    [self.sep_token_id]
       return cls + token_ids_a + sep + sep + token_ids_a + sep


   def        snake_case					(			self     , _UpperCAmelCase     , _UpperCAmelCase = None     , _UpperCAmelCase = False       ):
       if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=_UpperCAmelCase     , token_ids_a=_UpperCAmelCase     , already_has_special_tokens=_UpperCAmelCase       )

       if token_ids_a is None:
           return [1] + ([0] * len(_UpperCAmelCase       )) + [1]
       return [1] + ([0] * len(_UpperCAmelCase       )) + [1, 1] + ([0] * len(_UpperCAmelCase       )) + [1]


   def        snake_case					(			self     , _UpperCAmelCase     , _UpperCAmelCase = None       ):
       A							:							Union[str, Any]				=    [self.sep_token_id]
       A							:							Tuple				=    [self.cls_token_id]

       if token_ids_a is None:
           return len(cls + token_ids_a + sep       ) * [0]
       return len(cls + token_ids_a + sep + sep + token_ids_a + sep       ) * [0]


   def        snake_case					(			self     , _UpperCAmelCase     , _UpperCAmelCase=False     , **_UpperCAmelCase       ):
       A							:							Optional[int]				=    kwargs.pop('''add_prefix_space'''     , self.add_prefix_space       )
       if (is_split_into_words or add_prefix_space) and (len(_UpperCAmelCase       ) > 0 and not text[0].isspace()):
           A							:							Tuple				=    ''' ''' + text
       return (text, kwargs)
