


"""simple docstring"""


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      a__ (				__lowercase     ,			__lowercase     ,			__lowercase     ,			__lowercase     ,			__lowercase   )	->	List[str]:
				# Load configuration defined in the metadata file
				with open(__lowercase   ) as metadata_file:
								_A					  =			json.load(__lowercase   )
				_A					  =			LukeConfig(use_entity_aware_attention=__lowercase     ,			**metadata["model_config"]   )

				# Load in the weights from the checkpoint_path
				_A					  =			torch.load(__lowercase     ,			map_location="cpu"   )

				# Load the entity vocab file
				_A					  =			load_entity_vocab(__lowercase   )

				_A					  =			RobertaTokenizer.from_pretrained(metadata["model_config"]["bert_model_name"]   )

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

				_A					  =			LukeTokenizer.from_pretrained(__lowercase   )

				# Initialize the embeddings of the special tokens
				_A					  =			state_dict["embeddings.word_embeddings.weight"]
				_A					  =			word_emb[tokenizer.convert_tokens_to_ids(["@"]   )[0]].unsqueeze(0   )
				_A					  =			word_emb[tokenizer.convert_tokens_to_ids(["#"]   )[0]].unsqueeze(0   )
				_A					  =			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"]:
												_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]"]]

				_A					  =			LukeModel(config=__lowercase   ).eval()

				_A  ,		_A					  =			model.load_state_dict(__lowercase     ,			strict=__lowercase   )
				if not (len(__lowercase   ) == 1 and missing_keys[0] == "embeddings.position_ids"):
								raise ValueError(f"""Missing keys {', '.join(__lowercase   )}. 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
				_A					  =			LukeTokenizer.from_pretrained(__lowercase     ,			task="entity_classification"   )

				_A					  =			(
				    "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 ."
				)
				_A					  =			(39, 42)
				_A					  =			tokenizer(__lowercase     ,			entity_spans=[span]     ,			add_prefix_space=__lowercase     ,			return_tensors="pt"   )

				_A					  =			model(**__lowercase   )

				# Verify word hidden states
				if model_size == "large":
								_A					  =			torch.Size((1, 42, 1024)   )
								_A					  =			torch.tensor(
								    [[0.0_133, 0.0_865, 0.0_095], [0.3_093, -0.2_576, -0.7_418], [-0.1_720, -0.2_117, -0.2_869]]   )
				else:  # base
								_A					  =			torch.Size((1, 42, 768)   )
								_A					  =			torch.tensor([[0.0_037, 0.1_368, -0.0_091], [0.1_099, 0.3_329, -0.1_095], [0.0_765, 0.5_335, 0.1_179]]   )

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

				# Verify entity hidden states
				if model_size == "large":
								_A					  =			torch.Size((1, 1, 1024)   )
								_A					  =			torch.tensor([[0.0_466, -0.0_106, -0.0_179]]   )
				else:  # base
								_A					  =			torch.Size((1, 1, 768)   )
								_A					  =			torch.tensor([[0.1_457, 0.1_044, 0.0_174]]   )

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

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






def      a__ (				__lowercase   )	->	List[Any]:
				_A					  =			{}
				with open(__lowercase     ,			"r"     ,			encoding="utf-8"   ) as f:
								for index, line in enumerate(__lowercase   ):
												_A  ,		_A					  =			line.rstrip().split("\t"   )
												_A					  =			index

				return entity_vocab


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






"""simple docstring"""


from __future__ import annotations






def      a__ (				__lowercase     ,			__lowercase   )	->	float:
				_A					  =			sorted(numsa + numsa   )
				_A  ,		_A					  =			divmod(len(__lowercase   )     ,			2   )
				if mod == 1:
								return all_numbers[div]
				else:
								return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		a_       							=    [float(x) for x in input("Enter the elements of first array: ").split()]
		a_       							=    [float(x) for x in input("Enter the elements of second array: ").split()]
		print(f'''The median of two arrays is: {median_of_two_arrays(array_a, array_a)}''')