




'''simple docstring'''







import os
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers.models.realm.configuration_realm import RealmConfig
from transformers.models.realm.retrieval_realm import _REALM_BLOCK_RECORDS_FILENAME, RealmRetriever
from transformers.models.realm.tokenization_realm import VOCAB_FILES_NAMES, RealmTokenizer


class 			_a  (	__a ):
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		tempfile.mkdtemp()
           UpperCAmelCase			       =		5

           # Realm tok
           UpperCAmelCase			       =		[
               '''[UNK]''',
               '''[CLS]''',
               '''[SEP]''',
               '''[PAD]''',
               '''[MASK]''',
               '''test''',
               '''question''',
               '''this''',
               '''is''',
               '''the''',
               '''first''',
               '''second''',
               '''third''',
               '''fourth''',
               '''fifth''',
               '''record''',
               '''want''',
               '''##want''',
               '''##ed''',
               '''wa''',
               '''un''',
               '''runn''',
               '''##ing''',
               ''',''',
               '''low''',
               '''lowest''',
           ]
           UpperCAmelCase			       =		os.path.join(self.tmpdirname   ,				'''realm_tokenizer'''				)
           os.makedirs(lowercase   ,				exist_ok=lowercase				)
           UpperCAmelCase			       =		os.path.join(lowercase   ,				VOCAB_FILES_NAMES['''vocab_file''']				)
           with open(self.vocab_file   ,				'''w'''   ,				encoding='''utf-8'''				) as vocab_writer:
               vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]				)				)

           UpperCAmelCase			       =		os.path.join(self.tmpdirname   ,				'''realm_block_records'''				)
           os.makedirs(lowercase   ,				exist_ok=lowercase				)
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname   ,				'''realm_tokenizer'''				)				)
       def     A      (	self						:	int				):



           '''simple docstring'''

           shutil.rmtree(self.tmpdirname				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		RealmConfig(num_block_records=self.num_block_records				)
           return config
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           UpperCAmelCase			       =		Dataset.from_dict(
               {
                   '''id''': ['''0''', '''1'''],
                   '''question''': ['''foo''', '''bar'''],
                   '''answers''': [['''Foo''', '''Bar'''], ['''Bar''']],
               }				)
           return dataset
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		np.array(
               [
                   B'''This is the first record''',
                   B'''This is the second record''',
                   B'''This is the third record''',
                   B'''This is the fourth record''',
                   B'''This is the fifth record''',
                   B'''This is a longer longer longer record''',
               ]   ,				dtype=lowercase   ,				)
           return block_records
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		RealmRetriever(
               block_records=self.get_dummy_block_records()   ,				tokenizer=self.get_tokenizer()   ,				)
           return retriever
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_config()
           UpperCAmelCase			       =		self.get_dummy_retriever()
           UpperCAmelCase			       =		retriever.tokenizer

           UpperCAmelCase			       =		np.array([0, 3]   ,				dtype='''long'''				)
           UpperCAmelCase			       =		tokenizer(['''Test question''']				).input_ids
           UpperCAmelCase			       =		tokenizer(
               ['''the fourth''']   ,				add_special_tokens=lowercase   ,				return_token_type_ids=lowercase   ,				return_attention_mask=lowercase   ,				).input_ids
           UpperCAmelCase			       =		config.reader_seq_len

           UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		retriever(
               lowercase   ,				lowercase   ,				answer_ids=lowercase   ,				max_length=lowercase   ,				return_tensors='''np'''				)

           self.assertEqual(len(lowercase				)   ,				2				)
           self.assertEqual(len(lowercase				)   ,				2				)
           self.assertEqual(len(lowercase				)   ,				2				)
           self.assertEqual(concat_inputs.input_ids.shape   ,				(2, 10)				)
           self.assertEqual(concat_inputs.attention_mask.shape   ,				(2, 10)				)
           self.assertEqual(concat_inputs.token_type_ids.shape   ,				(2, 10)				)
           self.assertEqual(concat_inputs.special_tokens_mask.shape   ,				(2, 10)				)
           self.assertEqual(
               tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[0]				)   ,				['''[CLS]''', '''test''', '''question''', '''[SEP]''', '''this''', '''is''', '''the''', '''first''', '''record''', '''[SEP]''']   ,				)
           self.assertEqual(
               tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[1]				)   ,				['''[CLS]''', '''test''', '''question''', '''[SEP]''', '''this''', '''is''', '''the''', '''fourth''', '''record''', '''[SEP]''']   ,				)
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_config()
           UpperCAmelCase			       =		self.get_dummy_retriever()
           UpperCAmelCase			       =		retriever.tokenizer

           UpperCAmelCase			       =		np.array([0, 3, 5]   ,				dtype='''long'''				)
           UpperCAmelCase			       =		tokenizer(['''Test question''']				).input_ids
           UpperCAmelCase			       =		tokenizer(
               ['''the fourth''', '''longer longer''']   ,				add_special_tokens=lowercase   ,				return_token_type_ids=lowercase   ,				return_attention_mask=lowercase   ,				).input_ids
           UpperCAmelCase			       =		config.reader_seq_len

           UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		retriever(
               lowercase   ,				lowercase   ,				answer_ids=lowercase   ,				max_length=lowercase   ,				return_tensors='''np'''				)

           self.assertEqual([False, True, True]   ,				lowercase				)
           self.assertEqual([[-1, -1, -1], [6, -1, -1], [6, 7, 8]]   ,				lowercase				)
           self.assertEqual([[-1, -1, -1], [7, -1, -1], [7, 8, 9]]   ,				lowercase				)







       def     A      (	self						:	Dict				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_dummy_retriever()
           retriever.save_pretrained(os.path.join(self.tmpdirname   ,				'''realm_block_records'''				)				)

           # Test local path
           UpperCAmelCase			       =		retriever.from_pretrained(os.path.join(self.tmpdirname   ,				'''realm_block_records'''				)				)
           self.assertEqual(retriever.block_records[0]   ,				B'''This is the first record'''				)

           # Test mocked remote path
           with patch('''transformers.models.realm.retrieval_realm.hf_hub_download'''				) as mock_hf_hub_download:
               UpperCAmelCase			       =		os.path.join(
                   os.path.join(self.tmpdirname   ,				'''realm_block_records'''				)   ,				_REALM_BLOCK_RECORDS_FILENAME				)
               UpperCAmelCase			       =		RealmRetriever.from_pretrained('''google/realm-cc-news-pretrained-openqa'''				)

           self.assertEqual(retriever.block_records[0]   ,				B'''This is the first record'''				)










'''simple docstring'''







import argparse
import logging
from collections import namedtuple

import torch
from model_bertabs import BertAbsSummarizer
from models.model_builder import AbsSummarizer  # The authors' implementation

from transformers import BertTokenizer


logging.basicConfig(level=logging.INFO)
A     =logging.getLogger(__name__)


A     ='Hello world! cécé herlolip'


A     =namedtuple(
    'BertAbsConfig',
    [
        'temp_dir',
        'large',
        'use_bert_emb',
        'finetune_bert',
        'encoder',
        'share_emb',
        'max_pos',
        'enc_layers',
        'enc_hidden_size',
        'enc_heads',
        'enc_ff_size',
        'enc_dropout',
        'dec_layers',
        'dec_hidden_size',
        'dec_heads',
        'dec_ff_size',
        'dec_dropout',
    ],
)





def 						snake_case_							(_a	:							List[Any]    ,   _a	:							Any     ):
    UpperCAmelCase			       =		BertAbsConfig(
        temp_dir='''.'''    ,   finetune_bert=_a    ,   large=_a    ,   share_emb=_a    ,   use_bert_emb=_a    ,   encoder='''bert'''    ,   max_pos=5_1_2    ,   enc_layers=6    ,   enc_hidden_size=5_1_2    ,   enc_heads=8    ,   enc_ff_size=5_1_2    ,   enc_dropout=0.2    ,   dec_layers=6    ,   dec_hidden_size=7_6_8    ,   dec_heads=8    ,   dec_ff_size=2_0_4_8    ,   dec_dropout=0.2    ,   )
    UpperCAmelCase			       =		torch.load(_a    ,   lambda _a    ,   _a     : storage     )
    UpperCAmelCase			       =		AbsSummarizer(_a    ,   torch.device('''cpu'''     )    ,   _a     )
    original.eval()

    UpperCAmelCase			       =		BertAbsSummarizer(_a    ,   torch.device('''cpu'''     )     )
    new_model.eval()

    # -------------------
    # Convert the weights
    # -------------------

    logging.info('''convert the model'''     )
    new_model.bert.load_state_dict(original.bert.state_dict()     )
    new_model.decoder.load_state_dict(original.decoder.state_dict()     )
    new_model.generator.load_state_dict(original.generator.state_dict()     )

    # ----------------------------------
    # Make sure the outpus are identical
    # ----------------------------------

    logging.info('''Make sure that the models\' outputs are identical'''     )
    UpperCAmelCase			       =		BertTokenizer.from_pretrained('''bert-base-uncased'''     )

    # prepare the model inputs
    UpperCAmelCase			       =		tokenizer.encode('''This is sample éàalj\'-.'''     )
    encoder_input_ids.extend([tokenizer.pad_token_id] * (5_1_2 - len(_a     ))     )
    UpperCAmelCase			       =		torch.tensor(_a     ).unsqueeze(0     )
    UpperCAmelCase			       =		tokenizer.encode('''This is sample 3 éàalj\'-.'''     )
    decoder_input_ids.extend([tokenizer.pad_token_id] * (5_1_2 - len(_a     ))     )
    UpperCAmelCase			       =		torch.tensor(_a     ).unsqueeze(0     )

    # failsafe to make sure the weights reset does not affect the
    # loaded weights.
    assert torch.max(torch.abs(original.generator[0].weight - new_model.generator[0].weight     )     ) == 0

    # forward pass
    UpperCAmelCase			       =		encoder_input_ids
    UpperCAmelCase			       =		decoder_input_ids
    UpperCAmelCase			       =		UpperCAmelCase			       =		None
    UpperCAmelCase			       =		None
    UpperCAmelCase			       =		UpperCAmelCase			       =		None
    UpperCAmelCase			       =		UpperCAmelCase			       =		None
    UpperCAmelCase			       =		None

    # The original model does not apply the geneator layer immediatly but rather in
    # the beam search (where it combines softmax + linear layer). Since we already
    # apply the softmax in our generation process we only apply the linear layer here.
    # We make sure that the outputs of the full stack are identical
    UpperCAmelCase			       =		original(_a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a    ,   _a     )[0]
    UpperCAmelCase			       =		original.generator(_a     )

    UpperCAmelCase			       =		new_model(
        _a    ,   _a    ,   _a    ,   _a    ,   _a     )[0]
    UpperCAmelCase			       =		new_model.generator(_a     )

    UpperCAmelCase			       =		torch.max(torch.abs(output_converted_model - output_original_model     )     ).item()
    print('''Maximum absolute difference beween weights: {:.2f}'''.format(_a     )     )
    UpperCAmelCase			       =		torch.max(torch.abs(output_converted_generator - output_original_generator     )     ).item()
    print('''Maximum absolute difference beween weights: {:.2f}'''.format(_a     )     )

    UpperCAmelCase			       =		torch.allclose(_a    ,   _a    ,   atol=1E-3     )
    if are_identical:
        logging.info('''all weights are equal up to 1e-3'''     )
    else:
        raise ValueError('''the weights are different. The new model is likely different from the original one.'''     )

    # The model has been saved with torch.save(model) and this is bound to the exact
    # directory structure. We save the state_dict instead.
    logging.info('''saving the model\'s state dictionary'''     )
    torch.save(
        new_model.state_dict()    ,   '''./bertabs-finetuned-cnndm-extractive-abstractive-summarization/pytorch_model.bin'''     )


if __name__ == "__main__":
   A     =argparse.ArgumentParser()
   parser.add_argument(
       '--bertabs_checkpoint_path',
       default=None,
       type=str,
       required=True,
       help='Path the official PyTorch dump.',
   )
   parser.add_argument(
       '--pytorch_dump_folder_path',
       default=None,
       type=str,
       required=True,
       help='Path to the output PyTorch model.',
   )
   A     =parser.parse_args()

   convert_bertabs_checkpoints(
       args.bertabs_checkpoint_path,
       args.pytorch_dump_folder_path,
   )




