


'''simple docstring'''
from sklearn.metrics import precision_score

import datasets


__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		'''
Precision is the fraction of correctly labeled positive examples out of all of the examples that were labeled as positive. It is computed via the equation:
Precision = TP / (TP + FP)
where TP is the True positives (i.e. the examples correctly labeled as positive) and FP is the False positive examples (i.e. the examples incorrectly labeled as positive).
'''


__SCREAMING_SNAKE_CASE				:							Any		       =		'''
Args:
    predictions (`list` of `int`): Predicted class labels.
    references (`list` of `int`): Actual class labels.
    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`. If `average` is `None`, it should be the label order. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.

        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.
        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
    sample_weight (`list` of `float`): Sample weights Defaults to None.
    zero_division (`int` or `string`): Sets the value to return when there is a zero division. Defaults to \'warn\'.

        - 0: Returns 0 when there is a zero division.
        - 1: Returns 1 when there is a zero division.
        - \'warn\': Raises warnings and then returns 0 when there is a zero division.

Returns:
    precision (`float` or `array` of `float`): Precision score or list of precision scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate that fewer negative examples were incorrectly labeled as positive, which means that, generally, higher scores are better.

Examples:

    Example 1-A simple binary example
        >>> precision_metric = datasets.load_metric("precision")
        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
        >>> print(results)
        {\'precision\': 0.5}

    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
        >>> precision_metric = datasets.load_metric("precision")
        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
        >>> print(round(results[\'precision\'], 2))
        0.67

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> precision_metric = datasets.load_metric("precision")
        >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
        >>> print(results)
        {\'precision\': 0.23529411764705882}

    Example 4-A multiclass example, with different values for the `average` input.
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'macro\')
        >>> print(results)
        {\'precision\': 0.2222222222222222}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'micro\')
        >>> print(results)
        {\'precision\': 0.3333333333333333}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'weighted\')
        >>> print(results)
        {\'precision\': 0.2222222222222222}
        >>> results = precision_metric.compute(predictions=predictions, references=references, average=None)
        >>> print([round(res, 2) for res in results[\'precision\']])
        [0.67, 0.0, 0.0]
'''


__SCREAMING_SNAKE_CASE				:							Tuple		       =		'''
@article{scikit-learn,
    title={Scikit-learn: Machine Learning in {P}ython},
    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
    and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
    and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
    Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
    journal={Journal of Machine Learning Research},
    volume={12},
    pages={2825--2830},
    year={2011}
}
'''






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							, _KWARGS_DESCRIPTION	)
class 				__lowerCAmelCase      (      datasets.Metric	):

						"""simple docstring"""






						def 							_UpperCAmelCase					(     self       :			str  ):
													return datasets.MetricInfo(
													    description=_DESCRIPTION   ,     citation=_CITATION   ,     inputs_description=_KWARGS_DESCRIPTION   ,     features=datasets.Features(
													        {
													            "predictions": datasets.Sequence(datasets.Value("int32"  )  ),
													            "references": datasets.Sequence(datasets.Value("int32"  )  ),
													        }
													        if self.config_name == "multilabel"
													        else {
													            "predictions": datasets.Value("int32"  ),
													            "references": datasets.Value("int32"  ),
													        }  )   ,     reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html"]   ,     )






						def 							_UpperCAmelCase					(     self       :			List[Any]   ,     lowerCAmelCase       :			str   ,     lowerCAmelCase       :			Union[str, Any]   ,     lowerCAmelCase       :			int=None   ,     lowerCAmelCase       :			Optional[int]=1   ,     lowerCAmelCase       :			List[str]="binary"   ,     lowerCAmelCase       :			str=None   ,     lowerCAmelCase       :			str="warn"   ,     ):
													A_ 						=		precision_score(
													    lowerCAmelCase   ,     lowerCAmelCase   ,     labels=lowerCAmelCase   ,     pos_label=lowerCAmelCase   ,     average=lowerCAmelCase   ,     sample_weight=lowerCAmelCase   ,     zero_division=lowerCAmelCase   ,     )
													return {"precision": float(lowerCAmelCase  ) if score.size == 1 else score}









'''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


__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE				:							List[str]		       =		{
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
}

__SCREAMING_SNAKE_CASE				:							int		       =		{
    '''vocab_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/vocab.json''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/vocab.json''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/vocab.json''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/merges.txt''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/merges.txt''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/merges.txt''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt'''
        ),
    },
}

__SCREAMING_SNAKE_CASE				:							int		       =		{
    '''roberta-base''': 512,
    '''roberta-large''': 512,
    '''roberta-large-mnli''': 512,
    '''distilroberta-base''': 512,
    '''roberta-base-openai-detector''': 512,
    '''roberta-large-openai-detector''': 512,
}







@lru_cache()
def 			a_							(  ):
							A_ 						=		(
							    list(range(ord("!"   )	,     ord("~"   ) + 1   )   ) + list(range(ord("¡"   )	,     ord("¬"   ) + 1   )   ) + list(range(ord("®"   )	,     ord("ÿ"   ) + 1   )   )
							)
							A_ 						=		bs[:]
							A_ 						=		0
							for b in range(2**8   ):
														if b not in bs:
																					bs.append(UpperCamelCase_   )
																					cs.append(2**8 + n   )
																					n += 1
							A_ 						=		[chr(UpperCamelCase_   ) for n in cs]
							return dict(zip(UpperCamelCase_	,     UpperCamelCase_   )   )







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		set()
							A_ 						=		word[0]
							for char in word[1:]:
														pairs.add((prev_char, char)   )
														A_ 						=		char
							return pairs







class 				__lowerCAmelCase      (      lowercase	):

						"""simple docstring"""






						_UpperCAmelCase		:					List[str]      	=VOCAB_FILES_NAMES
						_UpperCAmelCase		:					Optional[Any]      	=PRETRAINED_VOCAB_FILES_MAP
						_UpperCAmelCase		:					List[Any]      	=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						_UpperCAmelCase		:					Optional[Any]      	=["input_ids", "attention_mask"]






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

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

													super().__init__(
													    errors=lowerCAmelCase   ,     bos_token=lowerCAmelCase   ,     eos_token=lowerCAmelCase   ,     unk_token=lowerCAmelCase   ,     sep_token=lowerCAmelCase   ,     cls_token=lowerCAmelCase   ,     pad_token=lowerCAmelCase   ,     mask_token=lowerCAmelCase   ,     add_prefix_space=lowerCAmelCase   ,     **lowerCAmelCase   ,     )

													with open(lowerCAmelCase   ,     encoding="utf-8"  ) as vocab_handle:
																				A_ 						=		json.load(lowerCAmelCase  )
													A_ 						=		{v: k for k, v in self.encoder.items()}
													A_ 						=		errors  # how to handle errors in decoding
													A_ 						=		bytes_to_unicode()
													A_ 						=		{v: k for k, v in self.byte_encoder.items()}
													with open(lowerCAmelCase   ,     encoding="utf-8"  ) as merges_handle:
																				A_ 						=		merges_handle.read().split("\n"  )[1:-1]
													A_ 						=		[tuple(merge.split()  ) for merge in bpe_merges]
													A_ 						=		dict(zip(lowerCAmelCase   ,     range(len(lowerCAmelCase  )  )  )  )
													A_ 						=		{}
													A_ 						=		add_prefix_space

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






						@property
						def 							_UpperCAmelCase					(     self       :			Optional[int]  ):
													return len(self.encoder  )






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													return dict(self.encoder   ,     **self.added_tokens_encoder  )






						def 							_UpperCAmelCase					(     self       :			Optional[int]   ,     lowerCAmelCase       :			List[Any]  ):
													if token in self.cache:
																				return self.cache[token]
													A_ 						=		tuple(lowerCAmelCase  )
													A_ 						=		get_pairs(lowerCAmelCase  )

													if not pairs:
																				return token

													while True:
																				A_ 						=		min(lowerCAmelCase   ,     key=lambda lowerCAmelCase  : self.bpe_ranks.get(lowerCAmelCase   ,     float("inf"  )  )  )
																				if bigram not in self.bpe_ranks:
																											break
																				A_						,				A_ 						=		bigram
																				A_ 						=		[]
																				A_ 						=		0
																				while i < len(lowerCAmelCase  ):
																											try:
																																		A_ 						=		word.index(lowerCAmelCase   ,     lowerCAmelCase  )
																											except ValueError:
																																		new_word.extend(word[i:]  )
																																		break
																											else:
																																		new_word.extend(word[i:j]  )
																																		A_ 						=		j

																											if word[i] == first and i < len(lowerCAmelCase  ) - 1 and word[i + 1] == second:
																																		new_word.append(first + second  )
																																		i += 2
																											else:
																																		new_word.append(word[i]  )
																																		i += 1
																				A_ 						=		tuple(lowerCAmelCase  )
																				A_ 						=		new_word
																				if len(lowerCAmelCase  ) == 1:
																											break
																				else:
																											A_ 						=		get_pairs(lowerCAmelCase  )
													A_ 						=		" ".join(lowerCAmelCase  )
													A_ 						=		word
													return word






						def 							_UpperCAmelCase					(     self       :			Optional[int]   ,     lowerCAmelCase       :			int  ):
													A_ 						=		[]
													for token in re.findall(self.pat   ,     lowerCAmelCase  ):
																				A_ 						=		"".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(lowerCAmelCase  ).split(" "  )  )
													return bpe_tokens






						def 							_UpperCAmelCase					(     self       :			str   ,     lowerCAmelCase       :			List[str]  ):
													return self.encoder.get(lowerCAmelCase   ,     self.encoder.get(self.unk_token  )  )






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			Union[str, Any]  ):
													return self.decoder.get(lowerCAmelCase  )






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			Tuple  ):
													A_ 						=		"".join(lowerCAmelCase  )
													A_ 						=		bytearray([self.byte_decoder[c] for c in text]  ).decode("utf-8"   ,     errors=self.errors  )
													return text






						def 							_UpperCAmelCase					(     self       :			Dict   ,     lowerCAmelCase       :			str   ,     lowerCAmelCase       :			Optional[str] = None  ):
													if not os.path.isdir(lowerCAmelCase  ):
																				logger.error(F"Vocabulary path ({save_directory}) should be a directory"  )
																				return
													A_ 						=		os.path.join(
													    lowerCAmelCase   ,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]  )
													A_ 						=		os.path.join(
													    lowerCAmelCase   ,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]  )

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

													A_ 						=		0
													with open(lowerCAmelCase   ,     "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 lowerCAmelCase  : 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_ 						=		token_index
																											writer.write(" ".join(lowerCAmelCase  ) + "\n"  )
																											index += 1

													return vocab_file, merge_file






						def 							_UpperCAmelCase					(     self       :			Union[str, Any]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None  ):
													if token_ids_a is None:
																				return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
													A_ 						=		[self.cls_token_id]
													A_ 						=		[self.sep_token_id]
													return cls + token_ids_a + sep + sep + token_ids_a + sep






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None   ,     lowerCAmelCase       :			bool = False  ):
													if already_has_special_tokens:
																				return super().get_special_tokens_mask(
																				    token_ids_a=lowerCAmelCase   ,     token_ids_a=lowerCAmelCase   ,     already_has_special_tokens=lowerCAmelCase  )

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






						def 							_UpperCAmelCase					(     self       :			Optional[Any]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None  ):
													A_ 						=		[self.sep_token_id]
													A_ 						=		[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 							_UpperCAmelCase					(     self       :			Tuple   ,     lowerCAmelCase       :			List[Any]   ,     lowerCAmelCase       :			str=False   ,     **lowerCAmelCase       :			Optional[Any]  ):
													A_ 						=		kwargs.pop("add_prefix_space"   ,     self.add_prefix_space  )
													if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase  ) > 0 and not text[0].isspace()):
																				A_ 						=		" " + text
													return (text, kwargs)





