




'''simple docstring'''



import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu





@require_cpu
class      lowerCAmelCase (			unittest.TestCase):


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



            '''simple docstring'''




            __snake_case            =	torch.nn.Linear(10     ,	10	)
            __snake_case            =	torch.optim.SGD(model.parameters()     ,	0.1	)
            __snake_case            =	Accelerator()
            __snake_case            =	accelerator.prepare(__SCREAMING_SNAKE_CASE	)
            try:
                 pickle.loads(pickle.dumps(__SCREAMING_SNAKE_CASE	)	)
            except Exception as e:
                 self.fail(F'''Accelerated optimizer pickling failed with {e}'''	)
            AcceleratorState._reset_state()










import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY






@is_pipeline_test
class      UpperCamelCase(	unittest.TestCase ):
					snake_case_		:					int    					=						MODEL_FOR_MASKED_LM_MAPPING
					snake_case_		:					Optional[int]    					=						TF_MODEL_FOR_MASKED_LM_MAPPING


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Union[str, Any]:




											'''simple docstring'''

											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											if is_torch_available():
																	import torch

																	torch.cuda.empty_cache()


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is grouped", "score": 2.1e-0_5, "token": 3_8_0_1_5, "token_str": " grouped"},
											        {"sequence": "My name is accuser", "score": 2.1e-0_5, "token": 2_5_5_0_6, "token_str": " accuser"},
											    ]  ,     )

											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {
											            "sequence": "The largest city in France is grouped",
											            "score": 2.1e-0_5,
											            "token": 3_8_0_1_5,
											            "token_str": " grouped",
											        },
											        {
											            "sequence": "The largest city in France is accuser",
											            "score": 2.1e-0_5,
											            "token": 2_5_5_0_6,
											            "token_str": " accuser",
											        },
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Patrick", "score": 2e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 1.9e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="pt"    )

											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Maul", "score": 2.2e-0_5, "token": 3_5_6_7_6, "token_str": " Maul"},
											        {"sequence": "My name isELS", "score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS"},
											    ]  ,     )

											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {
											            "sequence": "The largest city in France is Maul",
											            "score": 2.2e-0_5,
											            "token": 3_5_6_7_6,
											            "token_str": " Maul",
											        },
											        {"sequence": "The largest city in France isELS", "score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS"},
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Patrick", "score": 2.1e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 2e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask> <mask>"  ,     top_k=2    )

											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        [
											            {
											                "score": 2.2e-0_5,
											                "token": 3_5_6_7_6,
											                "token_str": " Maul",
											                "sequence": "<s>My name is Maul<mask></s>",
											            },
											            {"score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
											        ],
											        [
											            {
											                "score": 2.2e-0_5,
											                "token": 3_5_6_7_6,
											                "token_str": " Maul",
											                "sequence": "<s>My name is<mask> Maul</s>",
											            },
											            {"score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
											        ],
											    ]  ,     )


					@require_torch_gpu
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline("fill-mask"  ,     model="hf-internal-testing/tiny-random-distilbert"  ,     device=0  ,     framework="pt"    )

											# convert model to fp16
											pipe.model.half()

											__snake_case				=		pipe("Paris is the [MASK] of France."    )
											# We actually don't care about the result, we just want to make sure
											# it works, meaning the float16 tensor got casted back to float32
											# for postprocessing.
											self.assertIsInstance(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )


					@slow
					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="pt"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					@slow
					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is John", "score": 0.008, "token": 6_1_0, "token_str": " John"},
											        {"sequence": "My name is Chris", "score": 0.007, "token": 1_5_7_3, "token_str": " Chris"},
											    ]  ,     )
											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {
											            "sequence": "The largest city in France is Paris",
											            "score": 0.251,
											            "token": 2_2_0_1,
											            "token_str": " Paris",
											        },
											        {
											            "sequence": "The largest city in France is Lyon",
											            "score": 0.214,
											            "token": 1_2_7_9_0,
											            "token_str": " Lyon",
											        },
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is Patrick", "score": 0.005, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Clara", "score": 0.000, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Te", "score": 0.000, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						str:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="pt"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="tf"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		Tuple    )      ->						int:




											'''simple docstring'''

											if tokenizer is None or tokenizer.mask_token_id is None:
																	self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)"    )

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[
											    f'''This is another {tokenizer.mask_token} test''',
											]
											return fill_masker, examples


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		fill_masker.tokenizer
											__snake_case				=		fill_masker.model

											__snake_case				=		fill_masker(
											    f'''This is a {tokenizer.mask_token}'''  ,     )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

											__snake_case				=		fill_masker([f'''This is a {tokenizer.mask_token}''']    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

											__snake_case				=		fill_masker([f'''This is a {tokenizer.mask_token}''', f'''Another {tokenizer.mask_token} great test.''']    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											    ]  ,     )

											with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																	fill_masker([None]    )
											# No mask_token is not supported
											with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																	fill_masker("This is"    )

											self.run_test_top_k(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											self.run_test_targets(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											self.run_test_top_k_targets(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											self.fill_mask_with_duplicate_targets_and_top_k(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											self.fill_mask_with_multiple_masks(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]    )      ->						Any:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		sorted(vocab.keys()    )[:2]
											# Pipeline argument
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     targets=SCREAMING_SNAKE_CASE    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )
											__snake_case				=		{vocab[el] for el in targets}
											self.assertEqual({el["token"] for el in outputs}  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		[tokenizer.decode([x]    ) for x in target_ids]
											self.assertEqual({el["token_str"] for el in outputs}  ,     set(SCREAMING_SNAKE_CASE    )    )

											# Call argument
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )
											__snake_case				=		{vocab[el] for el in targets}
											self.assertEqual({el["token"] for el in outputs}  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		[tokenizer.decode([x]    ) for x in target_ids]
											self.assertEqual({el["token_str"] for el in outputs}  ,     set(SCREAMING_SNAKE_CASE    )    )

											# Score equivalence
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[top_mask["token_str"] for top_mask in outputs]
											__snake_case				=		[top_mask["score"] for top_mask in outputs]

											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(SCREAMING_SNAKE_CASE    ) == set(SCREAMING_SNAKE_CASE    ):
																	__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		[top_mask["score"] for top_mask in unmasked_targets]
																	self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE    )  ,     nested_simplify(SCREAMING_SNAKE_CASE    )    )

											# Raises with invalid
											with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																	__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=[]    )
											# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
											if "" not in tokenizer.get_vocab():
																	with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=[""]    )
																	with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=""    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     top_k=2    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     top_k=2    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE    )  ,     nested_simplify(SCREAMING_SNAKE_CASE    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		List[Any]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

											# top_k=2, ntargets=3
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     top_k=2  ,     targets=SCREAMING_SNAKE_CASE    )

											# If we use the most probably targets, and filter differently, we should still
											# have the same results
											__snake_case				=		[el["token_str"] for el in sorted(SCREAMING_SNAKE_CASE  ,     key=lambda SCREAMING_SNAKE_CASE    : x["score"]  ,     reverse=SCREAMING_SNAKE_CASE    )]
											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(SCREAMING_SNAKE_CASE    ).issubset(SCREAMING_SNAKE_CASE    ):
																	__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     top_k=3  ,     targets=SCREAMING_SNAKE_CASE    )
																	# They should yield exactly the same result
																	self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE    )  ,     nested_simplify(SCREAMING_SNAKE_CASE    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Dict    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer.get_vocab()
											# String duplicates + id duplicates
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__snake_case				=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
											__snake_case				=		fill_masker(f'''My name is {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE  ,     top_k=1_0    )

											# The target list contains duplicates, so we can't output more
											# than them
											self.assertEqual(len(SCREAMING_SNAKE_CASE    )  ,     3    )






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

											__snake_case				=		fill_masker(
											    f'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''  ,     top_k=2    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											    ]  ,     )





