






from sklearn.metrics import recall_score

import datasets


lowerCamelCase : Optional[Any]						   =       '''
Recall is the fraction of the positive examples that were correctly labeled by the model as positive. It can be computed with the equation:
Recall = TP / (TP + FN)
Where TP is the true positives and FN is the false negatives.
'''


lowerCamelCase : Tuple						   =       '''
Args:
- **predictions** (`list` of `int`): The predicted labels.
- **references** (`list` of `int`): The ground truth labels.
- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `binary`, and their order when average is `None`. Labels present in the data can be excluded in this input, for example to calculate a multiclass average ignoring a majority negative class, while 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 y_true and y_pred are used in sorted order. Defaults to None.
- **pos_label** (`int`): The class label to use as the \'positive class\' when calculating the recall. Defaults to `1`.
- **average** (`string`): This parameter is required for multiclass/multilabel targets. If 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 target labels and predictions 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. Note that it 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** (): Sets the value to return when there is a zero division. Defaults to .
    - `\'warn\'`: If there is a zero division, the return value is `0`, but warnings are also raised.
    - `0`: If there is a zero division, the return value is `0`.
    - `1`: If there is a zero division, the return value is `1`.

Returns:
- **recall** (`float`, or `array` of `float`): Either the general recall score, or the recall scores for individual classes, depending on the values input to `labels` and `average`. Minimum possible value is 0. Maximum possible value is 1. A higher recall means that more of the positive examples have been labeled correctly. Therefore, a higher recall is generally considered better.

Examples:

    Example 1-A simple example with some errors
        >>> recall_metric = datasets.load_metric(\'recall\')
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1])
        >>> print(results)
        {\'recall\': 0.6666666666666666}

    Example 2-The same example as Example 1, but with `pos_label=0` instead of the default `pos_label=1`.
        >>> recall_metric = datasets.load_metric(\'recall\')
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], pos_label=0)
        >>> print(results)
        {\'recall\': 0.5}

    Example 3-The same example as Example 1, but with `sample_weight` included.
        >>> recall_metric = datasets.load_metric(\'recall\')
        >>> sample_weight = [0.9, 0.2, 0.9, 0.3, 0.8]
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], sample_weight=sample_weight)
        >>> print(results)
        {\'recall\': 0.55}

    Example 4-A multiclass example, using different averages.
        >>> recall_metric = datasets.load_metric(\'recall\')
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = recall_metric.compute(predictions=predictions, references=references, average=\'macro\')
        >>> print(results)
        {\'recall\': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average=\'micro\')
        >>> print(results)
        {\'recall\': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average=\'weighted\')
        >>> print(results)
        {\'recall\': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {\'recall\': array([1., 0., 0.])}
'''


lowerCamelCase : Dict						   =       '''
@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       lowerCAmelCase				(  self				:	Optional[int]							)			->  Optional[int]:


												"""simple docstring"""

												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.recall_score.html"""]		,     )



					def       lowerCAmelCase				(  self				:	List[Any]		,     __a				:	Optional[int]		,     __a				:	int		,     __a				:	Dict=None		,     __a				:	List[Any]=1		,     __a				:	Optional[Any]="binary"		,     __a				:	Optional[int]=None		,     __a				:	List[Any]="warn"		,     )			->  Union[str, Any]:


												"""simple docstring"""

												__lowercase      :							str				=     recall_score(
												    __a		,     __a		,     labels=__a		,     pos_label=__a		,     average=__a		,     sample_weight=__a		,     zero_division=__a		,     )
												return {"recall": float(__a							) if score.size == 1 else score}







import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 		lowerCAmelCase     ( __a      ,       unittest.TestCase			):

					'''simple docstring'''

					_A						:			str									=      LongformerTokenizer
					_A						:			int									=      True
					_A						:			Optional[int]									=      LongformerTokenizerFast
					_A						:			int									=      True



					def       lowerCAmelCase				(  self				:	Any							)			->  List[str]:


												"""simple docstring"""

												super().setUp()

												# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
												__lowercase      :							Union[str, Any]				=     [
												    """l""",
												    """o""",
												    """w""",
												    """e""",
												    """r""",
												    """s""",
												    """t""",
												    """i""",
												    """d""",
												    """n""",
												    """\u0120""",
												    """\u0120l""",
												    """\u0120n""",
												    """\u0120lo""",
												    """\u0120low""",
												    """er""",
												    """\u0120lowest""",
												    """\u0120newer""",
												    """\u0120wider""",
												    """<unk>""",
												]
												__lowercase      :							Union[str, Any]				=     dict(zip(__a		,     range(len(__a							)							)							)							)
												__lowercase      :							Any				=     ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
												__lowercase      :							Optional[int]				=     {"""unk_token""": """<unk>"""}

												__lowercase      :							Dict				=     os.path.join(self.tmpdirname		,     VOCAB_FILES_NAMES["""vocab_file"""]							)
												__lowercase      :							str				=     os.path.join(self.tmpdirname		,     VOCAB_FILES_NAMES["""merges_file"""]							)
												with open(self.vocab_file		,     """w"""		,     encoding="""utf-8"""							) as fp:
																			fp.write(json.dumps(__a							) + """\n"""							)
												with open(self.merges_file		,     """w"""		,     encoding="""utf-8"""							) as fp:
																			fp.write("""\n""".join(__a							)							)



					def       lowerCAmelCase				(  self				:	Optional[int]		,     **__a				:	Optional[Any]							)			->  str:


												"""simple docstring"""

												kwargs.update(self.special_tokens_map							)
												return self.tokenizer_class.from_pretrained(self.tmpdirname		,     **__a							)



					def       lowerCAmelCase				(  self				:	Tuple		,     **__a				:	Tuple							)			->  str:


												"""simple docstring"""

												kwargs.update(self.special_tokens_map							)
												return self.rust_tokenizer_class.from_pretrained(self.tmpdirname		,     **__a							)



					def       lowerCAmelCase				(  self				:	str		,     __a				:	Optional[int]							)			->  Union[str, Any]:


												"""simple docstring"""

												__lowercase      :							Union[str, Any]				=     """lower newer"""
												__lowercase      :							int				=     """lower newer"""
												return input_text, output_text



					def       lowerCAmelCase				(  self				:	List[Any]							)			->  Optional[int]:


												"""simple docstring"""

												__lowercase      :							Union[str, Any]				=     self.tokenizer_class(self.vocab_file		,     self.merges_file		,     **self.special_tokens_map							)
												__lowercase      :							Dict				=     """lower newer"""
												__lowercase      :							Optional[Any]				=     ["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
												__lowercase      :							str				=     tokenizer.tokenize(__a							)  # , add_prefix_space=True)
												self.assertListEqual(__a		,     __a							)

												__lowercase      :							int				=     tokens + [tokenizer.unk_token]
												__lowercase      :							str				=     [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
												self.assertListEqual(tokenizer.convert_tokens_to_ids(__a							)		,     __a							)



					def       lowerCAmelCase				(  self				:	Optional[Any]							)			->  List[Any]:


												"""simple docstring"""

												__lowercase      :							Optional[Any]				=     self.get_tokenizer()

												self.assertListEqual(tokenizer.encode("""Hello world!"""		,     add_special_tokens=__a							)		,     [0, 31414, 232, 328, 2]							)
												self.assertListEqual(
												    tokenizer.encode("""Hello world! cécé herlolip 418"""		,     add_special_tokens=__a							)		,     [0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]		,     )



					@slow
					def       lowerCAmelCase				(  self				:	Tuple							)			->  str:


												"""simple docstring"""

												__lowercase      :							Any				=     self.tokenizer_class.from_pretrained("""allenai/longformer-base-4096"""							)

												__lowercase      :							Optional[Any]				=     tokenizer.encode("""sequence builders"""		,     add_special_tokens=__a							)
												__lowercase      :							List[str]				=     tokenizer.encode("""multi-sequence build"""		,     add_special_tokens=__a							)

												__lowercase      :							Optional[Any]				=     tokenizer.encode(
												    """sequence builders"""		,     add_special_tokens=__a		,     add_prefix_space=__a							)
												__lowercase      :							Union[str, Any]				=     tokenizer.encode(
												    """sequence builders"""		,     """multi-sequence build"""		,     add_special_tokens=__a		,     add_prefix_space=__a							)

												__lowercase      :							List[Any]				=     tokenizer.build_inputs_with_special_tokens(__a							)
												__lowercase      :							Any				=     tokenizer.build_inputs_with_special_tokens(__a		,     __a							)

												assert encoded_sentence == encoded_text_from_decode
												assert encoded_pair == encoded_pair_from_decode



					def       lowerCAmelCase				(  self				:	Dict							)			->  Tuple:


												"""simple docstring"""

												__lowercase      :							Optional[Any]				=     self.get_tokenizer()

												__lowercase      :							Tuple				=     """Encode this sequence."""
												__lowercase      :							Optional[Any]				=     tokenizer.byte_encoder[""" """.encode("""utf-8"""							)[0]]

												# Testing encoder arguments
												__lowercase      :							Dict				=     tokenizer.encode(__a		,     add_special_tokens=__a		,     add_prefix_space=__a							)
												__lowercase      :							Tuple				=     tokenizer.convert_ids_to_tokens(encoded[0]							)[0]
												self.assertNotEqual(__a		,     __a							)

												__lowercase      :							List[str]				=     tokenizer.encode(__a		,     add_special_tokens=__a		,     add_prefix_space=__a							)
												__lowercase      :							Any				=     tokenizer.convert_ids_to_tokens(encoded[0]							)[0]
												self.assertEqual(__a		,     __a							)

												tokenizer.add_special_tokens({"""bos_token""": """<s>"""}							)
												__lowercase      :							str				=     tokenizer.encode(__a		,     add_special_tokens=__a							)
												__lowercase      :							Dict				=     tokenizer.convert_ids_to_tokens(encoded[1]							)[0]
												self.assertNotEqual(__a		,     __a							)

												# Testing spaces after special tokens
												__lowercase      :							List[Any]				=     """<mask>"""
												tokenizer.add_special_tokens(
												    {"""mask_token""": AddedToken(__a		,     lstrip=__a		,     rstrip=__a							)}							)  # mask token has a left space
												__lowercase      :							Dict				=     tokenizer.convert_tokens_to_ids(__a							)

												__lowercase      :							List[str]				=     """Encode <mask> sequence"""
												__lowercase      :							List[str]				=     """Encode <mask>sequence"""

												__lowercase      :							Union[str, Any]				=     tokenizer.encode(__a							)
												__lowercase      :							Dict				=     encoded.index(__a							)
												__lowercase      :							List[Any]				=     tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]							)[0]
												self.assertEqual(__a		,     __a							)

												__lowercase      :							int				=     tokenizer.encode(__a							)
												__lowercase      :							Union[str, Any]				=     encoded.index(__a							)
												__lowercase      :							List[Any]				=     tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]							)[0]
												self.assertNotEqual(__a		,     __a							)



					def       lowerCAmelCase				(  self				:	int							)			->  str:


												"""simple docstring"""

												pass



					def       lowerCAmelCase				(  self				:	int							)			->  Dict:


												"""simple docstring"""

												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
																										__lowercase      :							List[str]				=     self.rust_tokenizer_class.from_pretrained(__a		,     **__a							)
																										__lowercase      :							List[Any]				=     self.tokenizer_class.from_pretrained(__a		,     **__a							)
																										__lowercase      :							Optional[Any]				=     """A, <mask> AllenNLP sentence."""
																										__lowercase      :							Union[str, Any]				=     tokenizer_r.encode_plus(__a		,     add_special_tokens=__a		,     return_token_type_ids=__a							)
																										__lowercase      :							Optional[Any]				=     tokenizer_p.encode_plus(__a		,     add_special_tokens=__a		,     return_token_type_ids=__a							)

																										# token_type_ids should put 0 everywhere
																										self.assertEqual(sum(tokens_r["""token_type_ids"""]							)		,     sum(tokens_p["""token_type_ids"""]							)							)

																										# attention_mask should put 1 everywhere, so sum over length should be 1
																										self.assertEqual(
																										    sum(tokens_r["""attention_mask"""]							) / len(tokens_r["""attention_mask"""]							)		,     sum(tokens_p["""attention_mask"""]							) / len(tokens_p["""attention_mask"""]							)		,     )

																										__lowercase      :							Dict				=     tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]							)
																										__lowercase      :							str				=     tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]							)

																										# Rust correctly handles the space before the mask while python doesnt
																										self.assertSequenceEqual(tokens_p["""input_ids"""]		,     [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]							)
																										self.assertSequenceEqual(tokens_r["""input_ids"""]		,     [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]							)

																										self.assertSequenceEqual(
																										    __a		,     ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]							)
																										self.assertSequenceEqual(
																										    __a		,     ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]							)



					def       lowerCAmelCase				(  self				:	List[Any]							)			->  Dict:


												"""simple docstring"""

												for trim_offsets, add_prefix_space in itertools.product([True, False]		,     repeat=2							):
																			__lowercase      :							Dict				=     self.rust_tokenizer_class.from_pretrained(
																			    self.tmpdirname		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)

																			__lowercase      :							Optional[int]				=     json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()							)
																			__lowercase      :							Any				=     json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()							)

																			self.assertEqual(pre_tokenizer_state["""add_prefix_space"""]		,     __a							)

																			self.assertEqual(post_processor_state["""add_prefix_space"""]		,     __a							)
																			self.assertEqual(post_processor_state["""trim_offsets"""]		,     __a							)



					def       lowerCAmelCase				(  self				:	int							)			->  Tuple:


												"""simple docstring"""

												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
																										__lowercase      :							List[str]				=     """hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
																										__lowercase      :							int				=     F"{text_of_1_token} {text_of_1_token}"

																										__lowercase      :							List[str]				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							Any				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (len(__a							) + 1, len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							str				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							Tuple				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (len(__a							) + 1, len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							Optional[int]				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							str				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (len(__a							), len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							str				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							int				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (len(__a							), len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							Any				=     F" {text}"

																										# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
																										#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
																										# )
																										# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
																										# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
																										# self.assertEqual(
																										#     encoding.offset_mapping[1],
																										#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
																										# )

																										__lowercase      :							Optional[Any]				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							str				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (1, 1 + len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (1 + len(__a							) + 1, 1 + len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							int				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							Dict				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, 1 + len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (1 + len(__a							), 1 + len(__a							) + 1 + len(__a							))		,     )

																										__lowercase      :							int				=     self.rust_tokenizer_class.from_pretrained(
																										    __a		,     use_fast=__a		,     add_prefix_space=__a		,     trim_offsets=__a							)
																										__lowercase      :							Tuple				=     tokenizer_r(__a		,     return_offsets_mapping=__a		,     add_special_tokens=__a							)
																										self.assertEqual(encoding.offset_mapping[0]		,     (0, 1 + len(__a							))							)
																										self.assertEqual(
																										    encoding.offset_mapping[1]		,     (1 + len(__a							), 1 + len(__a							) + 1 + len(__a							))		,     )