



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       lowerCAmelCase_     (lowerCAmelCase__:						Union[str, Any]						,		lowerCAmelCase__:						str						,		lowerCAmelCase__:						List[str]						,		lowerCAmelCase__:						Optional[int]						,		lowerCAmelCase__:						Union[str, Any]   ):





			"""simple docstring"""


			with open(_A   ) as metadata_file:
						UpperCAmelCase_:						Dict					=			json.load(_A   )
			UpperCAmelCase_:						Optional[int]					=			LukeConfig(use_entity_aware_attention=_A						,		**metadata["""model_config"""]   )

			# Load in the weights from the checkpoint_path
			UpperCAmelCase_:						str					=			torch.load(_A						,		map_location="""cpu"""   )["""module"""]

			# Load the entity vocab file
			UpperCAmelCase_:						Optional[int]					=			load_original_entity_vocab(_A   )
			# add an entry for [MASK2]
			UpperCAmelCase_:						str					=			max(entity_vocab.values()   ) + 1
			config.entity_vocab_size += 1

			UpperCAmelCase_:						Dict					=			XLMRobertaTokenizer.from_pretrained(metadata["""model_config"""]["""bert_model_name"""]   )

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

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

			UpperCAmelCase_:						Tuple					=			MLukeTokenizer.from_pretrained(_A   )

			# Initialize the embeddings of the special tokens
			UpperCAmelCase_:						Optional[Any]					=			tokenizer.convert_tokens_to_ids(["""@"""]   )[0]
			UpperCAmelCase_:						List[str]					=			tokenizer.convert_tokens_to_ids(["""#"""]   )[0]

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

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

			UpperCAmelCase_:						Dict					=			LukeForMaskedLM(config=_A   ).eval()

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

			UpperCAmelCase_	,				UpperCAmelCase_:						Optional[int]					=			model.load_state_dict(_A						,		strict=_A   )

			if set(_A   ) != {"luke.embeddings.position_ids"}:
						raise ValueError(F'Unexpected unexpected_keys: {unexpected_keys}'   )
			if set(_A   ) != {
			    "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
			UpperCAmelCase_:						Dict					=			MLukeTokenizer.from_pretrained(_A						,		task="""entity_classification"""   )

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

			UpperCAmelCase_:						Optional[int]					=			model(**_A   )

			# Verify word hidden states
			if model_size == "large":
						raise NotImplementedError
			else:  # base
						UpperCAmelCase_:						List[str]					=			torch.Size((1, 3_3, 7_6_8)   )
						UpperCAmelCase_:						List[str]					=			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]						,		_A						,		atol=1e-4   ):
						raise ValueError

			# Verify entity hidden states
			if model_size == "large":
						raise NotImplementedError
			else:  # base
						UpperCAmelCase_:						str					=			torch.Size((1, 1, 7_6_8)   )
						UpperCAmelCase_:						str					=			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]						,		_A						,		atol=1e-4   ):
						raise ValueError

			# Verify masked word/entity prediction
			UpperCAmelCase_:						Union[str, Any]					=			MLukeTokenizer.from_pretrained(_A   )
			UpperCAmelCase_:						int					=			"""Tokyo is the capital of <mask>."""
			UpperCAmelCase_:						Dict					=			(2_4, 3_0)
			UpperCAmelCase_:						int					=			tokenizer(_A						,		entity_spans=[span]						,		return_tensors="""pt"""   )

			UpperCAmelCase_:						Dict					=			model(**_A   )

			UpperCAmelCase_:						List[Any]					=			encoding["""input_ids"""][0].tolist()
			UpperCAmelCase_:						int					=			input_ids.index(tokenizer.convert_tokens_to_ids("""<mask>"""   )   )
			UpperCAmelCase_:						str					=			outputs.logits[0][mask_position_id].argmax(dim=-1   )
			assert "Japan" == tokenizer.decode(_A   )

			UpperCAmelCase_:						Any					=			outputs.entity_logits[0][0].argmax().item()
			UpperCAmelCase_:						Dict					=			[
			    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(_A   )   )
			model.save_pretrained(_A   )







def       lowerCAmelCase_     (lowerCAmelCase__:						Optional[Any]   ):





			"""simple docstring"""


			UpperCAmelCase_:						Dict					=			["""[MASK]""", """[PAD]""", """[UNK]"""]

			UpperCAmelCase_:						Any					=			[json.loads(_A   ) for line in open(_A   )]

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


if __name__ == "__main__":
	a	:   Tuple       			=       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	:   List[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,
	)









import os




def 			UpperCAmelCase__				(			_A      : Any							):





  '''simple docstring'''







  a__  =len(grid[0]							)
  a__  =len(_A							)

  a__  =0
  a__  =0
  a__  =0

  # Check vertically, horizontally, diagonally at the same time (only works
  # for nxn grid)
  for i in range(_A							):
    for j in range(n_rows - 3							):
      a__  =grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
      a__  =grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

      # Left-to-right diagonal (\) product
      if i < n_columns - 3:
        a__  =(
            grid[i][j]
            * grid[i + 1][j + 1]
            * grid[i + 2][j + 2]
            * grid[i + 3][j + 3]
        )

      # Right-to-left diagonal(/) product
      if i > 2:
        a__  =(
            grid[i][j]
            * grid[i - 1][j + 1]
            * grid[i - 2][j + 2]
            * grid[i - 3][j + 3]
        )

      a__  =max(
          _A	,      _A	,      _A	,      _A							)
      if max_product > largest:
        a__  =max_product

  return largest




def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  a__  =[]
  with open(os.path.dirname(_A							) + '''/grid.txt'''							) as file:
    for line in file:
      grid.append(line.strip('''\n'''							).split(''' '''							)							)

  a__  =[[int(_A							) for i in grid[j]] for j in range(len(_A							)							)]

  return largest_product(_A							)


if __name__ == "__main__":
       print(solution())
