


import datasets

from .evaluate import evaluate


_snake_case  :	List[Any]			      =       "\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n"

_snake_case  :	Optional[Any]			      =       "\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n"

_snake_case  :	List[Any]			      =       "\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair as given in the references (see below)\n        - 'prediction_text': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair (see above),\n        - 'answers': a Dict in the SQuAD dataset format\n            {\n                'text': list of possible texts for the answer, as a list of strings\n                'answer_start': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    'exact_match': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]\n    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]\n    >>> squad_metric = datasets.load_metric(\"squad\")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0}\n"

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




							"""simple docstring"""


							def 					__snake_case      (							self :						Union[str, Any]       )			->					Optional[int]:
														return datasets.MetricInfo(
														    description=_DESCRIPTION					,			citation=_CITATION					,			inputs_description=_KWARGS_DESCRIPTION					,			features=datasets.Features(
														        {
														            "predictions": {"id": datasets.Value("string"       ), "prediction_text": datasets.Value("string"       )},
														            "references": {
														                "id": datasets.Value("string"       ),
														                "answers": datasets.features.Sequence(
														                    {
														                        "text": datasets.Value("string"       ),
														                        "answer_start": datasets.Value("int32"       ),
														                    }       ),
														            },
														        }       )					,			codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]					,			reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]					,			)






							def 					__snake_case      (							self :						Optional[Any]					,			lowerCamelCase :						int					,			lowerCamelCase :						Tuple       )			->					Optional[int]:
														__snake_case	:    Optional[Any]											=     {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
														__snake_case	:    Optional[int]											=     [
														    {
														        "paragraphs": [
														            {
														                "qas": [
														                    {
														                        "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
														                        "id": ref["id"],
														                    }
														                    for ref in references
														                ]
														            }
														        ]
														    }
														]
														__snake_case	:    List[Any]											=     evaluate(dataset=lowerCamelCase					,			predictions=lowerCamelCase       )
														return score





import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case  :	Optional[int]			      =       "▁"

_snake_case  :	Tuple			      =       get_tests_dir("fixtures/test_sentencepiece.model")

@require_sentencepiece
class        a	(_lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Optional[Any]  						=						BertGenerationTokenizer
							__UpperCAmelCase					:							List[Any]  						=						False
							__UpperCAmelCase					:							List[Any]  						=						True

							def 					__snake_case      (							self :						Optional[int]       )			->					Optional[int]:
														super().setUp()

														__snake_case	:    Tuple											=     BertGenerationTokenizer(lowerCamelCase					,			keep_accents=lowerCamelCase       )
														tokenizer.save_pretrained(self.tmpdirname       )

							def 					__snake_case      (							self :						Dict       )			->					int:
														__snake_case	:    str											=     "<s>"
														__snake_case	:    Any											=     1

														self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase       )					,			lowerCamelCase       )
														self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase       )					,			lowerCamelCase       )

							def 					__snake_case      (							self :						str       )			->					Optional[Any]:
														__snake_case	:    int											=     list(self.get_tokenizer().get_vocab().keys()       )

														self.assertEqual(vocab_keys[0]					,			"<unk>"       )
														self.assertEqual(vocab_keys[1]					,			"<s>"       )
														self.assertEqual(vocab_keys[-1]					,			"<pad>"       )
														self.assertEqual(len(lowerCamelCase       )					,			1002       )

							def 					__snake_case      (							self :						List[str]       )			->					Optional[int]:
														self.assertEqual(self.get_tokenizer().vocab_size					,			1000       )

							def 					__snake_case      (							self :						List[str]       )			->					Union[str, Any]:
														__snake_case	:    List[Any]											=     BertGenerationTokenizer(lowerCamelCase					,			keep_accents=lowerCamelCase       )

														__snake_case	:    int											=     tokenizer.tokenize("This is a test"       )
														self.assertListEqual(lowerCamelCase					,			["▁This", "▁is", "▁a", "▁t", "est"]       )

														self.assertListEqual(
														    tokenizer.convert_tokens_to_ids(lowerCamelCase       )					,			[285, 46, 10, 170, 382]					,			)

														__snake_case	:    str											=     tokenizer.tokenize("I was born in 92000, and this is falsé."       )
														self.assertListEqual(
														    lowerCamelCase					,			[
														        SPIECE_UNDERLINE + "I",
														        SPIECE_UNDERLINE + "was",
														        SPIECE_UNDERLINE + "b",
														        "or",
														        "n",
														        SPIECE_UNDERLINE + "in",
														        SPIECE_UNDERLINE + "",
														        "9",
														        "2",
														        "0",
														        "0",
														        "0",
														        ",",
														        SPIECE_UNDERLINE + "and",
														        SPIECE_UNDERLINE + "this",
														        SPIECE_UNDERLINE + "is",
														        SPIECE_UNDERLINE + "f",
														        "al",
														        "s",
														        "é",
														        ".",
														    ]					,			)
														__snake_case	:    Any											=     tokenizer.convert_tokens_to_ids(lowerCamelCase       )
														self.assertListEqual(
														    lowerCamelCase					,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]					,			)

														__snake_case	:    Optional[Any]											=     tokenizer.convert_ids_to_tokens(lowerCamelCase       )
														self.assertListEqual(
														    lowerCamelCase					,			[
														        SPIECE_UNDERLINE + "I",
														        SPIECE_UNDERLINE + "was",
														        SPIECE_UNDERLINE + "b",
														        "or",
														        "n",
														        SPIECE_UNDERLINE + "in",
														        SPIECE_UNDERLINE + "",
														        "<unk>",
														        "2",
														        "0",
														        "0",
														        "0",
														        ",",
														        SPIECE_UNDERLINE + "and",
														        SPIECE_UNDERLINE + "this",
														        SPIECE_UNDERLINE + "is",
														        SPIECE_UNDERLINE + "f",
														        "al",
														        "s",
														        "<unk>",
														        ".",
														    ]					,			)

							@cached_property
							def 					__snake_case      (							self :						str       )			->					List[Any]:
														return BertGenerationTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"       )

							@slow
							def 					__snake_case      (							self :						Tuple       )			->					Union[str, Any]:
														__snake_case	:    Union[str, Any]											=     "Hello World!"
														__snake_case	:    List[str]											=     [18536, 2260, 101]

														self.assertListEqual(lowerCamelCase					,			self.big_tokenizer.encode(lowerCamelCase       )       )

							@slow
							def 					__snake_case      (							self :						str       )			->					Optional[int]:
														__snake_case	:    List[Any]											=     (
														    "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"
														    " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"
														)
														__snake_case	:    Any											=     [
														    871,
														    419,
														    358,
														    946,
														    991,
														    2521,
														    452,
														    358,
														    1357,
														    387,
														    7751,
														    3536,
														    112,
														    985,
														    456,
														    126,
														    865,
														    938,
														    5400,
														    5734,
														    458,
														    1368,
														    467,
														    786,
														    2462,
														    5246,
														    1159,
														    633,
														    865,
														    4519,
														    457,
														    582,
														    852,
														    2557,
														    427,
														    916,
														    508,
														    405,
														    34324,
														    497,
														    391,
														    408,
														    11342,
														    1244,
														    385,
														    100,
														    938,
														    985,
														    456,
														    574,
														    362,
														    12597,
														    3200,
														    3129,
														    1172,
														]

														self.assertListEqual(lowerCamelCase					,			self.big_tokenizer.encode(lowerCamelCase       )       )

							@require_torch
							@slow
							def 					__snake_case      (							self :						Optional[Any]       )			->					str:
														import torch

														from transformers import BertGenerationConfig, BertGenerationEncoder

														# Build sequence
														__snake_case	:    List[Any]											=     list(self.big_tokenizer.get_vocab().keys()       )[:10]
														__snake_case	:    Union[str, Any]											=     " ".join(lowerCamelCase       )
														__snake_case	:    Optional[int]											=     self.big_tokenizer.encode_plus(lowerCamelCase					,			return_tensors="pt"					,			return_token_type_ids=lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     self.big_tokenizer.batch_encode_plus(
														    [sequence + " " + sequence]					,			return_tensors="pt"					,			return_token_type_ids=lowerCamelCase       )

														__snake_case	:    List[Any]											=     BertGenerationConfig()
														__snake_case	:    Dict											=     BertGenerationEncoder(lowerCamelCase       )

														assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

														with torch.no_grad():
																					model(**lowerCamelCase       )
																					model(**lowerCamelCase       )






							@slow
							def 					__snake_case      (							self :						List[Any]       )			->					List[Any]:
														# fmt: off
														__snake_case	:    Optional[Any]											=     {"input_ids": [[39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114], [448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
														# fmt: on

														self.tokenizer_integration_test_util(
														    expected_encoding=lowerCamelCase					,			model_name="google/bert_for_seq_generation_L-24_bbc_encoder"					,			revision="c817d1fd1be2ffa69431227a1fe320544943d4db"					,			)

