


'''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)
snake_case_						:			Dict													=							logging.getLogger(__name__)


snake_case_						:			Optional[int]													=							'''Hello world! cécé herlolip'''


snake_case_						:			Tuple													=							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 						lowerCamelCase(   a__	,a__):
				_SCREAMING_SNAKE_CASE			  =BertAbsConfig(
				    temp_dir='''.'''	,finetune_bert=a__	,large=a__	,share_emb=a__	,use_bert_emb=a__	,encoder='''bert'''	,max_pos=512	,enc_layers=6	,enc_hidden_size=512	,enc_heads=8	,enc_ff_size=512	,enc_dropout=0.2	,dec_layers=6	,dec_hidden_size=768	,dec_heads=8	,dec_ff_size=2048	,dec_dropout=0.2	,)
				_SCREAMING_SNAKE_CASE			  =torch.load(a__	,lambda a__	,a__: storage)
				_SCREAMING_SNAKE_CASE			  =AbsSummarizer(a__	,torch.device('''cpu''')	,a__)
				original.eval()

				_SCREAMING_SNAKE_CASE			  =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''')
				_SCREAMING_SNAKE_CASE			  =BertTokenizer.from_pretrained('''bert-base-uncased''')

				# prepare the model inputs
				_SCREAMING_SNAKE_CASE			  =tokenizer.encode('''This is sample éàalj\'-.''')
				encoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(a__)))
				_SCREAMING_SNAKE_CASE			  =torch.tensor(a__).unsqueeze(0)
				_SCREAMING_SNAKE_CASE			  =tokenizer.encode('''This is sample 3 éàalj\'-.''')
				decoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(a__)))
				_SCREAMING_SNAKE_CASE			  =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
				_SCREAMING_SNAKE_CASE			  =encoder_input_ids
				_SCREAMING_SNAKE_CASE			  =decoder_input_ids
				_SCREAMING_SNAKE_CASE			  =_SCREAMING_SNAKE_CASE			  =None
				_SCREAMING_SNAKE_CASE			  =None
				_SCREAMING_SNAKE_CASE			  =_SCREAMING_SNAKE_CASE			  =None
				_SCREAMING_SNAKE_CASE			  =_SCREAMING_SNAKE_CASE			  =None
				_SCREAMING_SNAKE_CASE			  =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
				_SCREAMING_SNAKE_CASE			  =original(a__	,a__	,a__	,a__	,a__	,a__	,a__)[0]
				_SCREAMING_SNAKE_CASE			  =original.generator(a__)

				_SCREAMING_SNAKE_CASE			  =new_model(
				    a__	,a__	,a__	,a__	,a__)[0]
				_SCREAMING_SNAKE_CASE			  =new_model.generator(a__)

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

				_SCREAMING_SNAKE_CASE			  =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__":
							snake_case_						:			Optional[int]													=							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.''',
							)
							snake_case_						:			int													=							parser.parse_args()

							convert_bertabs_checkpoints(
							    args.bertabs_checkpoint_path,
							    args.pytorch_dump_folder_path,
							)



import unittest

import numpy as np
import requests

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

							from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
							snake_case_						:			Any													=							False

if is_vision_available():
							from PIL import Image

							from transformers import PixaStructImageProcessor

class 						A__							(		unittest.TestCase  ):




						def __init__(       self					:      Tuple				,    _a					:      str				,    _a					:      List[str]=7				,    _a					:      Union[str, Any]=3				,    _a					:      List[str]=18				,    _a					:      List[Any]=30				,    _a					:      Optional[Any]=400				,    _a					:      Dict=None				,    _a					:      Union[str, Any]=True				,    _a					:      List[str]=True				,    _a					:      Optional[Any]=None				,    )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =size if size is not None else {'''height''': 20, '''width''': 20}
										_SCREAMING_SNAKE_CASE			  =parent
										_SCREAMING_SNAKE_CASE			  =batch_size
										_SCREAMING_SNAKE_CASE			  =num_channels
										_SCREAMING_SNAKE_CASE			  =image_size
										_SCREAMING_SNAKE_CASE			  =min_resolution
										_SCREAMING_SNAKE_CASE			  =max_resolution
										_SCREAMING_SNAKE_CASE			  =size
										_SCREAMING_SNAKE_CASE			  =do_normalize
										_SCREAMING_SNAKE_CASE			  =do_convert_rgb
										_SCREAMING_SNAKE_CASE			  =[512, 1024, 2048, 4096]
										_SCREAMING_SNAKE_CASE			  =patch_size if patch_size is not None else {'''height''': 16, '''width''': 16}




						def 							__UpperCamelCase				(       self					:      int  )							->     Any:


										"""simple docstring"""





										return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}




						def 							__UpperCamelCase				(       self					:      str  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  ='''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg'''
										_SCREAMING_SNAKE_CASE			  =Image.open(requests.get(_a				,    stream=_a  ).raw  ).convert('''RGB'''  )
										return raw_image

@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11   ,     reason="`Pix2StructImageProcessor` requires `torch>=1.11.0`."   ,     )
@require_torch
@require_vision
class 						A__							(		UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						PixaStructImageProcessor if is_vision_available() else None




						def 							__UpperCamelCase				(       self					:      int  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =PixaStructImageProcessingTester(self  )




						@property
						def 							__UpperCamelCase				(       self					:      int  )							->     Any:


										"""simple docstring"""





										return self.image_processor_tester.prepare_image_processor_dict()




						def 							__UpperCamelCase				(       self					:      str  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										self.assertTrue(hasattr(_a				,    '''do_normalize'''  )  )
										self.assertTrue(hasattr(_a				,    '''do_convert_rgb'''  )  )




						def 							__UpperCamelCase				(       self					:      int  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processor_tester.prepare_dummy_image()

										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										_SCREAMING_SNAKE_CASE			  =2048

										_SCREAMING_SNAKE_CASE			  =image_processor(_a				,    return_tensors='''pt'''				,    max_patches=_a  )
										self.assertTrue(torch.allclose(inputs.flattened_patches.mean()				,    torch.tensor(0.06_06  )				,    atol=1E-3				,    rtol=1E-3  )  )




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										# create random PIL images
										_SCREAMING_SNAKE_CASE			  =prepare_image_inputs(self.image_processor_tester				,    equal_resolution=_a  )
										for image in image_inputs:
														self.assertIsInstance(_a				,    Image.Image  )

										# Test not batched input
										_SCREAMING_SNAKE_CASE			  =(
										    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
										    * self.image_processor_tester.num_channels
										) + 2

										for max_patch in self.image_processor_tester.max_patches:
														# Test not batched input
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (1, max_patch, expected_hidden_dim)				,    )

														# Test batched
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    _a				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)				,    )




						def 							__UpperCamelCase				(       self					:      Dict  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										# create random PIL images
										_SCREAMING_SNAKE_CASE			  =prepare_image_inputs(self.image_processor_tester				,    equal_resolution=_a  )
										for image in image_inputs:
														self.assertIsInstance(_a				,    Image.Image  )

										# Test not batched input
										_SCREAMING_SNAKE_CASE			  =(
										    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
										    * self.image_processor_tester.num_channels
										) + 2

										_SCREAMING_SNAKE_CASE			  =True

										for max_patch in self.image_processor_tester.max_patches:
														# Test not batched input
														with self.assertRaises(_a  ):
																		_SCREAMING_SNAKE_CASE			  =image_processor(
																		    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches

														_SCREAMING_SNAKE_CASE			  ='''Hello'''

														_SCREAMING_SNAKE_CASE			  =image_processor(
														    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a				,    header_text=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (1, max_patch, expected_hidden_dim)				,    )

														# Test batched
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    _a				,    return_tensors='''pt'''				,    max_patches=_a				,    header_text=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)				,    )




						def 							__UpperCamelCase				(       self					:      List[Any]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										# create random numpy tensors
										_SCREAMING_SNAKE_CASE			  =prepare_image_inputs(self.image_processor_tester				,    equal_resolution=_a				,    numpify=_a  )
										for image in image_inputs:
														self.assertIsInstance(_a				,    np.ndarray  )

										_SCREAMING_SNAKE_CASE			  =(
										    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
										    * self.image_processor_tester.num_channels
										) + 2

										for max_patch in self.image_processor_tester.max_patches:
														# Test not batched input
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (1, max_patch, expected_hidden_dim)				,    )

														# Test batched
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    _a				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)				,    )




						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										# create random PyTorch tensors
										_SCREAMING_SNAKE_CASE			  =prepare_image_inputs(self.image_processor_tester				,    equal_resolution=_a				,    torchify=_a  )
										for image in image_inputs:
														self.assertIsInstance(_a				,    torch.Tensor  )

										# Test not batched input
										_SCREAMING_SNAKE_CASE			  =(
										    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
										    * self.image_processor_tester.num_channels
										) + 2

										for max_patch in self.image_processor_tester.max_patches:
														# Test not batched input
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (1, max_patch, expected_hidden_dim)				,    )

														# Test batched
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    _a				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)				,    )

@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11   ,     reason="`Pix2StructImageProcessor` requires `torch>=1.11.0`."   ,     )
@require_torch
@require_vision
class 						A__							(		UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						PixaStructImageProcessor if is_vision_available() else None




						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =PixaStructImageProcessingTester(self				,    num_channels=4  )
										_SCREAMING_SNAKE_CASE			  =3




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     List[str]:


										"""simple docstring"""





										return self.image_processor_tester.prepare_image_processor_dict()




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										self.assertTrue(hasattr(_a				,    '''do_normalize'''  )  )
										self.assertTrue(hasattr(_a				,    '''do_convert_rgb'''  )  )




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.image_processing_class(**self.image_processor_dict  )
										# create random PIL images
										_SCREAMING_SNAKE_CASE			  =prepare_image_inputs(self.image_processor_tester				,    equal_resolution=_a  )
										for image in image_inputs:
														self.assertIsInstance(_a				,    Image.Image  )

										# Test not batched input
										_SCREAMING_SNAKE_CASE			  =(
										    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
										    * (self.image_processor_tester.num_channels - 1)
										) + 2

										for max_patch in self.image_processor_tester.max_patches:
														# Test not batched input
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    image_inputs[0]				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (1, max_patch, expected_hidden_dim)				,    )

														# Test batched
														_SCREAMING_SNAKE_CASE			  =image_processor(
														    _a				,    return_tensors='''pt'''				,    max_patches=_a  ).flattened_patches
														self.assertEqual(
														    encoded_images.shape				,    (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)				,    )