




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     _A   (    unittest.TestCase							):
  SCREAMING_SNAKE_CASE_	:	Tuple						=MODEL_FOR_MASKED_LM_MAPPING
  SCREAMING_SNAKE_CASE_	:	int						=TF_MODEL_FOR_MASKED_LM_MAPPING






  def 		_a					(self	)		->      int:





       '''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 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(task='''fill-mask'''   ,				model='''sshleifer/tiny-distilroberta-base'''   ,				top_k=2   ,				framework='''tf'''	)
       UpperCamelCase__										=      unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_   ,				decimals=6	)   ,				[
               {'''sequence''': '''My name is grouped''', '''score''': 2.1E-05, '''token''': 3_8015, '''token_str''': ''' grouped'''},
               {'''sequence''': '''My name is accuser''', '''score''': 2.1E-05, '''token''': 2_5506, '''token_str''': ''' accuser'''},
           ]   ,				)

       UpperCamelCase__										=      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-05,
                   '''token''': 3_8015,
                   '''token_str''': ''' grouped''',
               },
               {
                   '''sequence''': '''The largest city in France is accuser''',
                   '''score''': 2.1E-05,
                   '''token''': 2_5506,
                   '''token_str''': ''' accuser''',
               },
           ]   ,				)

       UpperCamelCase__										=      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-05, '''token''': 1_3606, '''token_str''': ''' Clara'''},
               {'''sequence''': '''My name is Patrick''', '''score''': 2E-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Te''', '''score''': 1.9E-05, '''token''': 2941, '''token_str''': ''' Te'''},
           ]   ,				)






  @require_torch
  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





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

       UpperCamelCase__										=      unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_   ,				decimals=6	)   ,				[
               {'''sequence''': '''My name is Maul''', '''score''': 2.2E-05, '''token''': 3_5676, '''token_str''': ''' Maul'''},
               {'''sequence''': '''My name isELS''', '''score''': 2.2E-05, '''token''': 1_6416, '''token_str''': '''ELS'''},
           ]   ,				)

       UpperCamelCase__										=      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-05,
                   '''token''': 3_5676,
                   '''token_str''': ''' Maul''',
               },
               {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2E-05, '''token''': 1_6416, '''token_str''': '''ELS'''},
           ]   ,				)

       UpperCamelCase__										=      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-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Te''', '''score''': 2E-05, '''token''': 2941, '''token_str''': ''' Te'''},
               {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 1_3606, '''token_str''': ''' Clara'''},
           ]   ,				)

       UpperCamelCase__										=      unmasker('''My name is <mask> <mask>'''   ,				top_k=2	)

       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_   ,				decimals=6	)   ,				[
               [
                   {
                       '''score''': 2.2E-05,
                       '''token''': 3_5676,
                       '''token_str''': ''' Maul''',
                       '''sequence''': '''<s>My name is Maul<mask></s>''',
                   },
                   {'''score''': 2.2E-05, '''token''': 1_6416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
               ],
               [
                   {
                       '''score''': 2.2E-05,
                       '''token''': 3_5676,
                       '''token_str''': ''' Maul''',
                       '''sequence''': '''<s>My name is<mask> Maul</s>''',
                   },
                   {'''score''': 2.2E-05, '''token''': 1_6416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
               ],
           ]   ,				)






  @require_torch_gpu
  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





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

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

       UpperCamelCase__										=      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 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(task='''fill-mask'''   ,				model='''distilroberta-base'''   ,				top_k=2   ,				framework='''pt'''	)
       self.run_large_test(SCREAMING_SNAKE_CASE_	)






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





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(task='''fill-mask'''   ,				model='''distilroberta-base'''   ,				top_k=2   ,				framework='''tf'''	)
       self.run_large_test(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_	)		->      List[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	)   ,				[
               {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 610, '''token_str''': ''' John'''},
               {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1573, '''token_str''': ''' Chris'''},
           ]   ,				)
       UpperCamelCase__										=      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''': 2201,
                   '''token_str''': ''' Paris''',
               },
               {
                   '''sequence''': '''The largest city in France is Lyon''',
                   '''score''': 0.214,
                   '''token''': 1_2790,
                   '''token_str''': ''' Lyon''',
               },
           ]   ,				)

       UpperCamelCase__										=      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''': 3499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 1_3606, '''token_str''': ''' Clara'''},
               {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2941, '''token_str''': ''' Te'''},
           ]   ,				)






  @require_torch
  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(task='''fill-mask'''   ,				model='''sshleifer/tiny-distilroberta-base'''   ,				framework='''pt'''	)
       UpperCamelCase__										=      None
       UpperCamelCase__										=      None
       self.run_pipeline_test(SCREAMING_SNAKE_CASE_   ,				[]	)






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





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(task='''fill-mask'''   ,				model='''sshleifer/tiny-distilroberta-base'''   ,				framework='''tf'''	)
       UpperCamelCase__										=      None
       UpperCamelCase__										=      None
       self.run_pipeline_test(SCREAMING_SNAKE_CASE_   ,				[]	)






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      List[Any]:





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

       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      [
           F"This is another {tokenizer.mask_token} test",
       ]
       return fill_masker, examples






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      List[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      fill_masker.tokenizer
       UpperCamelCase__										=      fill_masker.model

       UpperCamelCase__										=      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_	)},
           ]   ,				)

       UpperCamelCase__										=      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_	)},
           ]   ,				)

       UpperCamelCase__										=      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 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      str:





       '''simple docstring'''





       UpperCamelCase__										=      tokenizer.get_vocab()
       UpperCamelCase__										=      sorted(vocab.keys()	)[:2]
       # Pipeline argument
       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_   ,				targets=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      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_	)},
           ]   ,				)
       UpperCamelCase__										=      {vocab[el] for el in targets}
       self.assertEqual({el['''token'''] for el in outputs}   ,				SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      [tokenizer.decode([x]	) for x in target_ids]
       self.assertEqual({el['''token_str'''] for el in outputs}   ,				set(SCREAMING_SNAKE_CASE_	)	)

       # Call argument
       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      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_	)},
           ]   ,				)
       UpperCamelCase__										=      {vocab[el] for el in targets}
       self.assertEqual({el['''token'''] for el in outputs}   ,				SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      [tokenizer.decode([x]	) for x in target_ids]
       self.assertEqual({el['''token_str'''] for el in outputs}   ,				set(SCREAMING_SNAKE_CASE_	)	)

       # Score equivalence
       UpperCamelCase__										=      fill_masker(F"This is a {tokenizer.mask_token}"   ,				targets=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      [top_mask['''token_str'''] for top_mask in outputs]
       UpperCamelCase__										=      [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_	):
            UpperCamelCase__										=      fill_masker(F"This is a {tokenizer.mask_token}"   ,				targets=SCREAMING_SNAKE_CASE_	)
            UpperCamelCase__										=      [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_	):
            UpperCamelCase__										=      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_	):
                 UpperCamelCase__										=      fill_masker(F"This is a {tokenizer.mask_token}"   ,				targets=['''''']	)
            with self.assertRaises(SCREAMING_SNAKE_CASE_	):
                 UpperCamelCase__										=      fill_masker(F"This is a {tokenizer.mask_token}"   ,				targets=''''''	)






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





       '''simple docstring'''





       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_   ,				top_k=2	)
       UpperCamelCase__										=      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_	)},
           ]   ,				)

       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      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 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      Union[str, Any]:





       '''simple docstring'''





       UpperCamelCase__										=      tokenizer.get_vocab()
       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)

       # top_k=2, ntargets=3
       UpperCamelCase__										=      sorted(vocab.keys()	)[:3]
       UpperCamelCase__										=      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
       UpperCamelCase__										=      [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_	):
            UpperCamelCase__										=      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 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      Dict:





       '''simple docstring'''





       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      tokenizer.get_vocab()
       # String duplicates + id duplicates
       UpperCamelCase__										=      sorted(vocab.keys()	)[:3]
       UpperCamelCase__										=      [targets[0], targets[1], targets[0], targets[2], targets[1]]
       UpperCamelCase__										=      fill_masker(F"My name is {tokenizer.mask_token}"   ,				targets=SCREAMING_SNAKE_CASE_   ,				top_k=10	)

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






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





       '''simple docstring'''





       UpperCamelCase__										=      FillMaskPipeline(model=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      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_	)},
               ],
           ]   ,				)




import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
     import torch

     from transformers.activations import gelu_new, gelu_python, get_activation



@require_torch
class     _A   (    unittest.TestCase							):






  def 		_a					(self	)		->      str:





       '''simple docstring'''





       UpperCamelCase__										=      torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]	)
       UpperCamelCase__										=      get_activation('''gelu'''	)
       self.assertTrue(torch.allclose(gelu_python(SCREAMING_SNAKE_CASE_	)   ,				torch_builtin(SCREAMING_SNAKE_CASE_	)	)	)
       self.assertFalse(torch.allclose(gelu_python(SCREAMING_SNAKE_CASE_	)   ,				gelu_new(SCREAMING_SNAKE_CASE_	)	)	)






  def 		_a					(self	)		->      str:





       '''simple docstring'''





       UpperCamelCase__										=      torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]	)
       UpperCamelCase__										=      get_activation('''gelu'''	)
       UpperCamelCase__										=      get_activation('''gelu_10'''	)

       UpperCamelCase__										=      torch_builtin(SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      geluaa(SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      torch.where(y_gelu_aa < 10.0   ,				1   ,				0	)

       self.assertTrue(torch.max(SCREAMING_SNAKE_CASE_	).item() == 10.0	)
       self.assertTrue(torch.allclose(y_gelu * clipped_mask   ,				y_gelu_aa * clipped_mask	)	)






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





       '''simple docstring'''





       get_activation('''gelu'''	)
       get_activation('''gelu_10'''	)
       get_activation('''gelu_fast'''	)
       get_activation('''gelu_new'''	)
       get_activation('''gelu_python'''	)
       get_activation('''gelu_pytorch_tanh'''	)
       get_activation('''linear'''	)
       get_activation('''mish'''	)
       get_activation('''quick_gelu'''	)
       get_activation('''relu'''	)
       get_activation('''sigmoid'''	)
       get_activation('''silu'''	)
       get_activation('''swish'''	)
       get_activation('''tanh'''	)
       with self.assertRaises(SCREAMING_SNAKE_CASE_	):
            get_activation('''bogus'''	)
       with self.assertRaises(SCREAMING_SNAKE_CASE_	):
            get_activation(SCREAMING_SNAKE_CASE_	)






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





       '''simple docstring'''





       UpperCamelCase__										=      get_activation('''gelu'''	)
       UpperCamelCase__										=      1
       UpperCamelCase__										=      get_activation('''gelu'''	)
       self.assertEqual(acta.a   ,				1	)
       with self.assertRaises(SCREAMING_SNAKE_CASE_	):
            UpperCamelCase__										=      acta.a



