





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




   """simple docstring"""



   __A       :    int	  =  MODEL_FOR_MASKED_LM_MAPPING
   __A       :    int	  =  TF_MODEL_FOR_MASKED_LM_MAPPING

   def 							__lowercase		( self)      ->						Dict:







          '''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 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     List[Any]			=    pipeline(task='fill-mask' ,  model='sshleifer/tiny-distilroberta-base' ,  top_k=2 ,  framework='tf')
          a__						:     int			=    unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(lowercase ,  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__						:     List[Any]			=    unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(lowercase ,  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[Any]			=    unmasker('My name is <mask>' ,  targets=[' Patrick', ' Clara', ' Teven'] ,  top_k=3)
          self.assertEqual(
              nested_simplify(lowercase ,  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 							__lowercase		( self)      ->						List[Any]:







          '''simple docstring'''

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

          a__						:     int			=    unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(lowercase ,  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__						:     List[str]			=    unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(lowercase ,  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__						:     int			=    unmasker('My name is <mask>' ,  targets=[' Patrick', ' Clara', ' Teven'] ,  top_k=3)
          self.assertEqual(
              nested_simplify(lowercase ,  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__						:     int			=    unmasker('My name is <mask> <mask>' ,  top_k=2)

          self.assertEqual(
              nested_simplify(lowercase ,  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 							__lowercase		( self)      ->						Optional[int]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    pipeline('fill-mask' ,  model='hf-internal-testing/tiny-random-distilbert' ,  device=0 ,  framework='pt')

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

          a__						:     Tuple			=    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(lowercase ,  lowercase)

   @slow
   @require_torch
   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     List[Any]			=    pipeline(task='fill-mask' ,  model='distilroberta-base' ,  top_k=2 ,  framework='pt')
          self.run_large_test(lowercase)

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







          '''simple docstring'''

          a__						:     List[str]			=    pipeline(task='fill-mask' ,  model='distilroberta-base' ,  top_k=2 ,  framework='tf')
          self.run_large_test(lowercase)

   def 							__lowercase		( self ,  lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     List[str]			=    unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(lowercase) ,  [
                  {'sequence': 'My name is John', 'score': 0.0_08, 'token': 610, 'token_str': ' John'},
                  {'sequence': 'My name is Chris', 'score': 0.0_07, 'token': 1573, 'token_str': ' Chris'},
              ] ,  )
          a__						:     Optional[Any]			=    unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(lowercase) ,  [
                  {
                      'sequence': 'The largest city in France is Paris',
                      'score': 0.2_51,
                      'token': 2201,
                      'token_str': ' Paris',
                  },
                  {
                      'sequence': 'The largest city in France is Lyon',
                      'score': 0.2_14,
                      'token': 1_2790,
                      'token_str': ' Lyon',
                  },
              ] ,  )

          a__						:     Tuple			=    unmasker('My name is <mask>' ,  targets=[' Patrick', ' Clara', ' Teven'] ,  top_k=3)
          self.assertEqual(
              nested_simplify(lowercase) ,  [
                  {'sequence': 'My name is Patrick', 'score': 0.0_05, 'token': 3499, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Clara', 'score': 0.0_00, 'token': 1_3606, 'token_str': ' Clara'},
                  {'sequence': 'My name is Te', 'score': 0.0_00, 'token': 2941, 'token_str': ' Te'},
              ] ,  )

   @require_torch
   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     Any			=    pipeline(task='fill-mask' ,  model='sshleifer/tiny-distilroberta-base' ,  framework='pt')
          a__						:     Union[str, Any]			=    None
          a__						:     str			=    None
          self.run_pipeline_test(lowercase ,  [])

   @require_tf
   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     List[Any]			=    pipeline(task='fill-mask' ,  model='sshleifer/tiny-distilroberta-base' ,  framework='tf')
          a__						:     Optional[Any]			=    None
          a__						:     Any			=    None
          self.run_pipeline_test(lowercase ,  [])

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						Union[str, 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)')

          a__						:     Dict			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase)
          a__						:     str			=    [
              F'This is another {tokenizer.mask_token} test',
          ]
          return fill_masker, examples

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     List[str]			=    fill_masker.tokenizer
          a__						:     Optional[int]			=    fill_masker.model

          a__						:     Optional[int]			=    fill_masker(
              F'This is a {tokenizer.mask_token}' ,  )
          self.assertEqual(
              lowercase ,  [
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
              ] ,  )

          a__						:     Tuple			=    fill_masker([F'This is a {tokenizer.mask_token}'])
          self.assertEqual(
              lowercase ,  [
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
              ] ,  )

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

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

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

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						str:







          '''simple docstring'''

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

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

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

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

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Tuple:







          '''simple docstring'''

          a__						:     str			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase ,  top_k=2)
          a__						:     Tuple			=    fill_masker(F'This is a {tokenizer.mask_token}')
          self.assertEqual(
              lowercase ,  [
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
              ] ,  )

          a__						:     Optional[Any]			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase)
          a__						:     Optional[Any]			=    fill_masker(F'This is a {tokenizer.mask_token}' ,  top_k=2)
          self.assertEqual(
              lowercase ,  [
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
                  {'sequence': ANY(lowercase), 'score': ANY(lowercase), 'token': ANY(lowercase), 'token_str': ANY(lowercase)},
              ] ,  )
          self.assertEqual(nested_simplify(lowercase) ,  nested_simplify(lowercase))

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Tuple:







          '''simple docstring'''

          a__						:     List[str]			=    tokenizer.get_vocab()
          a__						:     Tuple			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase)

          # top_k=2, ntargets=3
          a__						:     int			=    sorted(vocab.keys())[:3]
          a__						:     Optional[int]			=    fill_masker(F'This is a {tokenizer.mask_token}' ,  top_k=2 ,  targets=lowercase)

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

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Optional[Any]			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase)
          a__						:     int			=    tokenizer.get_vocab()
          # String duplicates + id duplicates
          a__						:     int			=    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=lowercase ,  top_k=10)

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

   def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Tuple:







          '''simple docstring'''

          a__						:     Dict			=    FillMaskPipeline(model=lowercase ,  tokenizer=lowercase)

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









import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()



def A_     (		A__		,				A__		,				A__    )  ->		Any:
       # Construct model
       if gpta_config_file == "":
              a__						:     Optional[int]			=    GPTaConfig()
       else:
              a__						:     List[str]			=    GPTaConfig.from_json_file(A__    )
       a__						:     List[str]			=    GPTaModel(A__    )

       # Load weights from numpy
       load_tf_weights_in_gpta(A__		,				A__		,				A__    )

       # Save pytorch-model
       a__						:     Optional[Any]			=    pytorch_dump_folder_path + '/' + WEIGHTS_NAME
       a__						:     Any			=    pytorch_dump_folder_path + '/' + CONFIG_NAME
       print(F'Save PyTorch model to {pytorch_weights_dump_path}'    )
       torch.save(model.state_dict()		,				A__    )
       print(F'Save configuration file to {pytorch_config_dump_path}'    )
       with open(A__		,				'w'		,				encoding='utf-8'    ) as f:
              f.write(config.to_json_string()    )


if __name__ == "__main__":
    lowercase				:	Dict      						=  argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--gpt2_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--gpt2_config_file""",
        default="""""",
        type=str,
        help=(
            """An optional config json file corresponding to the pre-trained OpenAI model. \n"""
            """This specifies the model architecture."""
        ),
    )
    lowercase				:	int      						=  parser.parse_args()
    convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)


