






import argparse
import json
import os

import torch

from transformers import LukeConfig, LukeModel, LukeTokenizer, RobertaTokenizer
from transformers.tokenization_utils_base import AddedToken





@torch.no_grad()
def 						__UpperCAmelCase			(     a_							,     a_							,     a_							,     a_							,     a_):
							# Load configuration defined in the metadata file
							with open(a_) as metadata_file:
														snake_case_				=							json.load(a_)
							snake_case_				=							LukeConfig(use_entity_aware_attention=a_							,     **metadata['model_config'])

							# Load in the weights from the checkpoint_path
							snake_case_				=							torch.load(a_							,     map_location='cpu')

							# Load the entity vocab file
							snake_case_				=							load_entity_vocab(a_)

							snake_case_				=							RobertaTokenizer.from_pretrained(metadata['model_config']['bert_model_name'])

							# Add special tokens to the token vocabulary for downstream tasks
							snake_case_				=							AddedToken('<ent>'							,     lstrip=a_							,     rstrip=a_)
							snake_case_				=							AddedToken('<ent2>'							,     lstrip=a_							,     rstrip=a_)
							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(a_)
							with open(os.path.join(a_							,     LukeTokenizer.vocab_files_names['entity_vocab_file'])							,     'w') as f:
														json.dump(a_							,     a_)

							snake_case_				=							LukeTokenizer.from_pretrained(a_)

							# Initialize the embeddings of the special tokens
							snake_case_				=							state_dict['embeddings.word_embeddings.weight']
							snake_case_				=							word_emb[tokenizer.convert_tokens_to_ids(['@'])[0]].unsqueeze(0)
							snake_case_				=							word_emb[tokenizer.convert_tokens_to_ids(['#'])[0]].unsqueeze(0)
							snake_case_				=							torch.cat([word_emb, ent_emb, enta_emb])

							# 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"]:
																					snake_case_				=							f'''encoder.layer.{layer_index}.attention.self.'''
																					snake_case_				=							state_dict[prefix + matrix_name]
																					snake_case_				=							state_dict[prefix + matrix_name]
																					snake_case_				=							state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
							snake_case_				=							state_dict['entity_embeddings.entity_embeddings.weight']
							snake_case_				=							entity_emb[entity_vocab['[MASK]']]

							snake_case_				=							LukeModel(config=a_).eval()

							snake_case_				=							model.load_state_dict(a_							,     strict=a_)
							if not (len(a_) == 1 and missing_keys[0] == "embeddings.position_ids"):
														raise ValueError(f'''Missing keys {", ".join(a_)}. Expected only missing embeddings.position_ids''')
							if not (all(key.startswith('entity_predictions') or key.startswith('lm_head') for key in unexpected_keys)):
														raise ValueError(
														    'Unexpected keys'
														    f''' {", ".join([key for key in unexpected_keys if not (key.startswith("entity_predictions") or key.startswith("lm_head"))])}''')

							# Check outputs
							snake_case_				=							LukeTokenizer.from_pretrained(a_							,     task='entity_classification')

							snake_case_				=							(
							    'Top seed Ana Ivanovic said on Thursday she could hardly believe her luck as a fortuitous netcord helped the'
							    ' new world number one avoid a humiliating second- round exit at Wimbledon .'
							)
							snake_case_				=							(39, 42)
							snake_case_				=							tokenizer(a_							,     entity_spans=[span]							,     add_prefix_space=a_							,     return_tensors='pt')

							snake_case_				=							model(**a_)

							# Verify word hidden states
							if model_size == "large":
														snake_case_				=							torch.Size((1, 42, 10_24))
														snake_case_				=							torch.tensor(
														    [[0.01_33, 0.08_65, 0.00_95], [0.30_93, -0.25_76, -0.74_18], [-0.17_20, -0.21_17, -0.28_69]])
							else:  # base
														snake_case_				=							torch.Size((1, 42, 7_68))
														snake_case_				=							torch.tensor([[0.00_37, 0.13_68, -0.00_91], [0.10_99, 0.33_29, -0.10_95], [0.07_65, 0.53_35, 0.11_79]])

							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]							,     a_							,     atol=1E-4):
														raise ValueError

							# Verify entity hidden states
							if model_size == "large":
														snake_case_				=							torch.Size((1, 1, 10_24))
														snake_case_				=							torch.tensor([[0.04_66, -0.01_06, -0.01_79]])
							else:  # base
														snake_case_				=							torch.Size((1, 1, 7_68))
														snake_case_				=							torch.tensor([[0.14_57, 0.10_44, 0.01_74]])

							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]							,     a_							,     atol=1E-4):
														raise ValueError

							# Finally, save our PyTorch model and tokenizer
							print('Saving PyTorch model to {}'.format(a_))
							model.save_pretrained(a_)





def 						__UpperCAmelCase			(     a_):
							snake_case_				=							{}
							with open(a_							,     'r'							,     encoding='utf-8') as f:
														for index, line in enumerate(a_):
																					snake_case_				=							line.rstrip().split('\t')
																					snake_case_				=							index

							return entity_vocab


if __name__ == "__main__":
	lowercase  							=					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."
	)
	lowercase  							=					parser.parse_args()
	convert_luke_checkpoint(
	    args.checkpoint_path,
	    args.metadata_path,
	    args.entity_vocab_path,
	    args.pytorch_dump_folder_path,
	    args.model_size,
	)










import argparse

import torch

from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert
from transformers.utils import logging


logging.set_verbosity_info()
def        lowercase_							(A : str		,					A : List[Any]		,					A : Any      ):
       # Initialise PyTorch model
       snake_case__							:	List[Any]   	=	LxmertConfig.from_json_file(A      )
       print(F'''Building PyTorch model from configuration: {config}'''      )
       snake_case__							:	List[str]   	=	LxmertForPreTraining(A      )

       # Load weights from tf checkpoint
       load_tf_weights_in_lxmert(A		,					A		,					A      )

       # Save pytorch-model
       print(F'''Save PyTorch model to {pytorch_dump_path}'''      )
       torch.save(model.state_dict()		,					A      )


if __name__ == "__main__":
 a_   :Union[str, Any]        =      argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
 )
 parser.add_argument(
     "--config_file",
     default=None,
     type=str,
     required=True,
     help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
 )
 parser.add_argument(
     "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
 )
 a_   :Optional[int]        =      parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)






