





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     lowerCamelCase_	(      lowerCAmelCase:	Any    ,							lowerCAmelCase:	int    ,							lowerCAmelCase:	List[str]    ,							lowerCAmelCase:	str    ,							lowerCAmelCase:	Tuple				)->		Any:
  # Load configuration defined in the metadata file
  with open(lowerCamelCase_				) as metadata_file:
    _snake_case   :				str														=	json.load(lowerCamelCase_				)
  _snake_case   :				Dict														=	LukeConfig(use_entity_aware_attention=lowerCamelCase_    ,							**metadata['model_config']				)

  # Load in the weights from the checkpoint_path
  _snake_case   :				Optional[int]														=	torch.load(lowerCamelCase_    ,							map_location='cpu'				)

  # Load the entity vocab file
  _snake_case   :				int														=	load_entity_vocab(lowerCamelCase_				)

  _snake_case   :				Union[str, Any]														=	RobertaTokenizer.from_pretrained(metadata['model_config']['bert_model_name']				)

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

  _snake_case   :				Optional[Any]														=	LukeTokenizer.from_pretrained(lowerCamelCase_				)

  # Initialize the embeddings of the special tokens
  _snake_case   :				Tuple														=	state_dict['embeddings.word_embeddings.weight']
  _snake_case   :				Any														=	word_emb[tokenizer.convert_tokens_to_ids(['@']				)[0]].unsqueeze(0				)
  _snake_case   :				Dict														=	word_emb[tokenizer.convert_tokens_to_ids(['#']				)[0]].unsqueeze(0				)
  _snake_case   :				str														=	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   :				List[Any]														=	F"""encoder.layer.{layer_index}.attention.self."""
      _snake_case   :				Any														=	state_dict[prefix + matrix_name]
      _snake_case   :				List[Any]														=	state_dict[prefix + matrix_name]
      _snake_case   :				List[str]														=	state_dict[prefix + matrix_name]

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

  _snake_case   :				Dict														=	LukeModel(config=lowerCamelCase_				).eval()

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

  _snake_case   :				Union[str, Any]														=	(
      '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   :				Optional[Any]														=	(39, 42)
  _snake_case   :				List[Any]														=	tokenizer(lowerCamelCase_    ,							entity_spans=[span]    ,							add_prefix_space=lowerCamelCase_    ,							return_tensors='pt'				)

  _snake_case   :				str														=	model(**lowerCamelCase_				)

  # Verify word hidden states
  if model_size == "large":
    _snake_case   :				int														=	torch.Size((1, 42, 10_24)				)
    _snake_case   :				Union[str, Any]														=	torch.tensor(
        [[0.0_1_3_3, 0.0_8_6_5, 0.0_0_9_5], [0.3_0_9_3, -0.2_5_7_6, -0.7_4_1_8], [-0.1_7_2_0, -0.2_1_1_7, -0.2_8_6_9]]				)
  else:  # base
    _snake_case   :				int														=	torch.Size((1, 42, 7_68)				)
    _snake_case   :				Optional[int]														=	torch.tensor([[0.0_0_3_7, 0.1_3_6_8, -0.0_0_9_1], [0.1_0_9_9, 0.3_3_2_9, -0.1_0_9_5], [0.0_7_6_5, 0.5_3_3_5, 0.1_1_7_9]]				)

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

  # Verify entity hidden states
  if model_size == "large":
    _snake_case   :				Any														=	torch.Size((1, 1, 10_24)				)
    _snake_case   :				int														=	torch.tensor([[0.0_4_6_6, -0.0_1_0_6, -0.0_1_7_9]]				)
  else:  # base
    _snake_case   :				Dict														=	torch.Size((1, 1, 7_68)				)
    _snake_case   :				Any														=	torch.tensor([[0.1_4_5_7, 0.1_0_4_4, 0.0_1_7_4]]				)

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

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


def     lowerCamelCase_	(      lowerCAmelCase:	Any				)->		Union[str, Any]:
  _snake_case   :				List[Any]														=	{}
  with open(lowerCamelCase_    ,							'r'    ,							encoding='utf-8'				) as f:
    for index, line in enumerate(lowerCamelCase_				):
      _snake_case							,					_snake_case   :				Tuple														=	line.rstrip().split('\t'				)
      _snake_case   :				Any														=	index

  return entity_vocab


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,
   )











# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


lowerCAmelCase_						   =    """Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine"""


def     lowerCamelCase_	(      )->		Tuple:
  _snake_case   :				int														=	_ask_options(
      'In which compute environment are you running?'    ,							['This machine', 'AWS (Amazon SageMaker)']    ,							_convert_compute_environment    ,							)
  if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
    _snake_case   :				int														=	get_sagemaker_input()
  else:
    _snake_case   :				Any														=	get_cluster_input()
  return config


def     lowerCamelCase_	(      lowerCAmelCase:	str=None				)->		Any:
  if subparsers is not None:
    _snake_case   :				List[Any]														=	subparsers.add_parser('config'    ,							description=lowerCAmelCase				)
  else:
    _snake_case   :				Dict														=	argparse.ArgumentParser('Accelerate config command'    ,							description=lowerCAmelCase				)

  parser.add_argument(
      '--config_file'    ,							default=lowerCAmelCase    ,							help=(
          'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
          'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
          'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
          'with \'huggingface\'.'
      )    ,							)

  if subparsers is not None:
    parser.set_defaults(func=lowerCAmelCase				)
  return parser


def     lowerCamelCase_	(      lowerCAmelCase:	Any				)->		Any:
  _snake_case   :				Dict														=	get_user_input()
  if args.config_file is not None:
    _snake_case   :				List[str]														=	args.config_file
  else:
    if not os.path.isdir(lowerCAmelCase				):
      os.makedirs(lowerCAmelCase				)
    _snake_case   :				Union[str, Any]														=	default_yaml_config_file

  if config_file.endswith('.json'				):
    config.to_json_file(lowerCAmelCase				)
  else:
    config.to_yaml_file(lowerCAmelCase				)
  print(F"""accelerate configuration saved at {config_file}"""				)


def     lowerCamelCase_	(      )->		Dict:
  _snake_case   :				List[str]														=	config_command_parser()
  _snake_case   :				str														=	parser.parse_args()
  config_command(lowerCAmelCase				)


if __name__ == "__main__":
      main()




