

'''simple docstring'''







from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          AutoTokenizer,
          TFAutoModelForCausalLM,
          TFAutoModelForSeqaSeqLM,
          TFAutoModelForSpeechSeqaSeq,
          TFAutoModelForVisionaSeq,
          TFBartForConditionalGeneration,
          TFLogitsProcessorList,
          TFMinLengthLogitsProcessor,
          tf_top_k_top_p_filtering,
      )

if is_tensorflow_text_available():
      import tensorflow_text as text


@require_tf
class 					A__      (      unittest.TestCase			):



    def 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           A_						=      tf.convert_to_tensor(
               [
                   [
                       8.2220991,  # 3rd highest value; idx. 0
                       -0.5620044,
                       5.23229752,
                       4.0386393,
                       -6.8798378,
                       -0.54785802,
                       -3.2012153,
                       2.92777176,
                       1.88171953,
                       7.35341276,  # 5th highest value; idx. 9
                       8.43207833,  # 2nd highest value; idx. 10
                       -9.85711836,
                       -5.96209236,
                       -1.13039161,
                       -7.1115294,
                       -0.8369633,
                       -5.3186408,
                       7.06427407,
                       0.81369344,
                       -0.82023817,
                       -5.9179796,
                       0.58813443,
                       -6.99778438,
                       4.71551189,
                       -0.18771637,
                       7.44020759,  # 4th highest value; idx. 25
                       9.38450987,  # 1st highest value; idx. 26
                       2.12662941,
                       -9.32562038,
                       2.35652522,
                   ],  # cummulative prob of 5 highest values <= 0.6
                   [
                       0.58425518,
                       4.53139238,
                       -5.57510464,
                       -6.28030699,
                       -7.19529503,
                       -4.02122551,
                       1.39337037,
                       -6.06707057,
                       1.59480517,
                       -9.643119,
                       0.03907799,
                       0.67231762,
                       -8.88206726,
                       6.27115922,  # 4th highest value; idx. 13
                       2.28520723,
                       4.82767506,
                       4.30421368,
                       8.8275313,  # 2nd highest value; idx. 17
                       5.44029958,  # 5th highest value; idx. 18
                       -4.4735794,
                       7.38579536,  # 3rd highest value; idx. 20
                       -2.91051663,
                       2.61946077,
                       -2.5674762,
                       -9.48959302,
                       -4.02922645,
                       -1.35416918,
                       9.67702323,  # 1st highest value; idx. 27
                       -5.89478553,
                       1.85370467,
                   ],  # cummulative prob of 5 highest values <= 0.6
               ]		,				dtype=tf.floataa		,				)

           A_						=      tf.convert_to_tensor(
               [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]		,				dtype=tf.intaa		,				)  # expected non filtered idx as noted above

           A_						=      tf.convert_to_tensor(
               [8.222099, 7.3534126, 8.432078, 7.4402075, 9.38451, 6.271159, 8.827531, 5.4402995, 7.3857956, 9.677023]		,				dtype=tf.floataa		,				)  # expected non filtered values as noted above

           A_						=      tf_top_k_top_p_filtering(UpperCamelCase__		,				top_k=10		,				top_p=0.6		,				min_tokens_to_keep=4       )

           A_						=      output[output != -float("""inf"""       )]
           A_						=      tf.cast(
               tf.where(tf.not_equal(UpperCamelCase__		,				tf.constant(-float("""inf"""       )		,				dtype=tf.floataa       )       )       )		,				dtype=tf.intaa		,				)

           tf.debugging.assert_near(UpperCamelCase__		,				UpperCamelCase__		,				rtol=1e-1_2       )
           tf.debugging.assert_equal(UpperCamelCase__		,				UpperCamelCase__       )


@require_tf
class 					A__      (      unittest.TestCase						,						_snake_case			):
    # setting framework_dependent_parameters needs to be gated, just like its contents' imports
    if is_tf_available():
        lowercase						=		{
            "AutoModelForCausalLM": TFAutoModelForCausalLM,
            "AutoModelForSpeechSeq2Seq": TFAutoModelForSpeechSeqaSeq,
            "AutoModelForSeq2SeqLM": TFAutoModelForSeqaSeqLM,
            "AutoModelForVision2Seq": TFAutoModelForVisionaSeq,
            "LogitsProcessorList": TFLogitsProcessorList,
            "MinLengthLogitsProcessor": TFMinLengthLogitsProcessor,
            "create_tensor_fn": tf.convert_to_tensor,
            "floats_tensor": floats_tensor,
            "return_tensors": "tf",
        }



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





           '''simple docstring'''
           # TF-only test: tf.saved_model export
           A_						=      TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )
           A_						=      2
           A_						=      2


           class 					A__      (      tf.Module			):



               def __init__(					self		,				UpperCamelCase__       )						->      List[Any]:





                      '''simple docstring'''
                      super(UpperCamelCase__		,				self       ).__init__()
                      A_						=      model







               @tf.function(
                   input_signature=(
                       tf.TensorSpec((None, input_length)		,				tf.intaa		,				name="""input_ids"""       ),
                       tf.TensorSpec((None, input_length)		,				tf.intaa		,				name="""attention_mask"""       ),
                   )		,				jit_compile=UpperCamelCase__		,				)
               def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      List[Any]:





                      '''simple docstring'''
                      A_						=      self.model.generate(
                          input_ids=UpperCamelCase__		,				attention_mask=UpperCamelCase__		,				max_new_tokens=UpperCamelCase__		,				return_dict_in_generate=UpperCamelCase__		,				)
                      return {"sequences": outputs["sequences"]}

           A_						=      [[2, 0], [102, 103]]
           A_						=      [[1, 0], [1, 1]]
           A_						=      DummyModel(model=UpperCamelCase__       )
           with tempfile.TemporaryDirectory() as tmp_dir:
                  tf.saved_model.save(UpperCamelCase__		,				UpperCamelCase__		,				signatures={"""serving_default""": dummy_model.serving}       )
                  A_						=      tf.saved_model.load(UpperCamelCase__       ).signatures["""serving_default"""]
                  for batch_size in range(1		,				len(UpperCamelCase__       ) + 1       ):
                         A_						=      {
                             """input_ids""": tf.constant(dummy_input_ids[:batch_size]       ),
                             """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]       ),
                         }
                         A_						=      serving_func(**UpperCamelCase__       )["""sequences"""]
                         A_						=      test_model.generate(**UpperCamelCase__		,				max_new_tokens=UpperCamelCase__       )
                         tf.debugging.assert_equal(UpperCamelCase__		,				UpperCamelCase__       )



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





           '''simple docstring'''
           # TF-only test: tf.saved_model export
           A_						=      TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )
           A_						=      1
           A_						=      2


           class 					A__      (      tf.Module			):



               def __init__(					self		,				UpperCamelCase__       )						->      Any:





                      '''simple docstring'''
                      super(UpperCamelCase__		,				self       ).__init__()
                      A_						=      model







               @tf.function(
                   input_signature=(
                       tf.TensorSpec((batch_size, None)		,				tf.intaa		,				name="""input_ids"""       ),
                       tf.TensorSpec((batch_size, None)		,				tf.intaa		,				name="""attention_mask"""       ),
                   )		,				jit_compile=UpperCamelCase__		,				)
               def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      str:





                      '''simple docstring'''
                      A_						=      self.model.generate(
                          input_ids=UpperCamelCase__		,				attention_mask=UpperCamelCase__		,				max_new_tokens=UpperCamelCase__		,				return_dict_in_generate=UpperCamelCase__		,				)
                      return {"sequences": outputs["sequences"]}

           A_						=      [[2], [102, 103]]
           A_						=      [[1], [1, 1]]
           A_						=      DummyModel(model=UpperCamelCase__       )
           with tempfile.TemporaryDirectory() as tmp_dir:
                  tf.saved_model.save(UpperCamelCase__		,				UpperCamelCase__		,				signatures={"""serving_default""": dummy_model.serving}       )
                  A_						=      tf.saved_model.load(UpperCamelCase__       ).signatures["""serving_default"""]
                  for input_row in range(len(UpperCamelCase__       )       ):
                         A_						=      {
                             """input_ids""": tf.constant([dummy_input_ids[input_row]]       ),
                             """attention_mask""": tf.constant([dummy_attention_masks[input_row]]       ),
                         }
                         A_						=      serving_func(**UpperCamelCase__       )["""sequences"""]
                         A_						=      test_model.generate(**UpperCamelCase__		,				max_new_tokens=UpperCamelCase__       )
                         tf.debugging.assert_equal(UpperCamelCase__		,				UpperCamelCase__       )



    @slow
    @require_tensorflow_text
    def 					snake_case_			(					self       )						->      List[Any]:





           '''simple docstring'''
           # TF-only test: tf.saved_model export
           with tempfile.TemporaryDirectory() as tmp_dir:
                  # file needed to load the TF tokenizer
                  hf_hub_download(repo_id="""google/flan-t5-small"""		,				filename="""spiece.model"""		,				local_dir=UpperCamelCase__       )


                  class 					A__      (      tf.keras.layers.Layer			):



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





                             '''simple docstring'''
                             super().__init__()
                             A_						=      text.SentencepieceTokenizer(
                                 model=tf.io.gfile.GFile(os.path.join(UpperCamelCase__		,				"""spiece.model"""       )		,				"""rb"""       ).read()       )
                             A_						=      TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""       )







                      def 					snake_case_			(					self		,				UpperCamelCase__		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[Any]:





                             '''simple docstring'''
                             A_						=      self.tokenizer.tokenize(UpperCamelCase__       )
                             A_					,			A_						=      text.pad_model_inputs(
                                 UpperCamelCase__		,				max_seq_length=64		,				pad_value=self.model.config.pad_token_id       )
                             A_						=      self.model.generate(input_ids=UpperCamelCase__		,				attention_mask=UpperCamelCase__       )
                             return self.tokenizer.detokenize(UpperCamelCase__       )

                  A_						=      CompleteSentenceTransformer()
                  A_						=      tf.keras.layers.Input(shape=(1,)		,				dtype=tf.string		,				name="""inputs"""       )
                  A_						=      complete_model(UpperCamelCase__       )
                  A_						=      tf.keras.Model(UpperCamelCase__		,				UpperCamelCase__       )
                  keras_model.save(UpperCamelCase__       )



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           # Has PT equivalent: this test relies on random sampling
           A_						=      {
               """do_sample""": True,
               """num_beams""": 1,
               """top_p""": 0.7,
               """top_k""": 10,
               """temperature""": 0.7,
           }
           A_						=      14

           A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )
           A_						=      """Hello, my dog is cute and"""
           A_						=      tokenizer(UpperCamelCase__		,				return_tensors="""tf"""       )
           A_						=      TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )

           A_						=      638
           # forces the generation to happen on CPU, to avoid GPU-related quirks
           with tf.device(""":/CPU:0"""       ):
                  tf.random.set_seed(0       )
                  A_						=      model.generate(**UpperCamelCase__		,				eos_token_id=UpperCamelCase__		,				**UpperCamelCase__       )
           self.assertTrue(expectation == len(generated_tokens[0]       )       )

           A_						=      [638, 198]
           with tf.device(""":/CPU:0"""       ):
                  tf.random.set_seed(0       )
                  A_						=      model.generate(**UpperCamelCase__		,				eos_token_id=UpperCamelCase__		,				**UpperCamelCase__       )
           self.assertTrue(expectation == len(generated_tokens[0]       )       )







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





           '''simple docstring'''
           # Has PT equivalent: ample use of framework-specific code
           A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""       )
           A_						=      """Hugging Face is a technology company based in New York and Paris."""
           A_						=      bart_tokenizer(UpperCamelCase__		,				return_tensors="""tf"""       ).input_ids
           A_						=      TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""       )
           A_						=      bart_model.generate(UpperCamelCase__       ).numpy()


           class 					A__      (      _snake_case			):



               def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__=None		,				**UpperCamelCase__       )						->      Any:





                      '''simple docstring'''
                      return super().call(UpperCamelCase__		,				**UpperCamelCase__       )

           A_						=      FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""       )
           A_						=      bart_model.generate(UpperCamelCase__		,				foo="""bar"""       ).numpy()
           self.assertTrue(np.array_equal(UpperCamelCase__		,				UpperCamelCase__       )       )


           class 					A__      (      bart_model.model.encoder.__class__			):



               def 					snake_case_			(					self		,				UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





                      '''simple docstring'''
                      return super().call(UpperCamelCase__		,				**UpperCamelCase__       )

           A_						=      FakeEncoder(bart_model.config		,				bart_model.model.shared       )
           A_						=      fake_encoder

           # Normal generation still works (the output will be different because the encoder weights are different)
           A_						=      bart_model.generate(UpperCamelCase__       ).numpy()
           with self.assertRaises(UpperCamelCase__       ):
                  # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
                  bart_model.generate(UpperCamelCase__		,				foo="""bar"""       )



'''simple docstring'''







import argparse
import json
import os
from collections import OrderedDict

import torch

from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer
from transformers.tokenization_utils_base import AddedToken
@torch.no_grad()
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)			->			List[Any]:
       # Load configuration defined in the metadata file
       with open(UpperCAmelCase__				) as metadata_file:
              A_						=      json.load(UpperCAmelCase__				)
       A_						=      LukeConfig(use_entity_aware_attention=UpperCAmelCase__,       **metadata["""model_config"""]				)

       # Load in the weights from the checkpoint_path
       A_						=      torch.load(UpperCAmelCase__,       map_location="""cpu"""				)["""module"""]

       # Load the entity vocab file
       A_						=      load_original_entity_vocab(UpperCAmelCase__				)
       # add an entry for [MASK2]
       A_						=      max(entity_vocab.values()				) + 1
       config.entity_vocab_size += 1

       A_						=      XLMRobertaTokenizer.from_pretrained(metadata["""model_config"""]["""bert_model_name"""]				)

       # Add special tokens to the token vocabulary for downstream tasks
       A_						=      AddedToken("""<ent>""",       lstrip=UpperCAmelCase__,       rstrip=UpperCAmelCase__				)
       A_						=      AddedToken("""<ent2>""",       lstrip=UpperCAmelCase__,       rstrip=UpperCAmelCase__				)
       tokenizer.add_special_tokens({"""additional_special_tokens""": [entity_token_a, entity_token_a]}				)
       config.vocab_size += 2

       print(F'''Saving tokenizer to {pytorch_dump_folder_path}'''				)
       tokenizer.save_pretrained(UpperCAmelCase__				)
       with open(os.path.join(UpperCAmelCase__,       """tokenizer_config.json"""				),       """r"""				) as f:
              A_						=      json.load(UpperCAmelCase__				)
       A_						=      """MLukeTokenizer"""
       with open(os.path.join(UpperCAmelCase__,       """tokenizer_config.json"""				),       """w"""				) as f:
              json.dump(UpperCAmelCase__,       UpperCAmelCase__				)

       with open(os.path.join(UpperCAmelCase__,       MLukeTokenizer.vocab_files_names["""entity_vocab_file"""]				),       """w"""				) as f:
              json.dump(UpperCAmelCase__,       UpperCAmelCase__				)

       A_						=      MLukeTokenizer.from_pretrained(UpperCAmelCase__				)

       # Initialize the embeddings of the special tokens
       A_						=      tokenizer.convert_tokens_to_ids(["""@"""]				)[0]
       A_						=      tokenizer.convert_tokens_to_ids(["""#"""]				)[0]

       A_						=      state_dict["""embeddings.word_embeddings.weight"""]
       A_						=      word_emb[ent_init_index].unsqueeze(0				)
       A_						=      word_emb[enta_init_index].unsqueeze(0				)
       A_						=      torch.cat([word_emb, ent_emb, enta_emb]				)
       # add special tokens for 'entity_predictions.bias'
       for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]:
              A_						=      state_dict[bias_name]
              A_						=      decoder_bias[ent_init_index].unsqueeze(0				)
              A_						=      decoder_bias[enta_init_index].unsqueeze(0				)
              A_						=      torch.cat([decoder_bias, ent_decoder_bias, enta_decoder_bias]				)

       # Initialize the query layers of the entity-aware self-attention mechanism
       for layer_index in range(config.num_hidden_layers				):
              for matrix_name in ["query.weight", "query.bias"]:
                     A_						=      F'''encoder.layer.{layer_index}.attention.self.'''
                     A_						=      state_dict[prefix + matrix_name]
                     A_						=      state_dict[prefix + matrix_name]
                     A_						=      state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
       A_						=      state_dict["""entity_embeddings.entity_embeddings.weight"""]
       A_						=      entity_emb[entity_vocab["""[MASK]"""]].unsqueeze(0				)
       A_						=      torch.cat([entity_emb, entity_mask_emb]				)
       # add [MASK2] for 'entity_predictions.bias'
       A_						=      state_dict["""entity_predictions.bias"""]
       A_						=      entity_prediction_bias[entity_vocab["""[MASK]"""]].unsqueeze(0				)
       A_						=      torch.cat([entity_prediction_bias, entity_mask_bias]				)

       A_						=      LukeForMaskedLM(config=UpperCAmelCase__				).eval()

       state_dict.pop("""entity_predictions.decoder.weight"""				)
       state_dict.pop("""lm_head.decoder.weight"""				)
       state_dict.pop("""lm_head.decoder.bias"""				)
       A_						=      OrderedDict()
       for key, value in state_dict.items():
              if not (key.startswith("""lm_head"""				) or key.startswith("""entity_predictions"""				)):
                     A_						=      state_dict[key]
              else:
                     A_						=      state_dict[key]

       A_					,			A_						=      model.load_state_dict(UpperCAmelCase__,       strict=UpperCAmelCase__				)

       if set(UpperCAmelCase__				) != {"luke.embeddings.position_ids"}:
              raise ValueError(F'''Unexpected unexpected_keys: {unexpected_keys}'''				)
       if set(UpperCAmelCase__				) != {
           "lm_head.decoder.weight",
           "lm_head.decoder.bias",
           "entity_predictions.decoder.weight",
       }:
              raise ValueError(F'''Unexpected missing_keys: {missing_keys}'''				)

       model.tie_weights()
       assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all()
       assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all()

       # Check outputs
       A_						=      MLukeTokenizer.from_pretrained(UpperCAmelCase__,       task="""entity_classification"""				)

       A_						=      """ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan)."""
       A_						=      (0, 9)
       A_						=      tokenizer(UpperCAmelCase__,       entity_spans=[span],       return_tensors="""pt"""				)

       A_						=      model(**UpperCAmelCase__				)

       # Verify word hidden states
       if model_size == "large":
              raise NotImplementedError
       else:  # base
              A_						=      torch.Size((1, 33, 7_68)				)
              A_						=      torch.tensor([[0.0_892, 0.0_596, -0.2_819], [0.0_134, 0.1_199, 0.0_573], [-0.0_169, 0.0_927, 0.0_644]]				)

       if not (outputs.last_hidden_state.shape == expected_shape):
              raise ValueError(
                  F'''Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}'''				)
       if not torch.allclose(outputs.last_hidden_state[0, :3, :3],       UpperCAmelCase__,       atol=1e-4				):
              raise ValueError

       # Verify entity hidden states
       if model_size == "large":
              raise NotImplementedError
       else:  # base
              A_						=      torch.Size((1, 1, 7_68)				)
              A_						=      torch.tensor([[-0.1_482, 0.0_609, 0.0_322]]				)

       if not (outputs.entity_last_hidden_state.shape == expected_shape):
              raise ValueError(
                  F'''Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is'''
                  F''' {expected_shape}'''				)
       if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3],       UpperCAmelCase__,       atol=1e-4				):
              raise ValueError

       # Verify masked word/entity prediction
       A_						=      MLukeTokenizer.from_pretrained(UpperCAmelCase__				)
       A_						=      """Tokyo is the capital of <mask>."""
       A_						=      (24, 30)
       A_						=      tokenizer(UpperCAmelCase__,       entity_spans=[span],       return_tensors="""pt"""				)

       A_						=      model(**UpperCAmelCase__				)

       A_						=      encoding["""input_ids"""][0].tolist()
       A_						=      input_ids.index(tokenizer.convert_tokens_to_ids("""<mask>"""				)				)
       A_						=      outputs.logits[0][mask_position_id].argmax(dim=-1				)
       assert "Japan" == tokenizer.decode(UpperCAmelCase__				)

       A_						=      outputs.entity_logits[0][0].argmax().item()
       A_						=      [
           entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id
       ]
       assert [e for e in multilingual_predicted_entities if e.startswith("""en:"""				)][0] == "en:Japan"

       # Finally, save our PyTorch model and tokenizer
       print("""Saving PyTorch model to {}""".format(UpperCAmelCase__				)				)
       model.save_pretrained(UpperCAmelCase__				)
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       A_						=      ["""[MASK]""", """[PAD]""", """[UNK]"""]

       A_						=      [json.loads(UpperCAmelCase__				) for line in open(UpperCAmelCase__				)]

       A_						=      {}
       for entry in data:
              A_						=      entry["""id"""]
              for entity_name, language in entry["entities"]:
                     if entity_name in SPECIAL_TOKENS:
                            A_						=      entity_id
                            break
                     A_						=      F'''{language}:{entity_name}'''
                     A_						=      entity_id
       return new_mapping


if __name__ == "__main__":
      __lowerCamelCase		       =    argparse.ArgumentParser()
      # Required parameters
      parser.add_argument('''--checkpoint_path''', type=str, help='''Path to a pytorch_model.bin file.''')
      parser.add_argument(
          '''--metadata_path''', default=None, type=str, help='''Path to a metadata.json file, defining the configuration.'''
      )
      parser.add_argument(
          '''--entity_vocab_path''',
          default=None,
          type=str,
          help='''Path to an entity_vocab.tsv file, containing the entity vocabulary.''',
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to where to dump the output PyTorch model.'''
      )
      parser.add_argument(
          '''--model_size''', default='''base''', type=str, choices=['''base''', '''large'''], help='''Size of the model to be converted.'''
      )
      __lowerCamelCase		       =    parser.parse_args()
      convert_luke_checkpoint(
          args.checkpoint_path,
          args.metadata_path,
          args.entity_vocab_path,
          args.pytorch_dump_folder_path,
          args.model_size,
      )
