




'''simple docstring'''







import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwiftFormerForImageClassification, SwiftFormerModel
    from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import ViTImageProcessor

class 	_snake_case:






 def __init__(self       :  List[Any]    ,		a       :  str    ,		a       :  str=13    ,		a       :  Tuple=3    ,		a       :  Dict=True    ,		a       :  Tuple=True    ,		a       :  str=0.1    ,		a       :  Tuple=0.1    ,		a       :  List[str]=2_24    ,		a       :  List[Any]=10_00    ,		a       :  Dict=[3, 3, 6, 4]    ,		a       :  Tuple=[48, 56, 1_12, 2_20]    ,		)       ->   Union[str, Any]:






    """simple docstring"""


    A__       =     parent
    A__       =     batch_size
    A__       =     num_channels
    A__       =     is_training
    A__       =     use_labels
    A__       =     hidden_dropout_prob
    A__       =     attention_probs_dropout_prob
    A__       =     num_labels
    A__       =     image_size
    A__       =     layer_depths
    A__       =     embed_dims






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Dict:






    """simple docstring"""


    A__       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

    A__       =     None
    if self.use_labels:
       A__       =     ids_tensor([self.batch_size]    ,		self.num_labels    )

    A__       =     self.get_config()

    return config, pixel_values, labels






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   List[str]:






    """simple docstring"""


    return SwiftFormerConfig(
        depths=self.layer_depths    ,		embed_dims=self.embed_dims    ,		mlp_ratio=4    ,		downsamples=[True, True, True, True]    ,		hidden_act='gelu'    ,		num_labels=self.num_labels    ,		down_patch_size=3    ,		down_stride=2    ,		down_pad=1    ,		drop_rate=0.0    ,		drop_path_rate=0.0    ,		use_layer_scale=_SCREAMING_SNAKE_CASE    ,		layer_scale_init_value=1e-5    ,		)






 def 						_UpperCamelCase (self       :  Dict    ,		a       :  Any    ,		a       :  Optional[int]    ,		a       :  List[Any]    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     SwiftFormerModel(config=_SCREAMING_SNAKE_CASE    )
    model.to(_SCREAMING_SNAKE_CASE    )
    model.eval()
    A__       =     model(_SCREAMING_SNAKE_CASE    )
    self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.embed_dims[-1], 7, 7)    )






 def 						_UpperCamelCase (self       :  Dict    ,		a       :  Optional[Any]    ,		a       :  Union[str, Any]    ,		a       :  Optional[int]    )       ->   List[str]:






    """simple docstring"""


    A__       =     self.num_labels
    A__       =     SwiftFormerForImageClassification(_SCREAMING_SNAKE_CASE    )
    model.to(_SCREAMING_SNAKE_CASE    )
    model.eval()
    A__       =     model(_SCREAMING_SNAKE_CASE    ,		labels=_SCREAMING_SNAKE_CASE    )
    self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_labels)    )

    A__       =     SwiftFormerForImageClassification(_SCREAMING_SNAKE_CASE    )
    model.to(_SCREAMING_SNAKE_CASE    )
    model.eval()

    A__       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )
    A__       =     model(_SCREAMING_SNAKE_CASE    )
    self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_labels)    )






 def 						_UpperCamelCase (self       :  List[str]    )       ->   Tuple:






    """simple docstring"""


    ((A__)  ,			(A__)  ,			(A__))       =     self.prepare_config_and_inputs()
    A__       =     {'pixel_values': pixel_values}
    return config, inputs_dict




@require_torch
class 	_snake_case(			UpperCAmelCase       , UpperCAmelCase       , unittest.TestCase      ):
 __snake_case:							int						=					(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
 __snake_case:							List[str]						=					(
     {'feature-extraction': SwiftFormerModel, 'image-classification': SwiftFormerForImageClassification}
     if is_torch_available()
     else {}
 )

 __snake_case:							str						=					False
 __snake_case:							Union[str, Any]						=					False
 __snake_case:							Optional[Any]						=					False
 __snake_case:							Dict						=					False
 __snake_case:							int						=					False






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






    """simple docstring"""


    A__       =     SwiftFormerModelTester(self    )
    A__       =     ConfigTester(
        self    ,		config_class=_SCREAMING_SNAKE_CASE    ,		has_text_modality=_SCREAMING_SNAKE_CASE    ,		hidden_size=37    ,		num_attention_heads=12    ,		num_hidden_layers=12    ,		)






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






    """simple docstring"""


    self.config_tester.run_common_tests()






 @unittest.skip(reason='SwiftFormer does not use inputs_embeds'    )
 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Any:






    """simple docstring"""


    pass






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Dict:






    """simple docstring"""


    A__  ,			A__       =     self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       A__       =     model_class(_SCREAMING_SNAKE_CASE    )
       A__       =     model.get_output_embeddings()
       self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE    ,		nn.Linear    )    )






 def 						_UpperCamelCase (self       :  List[str]    )       ->   Tuple:






    """simple docstring"""


    A__  ,			A__       =     self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       A__       =     model_class(_SCREAMING_SNAKE_CASE    )
       A__       =     inspect.signature(model.forward    )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       A__       =     [*signature.parameters.keys()]

       A__       =     ['pixel_values']
       self.assertListEqual(arg_names[:1]    ,		_SCREAMING_SNAKE_CASE    )






 def 						_UpperCamelCase (self       :  str    )       ->   Optional[Any]:






    """simple docstring"""


    A__       =     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE    )






 def 						_UpperCamelCase (self       :  str    )       ->   str:






    """simple docstring"""


    A__       =     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE    )






 @slow
 def 						_UpperCamelCase (self       :  Dict    )       ->   int:






    """simple docstring"""


    for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       A__       =     SwiftFormerModel.from_pretrained(_SCREAMING_SNAKE_CASE    )
       self.assertIsNotNone(_SCREAMING_SNAKE_CASE    )






 @unittest.skip(reason='SwiftFormer does not output attentions'    )
 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Optional[int]:






    """simple docstring"""


    pass






 def 						_UpperCamelCase (self       :  int    )       ->   Optional[int]:






    """simple docstring"""


    def check_hidden_states_output(a       :  Optional[Any]    ,		a       :  Optional[int]    ,		a       :  List[str]    ):
       A__       =     model_class(_SCREAMING_SNAKE_CASE    )
       model.to(_SCREAMING_SNAKE_CASE    )
       model.eval()

       with torch.no_grad():
          A__       =     model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )    )

       A__       =     outputs.hidden_states

       A__       =     8
       self.assertEqual(len(_SCREAMING_SNAKE_CASE    )    ,		_SCREAMING_SNAKE_CASE    )  # TODO

       # SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
       # with the width and height being successively divided by 2, after every 2 blocks
       for i in range(len(_SCREAMING_SNAKE_CASE    )    ):
          self.assertEqual(
              hidden_states[i].shape    ,		torch.Size(
                  [
                      self.model_tester.batch_size,
                      self.model_tester.embed_dims[i // 2],
                      (self.model_tester.image_size // 4) // 2 ** (i // 2),
                      (self.model_tester.image_size // 4) // 2 ** (i // 2),
                  ]    )    ,		)

    A__  ,			A__       =     self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       A__       =     True
       check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       A__       =     True

       check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )






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






    """simple docstring"""


    def _config_zero_init(a       :  Union[str, Any]    ):
       A__       =     copy.deepcopy(_SCREAMING_SNAKE_CASE    )
       for key in configs_no_init.__dict__.keys():
          if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
             setattr(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		1e-10    )
          if isinstance(getattr(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )    ,		_SCREAMING_SNAKE_CASE    ):
             A__       =     _config_zero_init(getattr(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )    )
             setattr(_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    )
       return configs_no_init

    A__  ,			A__       =     self.model_tester.prepare_config_and_inputs_for_common()

    A__       =     _config_zero_init(_SCREAMING_SNAKE_CASE    )
    for model_class in self.all_model_classes:
       A__       =     model_class(config=_SCREAMING_SNAKE_CASE    )
       for name, param in model.named_parameters():
          if param.requires_grad:
             self.assertIn(
                 ((param.data.mean() * 1e9) / 1e9).round().item()    ,		[0.0, 1.0]    ,		msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""    ,		)






 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'    )
 def 						_UpperCamelCase (self       :  Tuple    )       ->   int:






    """simple docstring"""


    pass







def 						_A      ( ):






   '''simple docstring'''







   A__       =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
   return image







@require_torch
@require_vision
class 	_snake_case(			unittest.TestCase      ):






 @cached_property
 def 						_UpperCamelCase (self       :  Dict    )       ->   List[Any]:






    """simple docstring"""


    return ViTImageProcessor.from_pretrained('MBZUAI/swiftformer-xs'    ) if is_vision_available() else None






 @slow
 def 						_UpperCamelCase (self       :  Any    )       ->   Dict:






    """simple docstring"""


    A__       =     SwiftFormerForImageClassification.from_pretrained('MBZUAI/swiftformer-xs'    ).to(_SCREAMING_SNAKE_CASE    )

    A__       =     self.default_image_processor
    A__       =     prepare_img()
    A__       =     image_processor(images=_SCREAMING_SNAKE_CASE    ,		return_tensors='pt'    ).to(_SCREAMING_SNAKE_CASE    )

    # forward pass
    with torch.no_grad():
       A__       =     model(**_SCREAMING_SNAKE_CASE    )

    # verify the logits
    A__       =     torch.Size((1, 10_00)    )
    self.assertEqual(outputs.logits.shape    ,		_SCREAMING_SNAKE_CASE    )

    A__       =     torch.tensor([[-2.1703e00, 2.1107e00, -2.0811e00]]    ).to(_SCREAMING_SNAKE_CASE    )
    self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,		_SCREAMING_SNAKE_CASE    ,		atol=1e-4    )    )






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     ):
		_a      :    int           =      MODEL_FOR_MASKED_LM_MAPPING
		_a      :    Tuple           =      TF_MODEL_FOR_MASKED_LM_MAPPING
		def       UpperCAmelCase__							(     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       UpperCAmelCase__							(     self		)					->			int:




									"""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-0_5, 'token': 38015, 'token_str': ' grouped'},
									        {'sequence': 'My name is accuser', 'score': 2.1e-0_5, 'token': 25506, '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-0_5,
									            'token': 38015,
									            'token_str': ' grouped',
									        },
									        {
									            'sequence': 'The largest city in France is accuser',
									            'score': 2.1e-0_5,
									            'token': 25506,
									            '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-0_5, 'token': 13606, 'token_str': ' Clara'},
									        {'sequence': 'My name is Patrick', 'score': 2e-0_5, 'token': 3499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 1.9e-0_5, 'token': 2941, 'token_str': ' Te'},
									    ]     ,       )
		@require_torch
		def       UpperCAmelCase__							(     self		)					->			int:




									"""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-0_5, 'token': 35676, 'token_str': ' Maul'},
									        {'sequence': 'My name isELS', 'score': 2.2e-0_5, 'token': 16416, '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-0_5,
									            'token': 35676,
									            'token_str': ' Maul',
									        },
									        {'sequence': 'The largest city in France isELS', 'score': 2.2e-0_5, 'token': 16416, '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-0_5, 'token': 3499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 2e-0_5, 'token': 2941, 'token_str': ' Te'},
									        {'sequence': 'My name is Clara', 'score': 2e-0_5, 'token': 13606, '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-0_5,
									                'token': 35676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is Maul<mask></s>',
									            },
									            {'score': 2.2e-0_5, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
									        ],
									        [
									            {
									                'score': 2.2e-0_5,
									                'token': 35676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is<mask> Maul</s>',
									            },
									            {'score': 2.2e-0_5, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
									        ],
									    ]     ,       )
		@require_torch_gpu
		def       UpperCAmelCase__							(     self		)					->			List[Any]:




									"""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       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""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       UpperCAmelCase__							(     self		)					->			Dict:




									"""simple docstring"""





									_UpperCAmelCase											=     pipeline(task='fill-mask'     ,       model='distilroberta-base'     ,       top_k=2     ,       framework='tf'		)
									self.run_large_test(_SCREAMING_SNAKE_CASE		)
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE		)					->			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': 12790,
									            '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': 13606, 'token_str': ' Clara'},
									        {'sequence': 'My name is Te', 'score': 0.000, 'token': 2941, 'token_str': ' Te'},
									    ]     ,       )
		@require_torch
		def       UpperCAmelCase__							(     self		)					->			Dict:




									"""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       UpperCAmelCase__							(     self		)					->			int:




									"""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       UpperCAmelCase__							(     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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			List[str]:




									"""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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			Any:




									"""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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			Union[str, Any]:




									"""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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			int:




									"""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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			str:




									"""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       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			Tuple:




									"""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		)},
									        ],
									    ]     ,       )
