





'''simple docstring'''


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    lowerCAmelCase_		(		unittest.TestCase		):
 __lowerCamelCase						:							List[Any]         =					MODEL_FOR_MASKED_LM_MAPPING
 __lowerCamelCase						:							List[Any]         =					TF_MODEL_FOR_MASKED_LM_MAPPING




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     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 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="sshleifer/tiny-distilroberta-base"			,     top_k=2			,     framework="tf"		)
     _lowerCAmelCase				=      unmasker("My name is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             {"sequence": "My name is grouped", "score": 2.1E-05, "token": 38015, "token_str": " grouped"},
             {"sequence": "My name is accuser", "score": 2.1E-05, "token": 25506, "token_str": " accuser"},
         ]			,     )

     _lowerCAmelCase				=      unmasker("The largest city in France is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             {
                 "sequence": "The largest city in France is grouped",
                 "score": 2.1E-05,
                 "token": 38015,
                 "token_str": " grouped",
             },
             {
                 "sequence": "The largest city in France is accuser",
                 "score": 2.1E-05,
                 "token": 25506,
                 "token_str": " accuser",
             },
         ]			,     )

     _lowerCAmelCase				=      unmasker("My name is <mask>"			,     targets=[" Patrick", " Clara", " Teven"]			,     top_k=3		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             {"sequence": "My name is Clara", "score": 2E-05, "token": 13606, "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 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="sshleifer/tiny-distilroberta-base"			,     top_k=2			,     framework="pt"		)

     _lowerCAmelCase				=      unmasker("My name is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             {"sequence": "My name is Maul", "score": 2.2E-05, "token": 35676, "token_str": " Maul"},
             {"sequence": "My name isELS", "score": 2.2E-05, "token": 16416, "token_str": "ELS"},
         ]			,     )

     _lowerCAmelCase				=      unmasker("The largest city in France is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             {
                 "sequence": "The largest city in France is Maul",
                 "score": 2.2E-05,
                 "token": 35676,
                 "token_str": " Maul",
             },
             {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 16416, "token_str": "ELS"},
         ]			,     )

     _lowerCAmelCase				=      unmasker("My name is <mask>"			,     targets=[" Patrick", " Clara", " Teven"]			,     top_k=3		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     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": 13606, "token_str": " Clara"},
         ]			,     )

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

     self.assertEqual(
         nested_simplify(_lowerCAmelCase			,     decimals=6		)			,     [
             [
                 {
                     "score": 2.2E-05,
                     "token": 35676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is Maul<mask></s>",
                 },
                 {"score": 2.2E-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
             ],
             [
                 {
                     "score": 2.2E-05,
                     "token": 35676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is<mask> Maul</s>",
                 },
                 {"score": 2.2E-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
             ],
         ]			,     )




 @require_torch_gpu
 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      pipeline("fill-mask"			,     model="hf-internal-testing/tiny-random-distilbert"			,     device=0			,     framework="pt"		)

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

     _lowerCAmelCase				=      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(_lowerCAmelCase			,     _lowerCAmelCase		)




 @slow
 @require_torch
 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="distilroberta-base"			,     top_k=2			,     framework="pt"		)
     self.run_large_test(_lowerCAmelCase		)




 @slow
 @require_tf
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="distilroberta-base"			,     top_k=2			,     framework="tf"		)
     self.run_large_test(_lowerCAmelCase		)




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							str:
     _lowerCAmelCase				=      unmasker("My name is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             {"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"},
         ]			,     )
     _lowerCAmelCase				=      unmasker("The largest city in France is <mask>"		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             {
                 "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": 12790,
                 "token_str": " Lyon",
             },
         ]			,     )

     _lowerCAmelCase				=      unmasker("My name is <mask>"			,     targets=[" Patrick", " Clara", " Teven"]			,     top_k=3		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             {"sequence": "My name is Patrick", "score": 0.005, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Clara", "score": 0.000, "token": 13606, "token_str": " Clara"},
             {"sequence": "My name is Te", "score": 0.000, "token": 2941, "token_str": " Te"},
         ]			,     )




 @require_torch
 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="sshleifer/tiny-distilroberta-base"			,     framework="pt"		)
     _lowerCAmelCase				=      None
     _lowerCAmelCase				=      None
     self.run_pipeline_test(_lowerCAmelCase			,     []		)




 @require_tf
 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      pipeline(task="fill-mask"			,     model="sshleifer/tiny-distilroberta-base"			,     framework="tf"		)
     _lowerCAmelCase				=      None
     _lowerCAmelCase				=      None
     self.run_pipeline_test(_lowerCAmelCase			,     []		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							List[Any]:
     if tokenizer is None or tokenizer.mask_token_id is None:
         self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)"		)

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




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							List[Any]:
     _lowerCAmelCase				=      fill_masker.tokenizer
     _lowerCAmelCase				=      fill_masker.model

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

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

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

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

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




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

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

     # Score equivalence
     _lowerCAmelCase				=      fill_masker(f'''This is a {tokenizer.mask_token}'''			,     targets=_lowerCAmelCase		)
     _lowerCAmelCase				=      [top_mask["token_str"] for top_mask in outputs]
     _lowerCAmelCase				=      [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(_lowerCAmelCase		) == set(_lowerCAmelCase		):
         _lowerCAmelCase				=      fill_masker(f'''This is a {tokenizer.mask_token}'''			,     targets=_lowerCAmelCase		)
         _lowerCAmelCase				=      [top_mask["score"] for top_mask in unmasked_targets]
         self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     nested_simplify(_lowerCAmelCase		)		)

     # Raises with invalid
     with self.assertRaises(_lowerCAmelCase		):
         _lowerCAmelCase				=      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(_lowerCAmelCase		):
             _lowerCAmelCase				=      fill_masker(f'''This is a {tokenizer.mask_token}'''			,     targets=[""]		)
         with self.assertRaises(_lowerCAmelCase		):
             _lowerCAmelCase				=      fill_masker(f'''This is a {tokenizer.mask_token}'''			,     targets=""		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Dict:
     _lowerCAmelCase				=      FillMaskPipeline(model=_lowerCAmelCase			,     tokenizer=_lowerCAmelCase			,     top_k=2		)
     _lowerCAmelCase				=      fill_masker(f'''This is a {tokenizer.mask_token}'''		)
     self.assertEqual(
         _lowerCAmelCase			,     [
             {"sequence": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		), "token": ANY(_lowerCAmelCase		), "token_str": ANY(_lowerCAmelCase		)},
             {"sequence": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		), "token": ANY(_lowerCAmelCase		), "token_str": ANY(_lowerCAmelCase		)},
         ]			,     )

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




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Optional[int]:
     _lowerCAmelCase				=      tokenizer.get_vocab()
     _lowerCAmelCase				=      FillMaskPipeline(model=_lowerCAmelCase			,     tokenizer=_lowerCAmelCase		)

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

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




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							List[Any]:
     _lowerCAmelCase				=      FillMaskPipeline(model=_lowerCAmelCase			,     tokenizer=_lowerCAmelCase		)
     _lowerCAmelCase				=      tokenizer.get_vocab()
     # String duplicates + id duplicates
     _lowerCAmelCase				=      sorted(vocab.keys()		)[:3]
     _lowerCAmelCase				=      [targets[0], targets[1], targets[0], targets[2], targets[1]]
     _lowerCAmelCase				=      fill_masker(f'''My name is {tokenizer.mask_token}'''			,     targets=_lowerCAmelCase			,     top_k=10		)

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





 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							int:
     _lowerCAmelCase				=      FillMaskPipeline(model=_lowerCAmelCase			,     tokenizer=_lowerCAmelCase		)

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









'''simple docstring'''


from ...configuration_utils import PretrainedConfig

class    lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase						:							List[str]         =					"bert-generation"




 def __init__(	self			,     _lowerCAmelCase=50358			,     _lowerCAmelCase=1024			,     _lowerCAmelCase=24			,     _lowerCAmelCase=16			,     _lowerCAmelCase=4096			,     _lowerCAmelCase="gelu"			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=512			,     _lowerCAmelCase=0.02			,     _lowerCAmelCase=1E-12			,     _lowerCAmelCase=0			,     _lowerCAmelCase=2			,     _lowerCAmelCase=1			,     _lowerCAmelCase="absolute"			,     _lowerCAmelCase=True			,     **_lowerCAmelCase			,     )    ->							Tuple:
     super().__init__(pad_token_id=_lowerCAmelCase			,     bos_token_id=_lowerCAmelCase			,     eos_token_id=_lowerCAmelCase			,     **_lowerCAmelCase		)

     _lowerCAmelCase				=      vocab_size
     _lowerCAmelCase				=      hidden_size
     _lowerCAmelCase				=      num_hidden_layers
     _lowerCAmelCase				=      num_attention_heads
     _lowerCAmelCase				=      hidden_act
     _lowerCAmelCase				=      intermediate_size
     _lowerCAmelCase				=      hidden_dropout_prob
     _lowerCAmelCase				=      attention_probs_dropout_prob
     _lowerCAmelCase				=      max_position_embeddings
     _lowerCAmelCase				=      initializer_range
     _lowerCAmelCase				=      layer_norm_eps
     _lowerCAmelCase				=      position_embedding_type
     _lowerCAmelCase				=      use_cache


