



"""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)
UpperCamelCase_	:				Optional[int]										= logging.getLogger(__name__)


UpperCamelCase_	:				Optional[int]										= """Hello world! cécé herlolip"""


UpperCamelCase_	:				List[str]										= 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     __lowercase					(    a :				Union[str, Any]       ,		a :				Optional[int] )					->					str:
      __snake_case      :    Tuple  			=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=2_048       ,		dec_dropout=0.2       ,		)
      __snake_case      :    Optional[Any]  			=torch.load(a       ,		lambda a       ,		a : storage )
      __snake_case      :    Any  			=AbsSummarizer(a       ,		torch.device('''cpu''' )       ,		a )
      original.eval()

      __snake_case      :    List[Any]  			=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''' )
      __snake_case      :    Tuple  			=BertTokenizer.from_pretrained('''bert-base-uncased''' )

      # prepare the model inputs
      __snake_case      :    Dict  			=tokenizer.encode('''This is sample éàalj\'-.''' )
      encoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(a )) )
      __snake_case      :    List[str]  			=torch.tensor(a ).unsqueeze(0 )
      __snake_case      :    Any  			=tokenizer.encode('''This is sample 3 éàalj\'-.''' )
      decoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(a )) )
      __snake_case      :    Union[str, Any]  			=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
      __snake_case      :    str  			=encoder_input_ids
      __snake_case      :    Tuple  			=decoder_input_ids
      __snake_case      :    int  			=None
      __snake_case      :    List[Any]  			=None
      __snake_case      :    int  			=None
      __snake_case      :    Tuple  			=None
      __snake_case      :    List[str]  			=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
      __snake_case      :    Optional[int]  			=original(a       ,		a       ,		a       ,		a       ,		a       ,		a       ,		a )[0]
      __snake_case      :    Union[str, Any]  			=original.generator(a )

      __snake_case      :    Optional[Any]  			=new_model(
          a       ,		a       ,		a       ,		a       ,		a )[0]
      __snake_case      :    Optional[int]  			=new_model.generator(a )

      __snake_case      :    Union[str, Any]  			=torch.max(torch.abs(output_converted_model - output_original_model ) ).item()
      print('''Maximum absolute difference beween weights: {:.2f}'''.format(a ) )
      __snake_case      :    Union[str, Any]  			=torch.max(torch.abs(output_converted_generator - output_original_generator ) ).item()
      print('''Maximum absolute difference beween weights: {:.2f}'''.format(a ) )

      __snake_case      :    List[Any]  			=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__":
    UpperCamelCase_	:				Dict										= 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.""",
    )
    UpperCamelCase_	:				Any										= parser.parse_args()

    convert_bertabs_checkpoints(
        args.bertabs_checkpoint_path,
        args.pytorch_dump_folder_path,
    )










"""simple docstring"""





import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand



def     __lowercase					(    a :				Dict )					->					str:
      return EnvironmentCommand()



def     __lowercase					(    a :				Optional[int] )					->					List[Any]:
      return EnvironmentCommand(args.accelerate_config_file )


class      _lowercase (     lowerCAmelCase						):


      @staticmethod
      def _UpperCamelCase						(    a				:	ArgumentParser						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=parser.add_parser('''env'''						)
            download_parser.set_defaults(func=a						)
            download_parser.add_argument(
                '''--accelerate-config_file'''							,   default=a							,   help='''The accelerate config file to use for the default values in the launching script.'''							,   )
            download_parser.set_defaults(func=a						)


      def __init__(    self				:	Any							,   a				:	str							,   *a				:	Any						):





            """simple docstring"""







            __snake_case      :    int  			=accelerate_config_file


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    List[str]  			='''not installed'''
            if is_safetensors_available():
                  import safetensors

                  __snake_case      :    int  			=safetensors.__version__
            elif importlib.util.find_spec('''safetensors'''						) is not None:
                  import safetensors

                  __snake_case      :    List[Any]  			=f'''{safetensors.__version__} but is ignored because of PyTorch version too old.'''

            __snake_case      :    Dict  			='''not installed'''
            __snake_case      :    Optional[Any]  			='''not found'''
            if is_accelerate_available():
                  import accelerate
                  from accelerate.commands.config import default_config_file, load_config_from_file

                  __snake_case      :    Union[str, Any]  			=accelerate.__version__
                  # Get the default from the config file.
                  if self._accelerate_config_file is not None or os.path.isfile(a						):
                        __snake_case      :    int  			=load_config_from_file(self._accelerate_config_file						).to_dict()

                  __snake_case      :    Optional[int]  			=(
                      '''\n'''.join([f'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]						)
                      if isinstance(a							,   a						)
                      else f'''\t{accelerate_config}'''
                  )

            __snake_case      :    int  			='''not installed'''
            __snake_case      :    Any  			='''NA'''
            if is_torch_available():
                  import torch

                  __snake_case      :    Tuple  			=torch.__version__
                  __snake_case      :    Optional[Any]  			=torch.cuda.is_available()

            __snake_case      :    Optional[Any]  			='''not installed'''
            __snake_case      :    Any  			='''NA'''
            if is_tf_available():
                  import tensorflow as tf

                  __snake_case      :    Optional[Any]  			=tf.__version__
                  try:
                        # deprecated in v2.1
                        __snake_case      :    str  			=tf.test.is_gpu_available()
                  except AttributeError:
                        # returns list of devices, convert to bool
                        __snake_case      :    List[Any]  			=bool(tf.config.list_physical_devices('''GPU'''						)						)

            __snake_case      :    Optional[int]  			='''not installed'''
            __snake_case      :    Dict  			='''not installed'''
            __snake_case      :    List[str]  			='''not installed'''
            __snake_case      :    Optional[int]  			='''NA'''
            if is_flax_available():
                  import flax
                  import jax
                  import jaxlib

                  __snake_case      :    Tuple  			=flax.__version__
                  __snake_case      :    Optional[Any]  			=jax.__version__
                  __snake_case      :    str  			=jaxlib.__version__
                  __snake_case      :    Tuple  			=jax.lib.xla_bridge.get_backend().platform

            __snake_case      :    List[str]  			={
                '''`transformers` version''': version,
                '''Platform''': platform.platform(),
                '''Python version''': platform.python_version(),
                '''Huggingface_hub version''': huggingface_hub.__version__,
                '''Safetensors version''': f'''{safetensors_version}''',
                '''Accelerate version''': f'''{accelerate_version}''',
                '''Accelerate config''': f'''{accelerate_config_str}''',
                '''PyTorch version (GPU?)''': f'''{pt_version} ({pt_cuda_available})''',
                '''Tensorflow version (GPU?)''': f'''{tf_version} ({tf_cuda_available})''',
                '''Flax version (CPU?/GPU?/TPU?)''': f'''{flax_version} ({jax_backend})''',
                '''Jax version''': f'''{jax_version}''',
                '''JaxLib version''': f'''{jaxlib_version}''',
                '''Using GPU in script?''': '''<fill in>''',
                '''Using distributed or parallel set-up in script?''': '''<fill in>''',
            }

            print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n'''						)
            print(self.format_dict(a						)						)

            return info







      @staticmethod
      def _UpperCamelCase						(    a				:	List[str]						):





            """simple docstring"""







            return "\n".join([f'''- {prop}: {val}''' for prop, val in d.items()]						) + "\n"


