




import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case            = logging.get_logger(__name__)

_snake_case            = {
    "b0": efficientnet.EfficientNetBa,
    "b1": efficientnet.EfficientNetBa,
    "b2": efficientnet.EfficientNetBa,
    "b3": efficientnet.EfficientNetBa,
    "b4": efficientnet.EfficientNetBa,
    "b5": efficientnet.EfficientNetBa,
    "b6": efficientnet.EfficientNetBa,
    "b7": efficientnet.EfficientNetBa,
}

_snake_case            = {
    "b0": {
        "hidden_dim": 1280,
        "width_coef": 1.0,
        "depth_coef": 1.0,
        "image_size": 224,
        "dropout_rate": 0.2,
        "dw_padding": [],
    },
    "b1": {
        "hidden_dim": 1280,
        "width_coef": 1.0,
        "depth_coef": 1.1,
        "image_size": 240,
        "dropout_rate": 0.2,
        "dw_padding": [16],
    },
    "b2": {
        "hidden_dim": 1408,
        "width_coef": 1.1,
        "depth_coef": 1.2,
        "image_size": 260,
        "dropout_rate": 0.3,
        "dw_padding": [5, 8, 16],
    },
    "b3": {
        "hidden_dim": 1536,
        "width_coef": 1.2,
        "depth_coef": 1.4,
        "image_size": 300,
        "dropout_rate": 0.3,
        "dw_padding": [5, 18],
    },
    "b4": {
        "hidden_dim": 1792,
        "width_coef": 1.4,
        "depth_coef": 1.8,
        "image_size": 380,
        "dropout_rate": 0.4,
        "dw_padding": [6],
    },
    "b5": {
        "hidden_dim": 2048,
        "width_coef": 1.6,
        "depth_coef": 2.2,
        "image_size": 456,
        "dropout_rate": 0.4,
        "dw_padding": [13, 27],
    },
    "b6": {
        "hidden_dim": 2304,
        "width_coef": 1.8,
        "depth_coef": 2.6,
        "image_size": 528,
        "dropout_rate": 0.5,
        "dw_padding": [31],
    },
    "b7": {
        "hidden_dim": 2560,
        "width_coef": 2.0,
        "depth_coef": 3.1,
        "image_size": 600,
        "dropout_rate": 0.5,
        "dw_padding": [18],
    },
}







def        lowerCAmelCase_			(  snake_case_  ):
      _A							:  Optional[int]    =		EfficientNetConfig()
      _A							:  Any    =		CONFIG_MAP[model_name]["""hidden_dim"""]
      _A							:  Dict    =		CONFIG_MAP[model_name]["""width_coef"""]
      _A							:  Tuple    =		CONFIG_MAP[model_name]["""depth_coef"""]
      _A							:  int    =		CONFIG_MAP[model_name]["""image_size"""]
      _A							:  str    =		CONFIG_MAP[model_name]["""dropout_rate"""]
      _A							:  Union[str, Any]    =		CONFIG_MAP[model_name]["""dw_padding"""]

      _A							:  Optional[int]    =		"""huggingface/label-files"""
      _A							:  Optional[int]    =		"""imagenet-1k-id2label.json"""
      _A							:  Union[str, Any]    =		1000
      _A							:  Dict    =		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,repo_type="""dataset"""  ),"""r"""  )  )
      _A							:  Union[str, Any]    =		{int(_SCREAMING_SNAKE_CASE  ): v for k, v in idalabel.items()}

      _A							:  Union[str, Any]    =		idalabel
      _A							:  Optional[Any]    =		{v: k for k, v in idalabel.items()}
      return config







def        lowerCAmelCase_			(  ):
      _A							:  Any    =		"""http://images.cocodataset.org/val2017/000000039769.jpg"""
      _A							:  str    =		Image.open(requests.get(_SCREAMING_SNAKE_CASE,stream=_SCREAMING_SNAKE_CASE  ).raw  )
      return im







def        lowerCAmelCase_			(  snake_case_  ):
      _A							:  Optional[int]    =		CONFIG_MAP[model_name]["""image_size"""]
      _A							:  Optional[Any]    =		EfficientNetImageProcessor(
          size={"""height""": size, """width""": size},image_mean=[0.4_85, 0.4_56, 0.4_06],image_std=[0.47_85_39_44, 0.4_73_28_64, 0.47_43_41_63],do_center_crop=_SCREAMING_SNAKE_CASE,)
      return preprocessor







def        lowerCAmelCase_			(  snake_case_  ):
      _A							:  Optional[int]    =		[v.split("""_"""  )[0].split("""block"""  )[1] for v in original_param_names if v.startswith("""block"""  )]
      _A							:  Optional[Any]    =		sorted(set(_SCREAMING_SNAKE_CASE  )  )
      _A							:  Dict    =		len(_SCREAMING_SNAKE_CASE  )
      _A							:  Optional[int]    =		{b: str(_SCREAMING_SNAKE_CASE  ) for b, i in zip(_SCREAMING_SNAKE_CASE,range(_SCREAMING_SNAKE_CASE  )  )}

      _A							:  Optional[int]    =		[]
      rename_keys.append(("""stem_conv/kernel:0""", """embeddings.convolution.weight""")  )
      rename_keys.append(("""stem_bn/gamma:0""", """embeddings.batchnorm.weight""")  )
      rename_keys.append(("""stem_bn/beta:0""", """embeddings.batchnorm.bias""")  )
      rename_keys.append(("""stem_bn/moving_mean:0""", """embeddings.batchnorm.running_mean""")  )
      rename_keys.append(("""stem_bn/moving_variance:0""", """embeddings.batchnorm.running_var""")  )

      for b in block_names:
            _A							:  List[Any]    =		block_name_mapping[b]
            rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')  )
            rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')  )
            rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')  )
            rename_keys.append(
                (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')  )
            rename_keys.append(
                (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')  )
            rename_keys.append(
                (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')  )
            rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')  )
            rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')  )
            rename_keys.append(
                (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')  )
            rename_keys.append(
                (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')  )

            rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')  )
            rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')  )
            rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')  )
            rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')  )
            rename_keys.append(
                (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')  )
            rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')  )
            rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')  )
            rename_keys.append(
                (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')  )
            rename_keys.append(
                (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')  )

      rename_keys.append(("""top_conv/kernel:0""", """encoder.top_conv.weight""")  )
      rename_keys.append(("""top_bn/gamma:0""", """encoder.top_bn.weight""")  )
      rename_keys.append(("""top_bn/beta:0""", """encoder.top_bn.bias""")  )
      rename_keys.append(("""top_bn/moving_mean:0""", """encoder.top_bn.running_mean""")  )
      rename_keys.append(("""top_bn/moving_variance:0""", """encoder.top_bn.running_var""")  )

      _A							:  int    =		{}
      for item in rename_keys:
            if item[0] in original_param_names:
                  _A							:  Any    =		"""efficientnet.""" + item[1]

      _A							:  List[str]    =		"""classifier.weight"""
      _A							:  Tuple    =		"""classifier.bias"""
      return key_mapping







def        lowerCAmelCase_			(  snake_case_,snake_case_,snake_case_  ):
      for key, value in tf_params.items():
            if "normalization" in key:
                  continue

            _A							:  List[str]    =		key_mapping[key]
            if "_conv" in key and "kernel" in key:
                  _A							:  List[str]    =		torch.from_numpy(_SCREAMING_SNAKE_CASE  ).permute(3,2,0,1  )
            elif "depthwise_kernel" in key:
                  _A							:  List[str]    =		torch.from_numpy(_SCREAMING_SNAKE_CASE  ).permute(2,3,0,1  )
            elif "kernel" in key:
                  _A							:  int    =		torch.from_numpy(np.transpose(_SCREAMING_SNAKE_CASE  )  )
            else:
                  _A							:  Optional[Any]    =		torch.from_numpy(_SCREAMING_SNAKE_CASE  )

            # Replace HF parameters with original TF model parameters
            assert hf_params[hf_key].shape == new_hf_value.shape
            hf_params[hf_key].copy_(_SCREAMING_SNAKE_CASE  )







@torch.no_grad()
def        lowerCAmelCase_			(  snake_case_,snake_case_,snake_case_,snake_case_  ):
      _A							:  Optional[Any]    =		model_classes[model_name](
          include_top=_SCREAMING_SNAKE_CASE,weights="""imagenet""",input_tensor=_SCREAMING_SNAKE_CASE,input_shape=_SCREAMING_SNAKE_CASE,pooling=_SCREAMING_SNAKE_CASE,classes=1000,classifier_activation="""softmax""",)

      _A							:  str    =		original_model.trainable_variables
      _A							:  Dict    =		original_model.non_trainable_variables
      _A							:  Union[str, Any]    =		{param.name: param.numpy() for param in tf_params}
      for param in tf_non_train_params:
            _A							:  Optional[Any]    =		param.numpy()
      _A							:  Tuple    =		list(tf_params.keys()  )

      # Load HuggingFace model
      _A							:  int    =		get_efficientnet_config(_SCREAMING_SNAKE_CASE  )
      _A							:  Dict    =		EfficientNetForImageClassification(_SCREAMING_SNAKE_CASE  ).eval()
      _A							:  Any    =		hf_model.state_dict()

      # Create src-to-dst parameter name mapping dictionary
      print("""Converting parameters..."""  )
      _A							:  Union[str, Any]    =		rename_keys(_SCREAMING_SNAKE_CASE  )
      replace_params(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE  )

      # Initialize preprocessor and preprocess input image
      _A							:  List[str]    =		convert_image_processor(_SCREAMING_SNAKE_CASE  )
      _A							:  Optional[Any]    =		preprocessor(images=prepare_img(),return_tensors="""pt"""  )

      # HF model inference
      hf_model.eval()
      with torch.no_grad():
            _A							:  List[str]    =		hf_model(**_SCREAMING_SNAKE_CASE  )
      _A							:  Dict    =		outputs.logits.detach().numpy()

      # Original model inference
      _A							:  Tuple    =		False
      _A							:  Tuple    =		CONFIG_MAP[model_name]["""image_size"""]
      _A							:  str    =		prepare_img().resize((image_size, image_size),resample=PIL.Image.NEAREST  )
      _A							:  Any    =		image.img_to_array(_SCREAMING_SNAKE_CASE  )
      _A							:  Dict    =		np.expand_dims(_SCREAMING_SNAKE_CASE,axis=0  )
      _A							:  Any    =		original_model.predict(_SCREAMING_SNAKE_CASE  )

      # Check whether original and HF model outputs match  -> np.allclose
      assert np.allclose(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,atol=1e-3  ), "The predicted logits are not the same."
      print("""Model outputs match!"""  )

      if save_model:
            # Create folder to save model
            if not os.path.isdir(_SCREAMING_SNAKE_CASE  ):
                  os.mkdir(_SCREAMING_SNAKE_CASE  )
            # Save converted model and image processor
            hf_model.save_pretrained(_SCREAMING_SNAKE_CASE  )
            preprocessor.save_pretrained(_SCREAMING_SNAKE_CASE  )

      if push_to_hub:
            # Push model and image processor to hub
            print(f'''Pushing converted {model_name} to the hub...'''  )
            _A							:  Tuple    =		f'''efficientnet-{model_name}'''
            preprocessor.push_to_hub(_SCREAMING_SNAKE_CASE  )
            hf_model.push_to_hub(_SCREAMING_SNAKE_CASE  )


if __name__ == "__main__":
  _snake_case            = argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--model_name",
      default="b0",
      type=str,
      help="Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].",
  )
  parser.add_argument(
      "--pytorch_dump_folder_path",
      default="hf_model",
      type=str,
      help="Path to the output PyTorch model directory.",
  )
  parser.add_argument("--save_model", action="store_true", help="Save model to local")
  parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")

  _snake_case            = parser.parse_args()
  convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)







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 		lowercase							(     unittest.TestCase	):
     _a											=		MODEL_FOR_MASKED_LM_MAPPING
     _a											=		TF_MODEL_FOR_MASKED_LM_MAPPING

     def       a__			(						self       )		->							Tuple:
           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       )		->							Any:
           _A							:  Optional[Any]    =		pipeline(task="""fill-mask"""	,  model="""sshleifer/tiny-distilroberta-base"""	,  top_k=2	,  framework="""tf"""       )
           _A							:  Optional[int]    =		unmasker("""My name is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a	,  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"""},
               ]	,  )

           _A							:  Tuple    =		unmasker("""The largest city in France is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a	,  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""",
                   },
               ]	,  )

           _A							:  List[str]    =		unmasker("""My name is <mask>"""	,  targets=[""" Patrick""", """ Clara""", """ Teven"""]	,  top_k=3       )
           self.assertEqual(
               nested_simplify(_a	,  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       )		->							str:
           _A							:  Any    =		pipeline(task="""fill-mask"""	,  model="""sshleifer/tiny-distilroberta-base"""	,  top_k=2	,  framework="""pt"""       )

           _A							:  List[Any]    =		unmasker("""My name is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a	,  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"""},
               ]	,  )

           _A							:  Optional[Any]    =		unmasker("""The largest city in France is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a	,  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"""},
               ]	,  )

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

           _A							:  str    =		unmasker("""My name is <mask> <mask>"""	,  top_k=2       )

           self.assertEqual(
               nested_simplify(_a	,  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       )		->							Union[str, Any]:
           _A							:  int    =		pipeline("""fill-mask"""	,  model="""hf-internal-testing/tiny-random-distilbert"""	,  device=0	,  framework="""pt"""       )

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

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

     @slow
     @require_torch
     def       a__			(						self       )		->							Optional[int]:
           _A							:  Optional[Any]    =		pipeline(task="""fill-mask"""	,  model="""distilroberta-base"""	,  top_k=2	,  framework="""pt"""       )
           self.run_large_test(_a       )

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

     def       a__			(						self	,  _a       )		->							Tuple:
           _A							:  Optional[int]    =		unmasker("""My name is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a       )	,  [
                   {"""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"""},
               ]	,  )
           _A							:  int    =		unmasker("""The largest city in France is <mask>"""       )
           self.assertEqual(
               nested_simplify(_a       )	,  [
                   {
                       """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""",
                   },
               ]	,  )

           _A							:  Optional[Any]    =		unmasker("""My name is <mask>"""	,  targets=[""" Patrick""", """ Clara""", """ Teven"""]	,  top_k=3       )
           self.assertEqual(
               nested_simplify(_a       )	,  [
                   {"""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       )		->							Tuple:
           _A							:  List[str]    =		pipeline(task="""fill-mask"""	,  model="""sshleifer/tiny-distilroberta-base"""	,  framework="""pt"""       )
           _A							:  str    =		None
           _A							:  Union[str, Any]    =		None
           self.run_pipeline_test(_a	,  []       )

     @require_tf
     def       a__			(						self       )		->							Union[str, Any]:
           _A							:  Tuple    =		pipeline(task="""fill-mask"""	,  model="""sshleifer/tiny-distilroberta-base"""	,  framework="""tf"""       )
           _A							:  Any    =		None
           _A							:  Dict    =		None
           self.run_pipeline_test(_a	,  []       )

     def       a__			(						self	,  _a	,  _a	,  _a       )		->							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)"""       )

           _A							:  Optional[Any]    =		FillMaskPipeline(model=_a	,  tokenizer=_a       )
           _A							:  Tuple    =		[
               F'''This is another {tokenizer.mask_token} test''',
           ]
           return fill_masker, examples

     def       a__			(						self	,  _a	,  _a       )		->							Dict:
           _A							:  Dict    =		fill_masker.tokenizer
           _A							:  List[str]    =		fill_masker.model

           _A							:  List[str]    =		fill_masker(
               F'''This is a {tokenizer.mask_token}'''	,  )
           self.assertEqual(
               _a	,  [
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
               ]	,  )

           _A							:  Optional[Any]    =		fill_masker([F'''This is a {tokenizer.mask_token}''']       )
           self.assertEqual(
               _a	,  [
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
               ]	,  )

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

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

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

     def       a__			(						self	,  _a	,  _a       )		->							List[str]:
           _A							:  int    =		tokenizer.get_vocab()
           _A							:  str    =		sorted(vocab.keys()       )[:2]
           # Pipeline argument
           _A							:  Tuple    =		FillMaskPipeline(model=_a	,  tokenizer=_a	,  targets=_a       )
           _A							:  Optional[int]    =		fill_masker(F'''This is a {tokenizer.mask_token}'''       )
           self.assertEqual(
               _a	,  [
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
               ]	,  )
           _A							:  List[str]    =		{vocab[el] for el in targets}
           self.assertEqual({el["""token"""] for el in outputs}	,  _a       )
           _A							:  Union[str, Any]    =		[tokenizer.decode([x]       ) for x in target_ids]
           self.assertEqual({el["""token_str"""] for el in outputs}	,  set(_a       )       )

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

           # Score equivalence
           _A							:  int    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  targets=_a       )
           _A							:  Optional[int]    =		[top_mask["""token_str"""] for top_mask in outputs]
           _A							:  Union[str, Any]    =		[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(_a       ) == set(_a       ):
                 _A							:  Tuple    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  targets=_a       )
                 _A							:  Union[str, Any]    =		[top_mask["""score"""] for top_mask in unmasked_targets]
                 self.assertEqual(nested_simplify(_a       )	,  nested_simplify(_a       )       )

           # Raises with invalid
           with self.assertRaises(_a       ):
                 _A							:  str    =		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(_a       ):
                       _A							:  Optional[Any]    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  targets=[""""""]       )
                 with self.assertRaises(_a       ):
                       _A							:  int    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  targets=""""""       )

     def       a__			(						self	,  _a	,  _a       )		->							Optional[Any]:
           _A							:  str    =		FillMaskPipeline(model=_a	,  tokenizer=_a	,  top_k=2       )
           _A							:  str    =		fill_masker(F'''This is a {tokenizer.mask_token}'''       )
           self.assertEqual(
               _a	,  [
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
               ]	,  )

           _A							:  Union[str, Any]    =		FillMaskPipeline(model=_a	,  tokenizer=_a       )
           _A							:  Union[str, Any]    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  top_k=2       )
           self.assertEqual(
               _a	,  [
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
               ]	,  )
           self.assertEqual(nested_simplify(_a       )	,  nested_simplify(_a       )       )

     def       a__			(						self	,  _a	,  _a       )		->							List[Any]:
           _A							:  Union[str, Any]    =		tokenizer.get_vocab()
           _A							:  int    =		FillMaskPipeline(model=_a	,  tokenizer=_a       )

           # top_k=2, ntargets=3
           _A							:  List[str]    =		sorted(vocab.keys()       )[:3]
           _A							:  Tuple    =		fill_masker(F'''This is a {tokenizer.mask_token}'''	,  top_k=2	,  targets=_a       )

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

     def       a__			(						self	,  _a	,  _a       )		->							str:
           _A							:  Optional[int]    =		FillMaskPipeline(model=_a	,  tokenizer=_a       )
           _A							:  List[Any]    =		tokenizer.get_vocab()
           # String duplicates + id duplicates
           _A							:  Optional[Any]    =		sorted(vocab.keys()       )[:3]
           _A							:  Optional[Any]    =		[targets[0], targets[1], targets[0], targets[2], targets[1]]
           _A							:  Union[str, Any]    =		fill_masker(F'''My name is {tokenizer.mask_token}'''	,  targets=_a	,  top_k=10       )

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



     def       a__			(						self	,  _a	,  _a       )		->							Tuple:
           _A							:  Any    =		FillMaskPipeline(model=_a	,  tokenizer=_a       )

           _A							:  Optional[Any]    =		fill_masker(
               F'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''	,  top_k=2       )
           self.assertEqual(
               _a	,  [
                   [
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   ],
                   [
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   ],
                   [
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                       {"""sequence""": ANY(_a       ), """score""": ANY(_a       ), """token""": ANY(_a       ), """token_str""": ANY(_a       )},
                   ],
               ]	,  )

