






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		(			_A,       _A,       _A,       _A,       _A					):






						"""simple docstring"""







						with open(lowercase_					) as metadata_file:
												__magic_name__     :  List[Any]  		=   json.load(lowercase_					)
						__magic_name__     :  List[Any]  		=   LukeConfig(use_entity_aware_attention=lowercase_,       **metadata["""model_config"""]					)

						# Load in the weights from the checkpoint_path
						__magic_name__     :  Union[str, Any]  		=   torch.load(lowercase_,       map_location="""cpu"""					)["""module"""]

						# Load the entity vocab file
						__magic_name__     :  Dict  		=   load_original_entity_vocab(lowercase_					)
						# add an entry for [MASK2]
						__magic_name__     :  Any  		=   max(entity_vocab.values()					) + 1
						config.entity_vocab_size += 1

						__magic_name__     :  str  		=   XLMRobertaTokenizer.from_pretrained(metadata["""model_config"""]["""bert_model_name"""]					)

						# Add special tokens to the token vocabulary for downstream tasks
						__magic_name__     :  Any  		=   AddedToken("""<ent>""",       lstrip=lowercase_,       rstrip=lowercase_					)
						__magic_name__     :  Optional[Any]  		=   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_,       """tokenizer_config.json"""					),       """r"""					) as f:
												__magic_name__     :  Tuple  		=   json.load(lowercase_					)
						__magic_name__     :  int  		=   """MLukeTokenizer"""
						with open(os.path.join(lowercase_,       """tokenizer_config.json"""					),       """w"""					) as f:
												json.dump(lowercase_,       lowercase_					)

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

						__magic_name__     :  Tuple  		=   MLukeTokenizer.from_pretrained(lowercase_					)

						# Initialize the embeddings of the special tokens
						__magic_name__     :  Dict  		=   tokenizer.convert_tokens_to_ids(["""@"""]					)[0]
						__magic_name__     :  Union[str, Any]  		=   tokenizer.convert_tokens_to_ids(["""#"""]					)[0]

						__magic_name__     :  Dict  		=   state_dict["""embeddings.word_embeddings.weight"""]
						__magic_name__     :  Optional[int]  		=   word_emb[ent_init_index].unsqueeze(0					)
						__magic_name__     :  List[str]  		=   word_emb[enta_init_index].unsqueeze(0					)
						__magic_name__     :  List[str]  		=   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"]:
												__magic_name__     :  Optional[int]  		=   state_dict[bias_name]
												__magic_name__     :  Tuple  		=   decoder_bias[ent_init_index].unsqueeze(0					)
												__magic_name__     :  int  		=   decoder_bias[enta_init_index].unsqueeze(0					)
												__magic_name__     :  List[Any]  		=   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"]:
																		__magic_name__     :  Any  		=   f'encoder.layer.{layer_index}.attention.self.'
																		__magic_name__     :  str  		=   state_dict[prefix + matrix_name]
																		__magic_name__     :  int  		=   state_dict[prefix + matrix_name]
																		__magic_name__     :  Union[str, Any]  		=   state_dict[prefix + matrix_name]

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

						__magic_name__     :  Any  		=   LukeForMaskedLM(config=lowercase_					).eval()

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

						__magic_name__		,__magic_name__     :  int  		=   model.load_state_dict(lowercase_,       strict=lowercase_					)

						if set(lowercase_					) != {"luke.embeddings.position_ids"}:
												raise ValueError(f'Unexpected unexpected_keys: {unexpected_keys}'					)
						if set(lowercase_					) != {
						    "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
						__magic_name__     :  Union[str, Any]  		=   MLukeTokenizer.from_pretrained(lowercase_,       task="""entity_classification"""					)

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

						__magic_name__     :  Optional[int]  		=   model(**lowercase_					)

						# Verify word hidden states
						if model_size == "large":
												raise NotImplementedError
						else:  # base
												__magic_name__     :  Dict  		=   torch.Size((1, 33, 768)					)
												__magic_name__     :  Dict  		=   torch.tensor([[0.0892, 0.0596, -0.2819], [0.0134, 0.1199, 0.0573], [-0.0169, 0.0927, 0.0644]]					)

						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":
												raise NotImplementedError
						else:  # base
												__magic_name__     :  str  		=   torch.Size((1, 1, 768)					)
												__magic_name__     :  int  		=   torch.tensor([[-0.1482, 0.0609, 0.0322]]					)

						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

						# Verify masked word/entity prediction
						__magic_name__     :  Union[str, Any]  		=   MLukeTokenizer.from_pretrained(lowercase_					)
						__magic_name__     :  List[str]  		=   """Tokyo is the capital of <mask>."""
						__magic_name__     :  int  		=   (24, 30)
						__magic_name__     :  Dict  		=   tokenizer(lowercase_,       entity_spans=[span],       return_tensors="""pt"""					)

						__magic_name__     :  int  		=   model(**lowercase_					)

						__magic_name__     :  Dict  		=   encoding["""input_ids"""][0].tolist()
						__magic_name__     :  Tuple  		=   input_ids.index(tokenizer.convert_tokens_to_ids("""<mask>"""					)					)
						__magic_name__     :  str  		=   outputs.logits[0][mask_position_id].argmax(dim=-1					)
						assert "Japan" == tokenizer.decode(lowercase_					)

						__magic_name__     :  List[Any]  		=   outputs.entity_logits[0][0].argmax().item()
						__magic_name__     :  List[Any]  		=   [
						    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(lowercase_					)					)
						model.save_pretrained(lowercase_					)

def        UpperCamelCase		(			_A					):






						"""simple docstring"""







						__magic_name__     :  Tuple  		=   ["""[MASK]""", """[PAD]""", """[UNK]"""]

						__magic_name__     :  Dict  		=   [json.loads(lowercase_					) for line in open(lowercase_					)]

						__magic_name__     :  Union[str, Any]  		=   {}
						for entry in data:
												__magic_name__     :  Optional[int]  		=   entry["""id"""]
												for entity_name, language in entry["entities"]:
																		if entity_name in SPECIAL_TOKENS:
																								__magic_name__     :  List[Any]  		=   entity_id
																								break
																		__magic_name__     :  int  		=   f'{language}:{entity_name}'
																		__magic_name__     :  Union[str, Any]  		=   entity_id
						return new_mapping


if __name__ == "__main__":
		__magic_name__:	List[str]							=      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."
		)
		__magic_name__:	Optional[Any]							=      parser.parse_args()
		convert_luke_checkpoint(
		    args.checkpoint_path,
		    args.metadata_path,
		    args.entity_vocab_path,
		    args.pytorch_dump_folder_path,
		    args.model_size,
		)






from math import atan, cos, radians, sin, tan

from .haversine_distance import haversine_distance

_lowerCamelCase      :						Dict							=  6_378_137.0
_lowerCamelCase      :						Union[str, Any]							=  6_356_752.314_245
_lowerCamelCase      :						List[Any]							=  6378137







def SCREAMING_SNAKE_CASE							(			lowercase_					,							lowercase_					,							lowercase_					,							lowercase_		)  ->			float:



       """simple docstring"""

       A__ 					=       (AXIS_A - AXIS_B) / AXIS_A
       # Parametric latitudes
       # https://en.wikipedia.org/wiki/Latitude#Parametric_(or_reduced)_latitude
       A__ 					=       atan((1 - flattening) * tan(radians(lowercase_		)		)		)
       A__ 					=       atan((1 - flattening) * tan(radians(lowercase_		)		)		)

       # Compute central angle between two points
       # using haversine theta. sigma =  haversine_distance / equatorial radius
       A__ 					=       haversine_distance(lowercase_					,							lowercase_					,							lowercase_					,							lowercase_		) / EQUATORIAL_RADIUS

       # Intermediate P and Q values
       A__ 					=       (b_lata + b_lata) / 2
       A__ 					=       (b_lata - b_lata) / 2

       # Intermediate X value
       # X = (sigma - sin(sigma)) * sin^2Pcos^2Q / cos^2(sigma/2)
       A__ 					=       (sin(lowercase_		) ** 2) * (cos(lowercase_		) ** 2)
       A__ 					=       cos(sigma / 2		) ** 2
       A__ 					=       (sigma - sin(lowercase_		)) * (x_numerator / x_demonimator)

       # Intermediate Y value
       # Y = (sigma + sin(sigma)) * cos^2Psin^2Q / sin^2(sigma/2)
       A__ 					=       (cos(lowercase_		) ** 2) * (sin(lowercase_		) ** 2)
       A__ 					=       sin(sigma / 2		) ** 2
       A__ 					=       (sigma + sin(lowercase_		)) * (y_numerator / y_denominator)

       return EQUATORIAL_RADIUS * (sigma - ((flattening / 2) * (x_value + y_value)))


if __name__ == "__main__":
  import doctest

  doctest.testmod()


