





'''simple docstring'''

import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
lowercase_					= {"""LayoutLMv2Config""", """LayoutLMv3Config"""}


@is_pipeline_test
class 					a_     (				unittest.TestCase       ):

    '''simple docstring'''
    UpperCamelCase     = MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
    UpperCamelCase     = TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

    if model_mapping is not None:
        UpperCamelCase     = {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
    if tf_model_mapping is not None:
        UpperCamelCase     = {
            config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
        }


    @require_torch
    def 			snake_case_(		self       )		->   Union[str, Any]:
        _SCREAMING_SNAKE_CASE									=			pipeline(
            task="""text-classification""" ,		model="""hf-internal-testing/tiny-random-distilbert""" ,		framework="""pt"""       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}]       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !""" ,		top_k=2       )
        self.assertEqual(
            nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}]       )

        _SCREAMING_SNAKE_CASE									=			text_classifier(["""This is great !""", """This is bad"""] ,		top_k=2       )
        self.assertEqual(
            nested_simplify(A       ) ,		[
                [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
                [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
            ] ,		)

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !""" ,		top_k=1       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}]       )

        # Legacy behavior
        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !""" ,		return_all_scores=A       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}]       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !""" ,		return_all_scores=A       )
        self.assertEqual(
            nested_simplify(A       ) ,		[[{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}]]       )

        _SCREAMING_SNAKE_CASE									=			text_classifier(["""This is great !""", """Something else"""] ,		return_all_scores=A       )
        self.assertEqual(
            nested_simplify(A       ) ,		[
                [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
                [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
            ] ,		)

        _SCREAMING_SNAKE_CASE									=			text_classifier(["""This is great !""", """Something else"""] ,		return_all_scores=A       )
        self.assertEqual(
            nested_simplify(A       ) ,		[
                {"""label""": """LABEL_0""", """score""": 0.504},
                {"""label""": """LABEL_0""", """score""": 0.504},
            ] ,		)


    @require_torch
    def 			snake_case_(		self       )		->   int:
        import torch

        _SCREAMING_SNAKE_CASE									=			pipeline(
            task="""text-classification""" ,		model="""hf-internal-testing/tiny-random-distilbert""" ,		framework="""pt""" ,		device=torch.device("""cpu"""       ) ,		)

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}]       )


    @require_tf
    def 			snake_case_(		self       )		->   List[Any]:
        _SCREAMING_SNAKE_CASE									=			pipeline(
            task="""text-classification""" ,		model="""hf-internal-testing/tiny-random-distilbert""" ,		framework="""tf"""       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """LABEL_0""", """score""": 0.504}]       )


    @slow
    @require_torch
    def 			snake_case_(		self       )		->   Any:
        _SCREAMING_SNAKE_CASE									=			pipeline("""text-classification"""       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """POSITIVE""", """score""": 1.0}]       )
        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is bad !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """NEGATIVE""", """score""": 1.0}]       )
        _SCREAMING_SNAKE_CASE									=			text_classifier("""Birds are a type of animal"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """POSITIVE""", """score""": 0.988}]       )


    @slow
    @require_tf
    def 			snake_case_(		self       )		->   List[Any]:
        _SCREAMING_SNAKE_CASE									=			pipeline("""text-classification""" ,		framework="""tf"""       )

        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is great !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """POSITIVE""", """score""": 1.0}]       )
        _SCREAMING_SNAKE_CASE									=			text_classifier("""This is bad !"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """NEGATIVE""", """score""": 1.0}]       )
        _SCREAMING_SNAKE_CASE									=			text_classifier("""Birds are a type of animal"""       )
        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": """POSITIVE""", """score""": 0.988}]       )


    def 			snake_case_(		self ,		A ,		A ,		A       )		->   Optional[Any]:
        _SCREAMING_SNAKE_CASE									=			TextClassificationPipeline(model=A ,		tokenizer=A       )
        return text_classifier, ["HuggingFace is in", "This is another test"]





    def 			snake_case_(		self ,		A ,		A       )		->   int:
        _SCREAMING_SNAKE_CASE									=			text_classifier.model
        # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
        _SCREAMING_SNAKE_CASE									=			"""HuggingFace is in"""
        _SCREAMING_SNAKE_CASE									=			text_classifier(A       )

        self.assertEqual(nested_simplify(A       ) ,		[{"""label""": ANY(A       ), """score""": ANY(A       )}]       )
        self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()       )

        _SCREAMING_SNAKE_CASE									=			["""HuggingFace is in """, """Paris is in France"""]
        _SCREAMING_SNAKE_CASE									=			text_classifier(A       )
        self.assertEqual(
            nested_simplify(A       ) ,		[{"""label""": ANY(A       ), """score""": ANY(A       )}, {"""label""": ANY(A       ), """score""": ANY(A       )}] ,		)
        self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()       )
        self.assertTrue(outputs[1]["""label"""] in model.config.idalabel.values()       )

        # Forcing to get all results with `top_k=None`
        # This is NOT the legacy format
        _SCREAMING_SNAKE_CASE									=			text_classifier(A ,		top_k=A       )
        _SCREAMING_SNAKE_CASE									=			len(model.config.idalabel.values()       )
        self.assertEqual(
            nested_simplify(A       ) ,		[[{"""label""": ANY(A       ), """score""": ANY(A       )}] * N, [{"""label""": ANY(A       ), """score""": ANY(A       )}] * N] ,		)

        _SCREAMING_SNAKE_CASE									=			{"""text""": """HuggingFace is in """, """text_pair""": """Paris is in France"""}
        _SCREAMING_SNAKE_CASE									=			text_classifier(A       )
        self.assertEqual(
            nested_simplify(A       ) ,		{"""label""": ANY(A       ), """score""": ANY(A       )} ,		)
        self.assertTrue(outputs["""label"""] in model.config.idalabel.values()       )

        # This might be used a text pair, but tokenizer + pipe interaction
        # makes it hard to understand that it's not using the pair properly
        # https://github.com/huggingface/transformers/issues/17305
        # We disabled this usage instead as it was outputting wrong outputs.
        _SCREAMING_SNAKE_CASE									=			[["""HuggingFace is in """, """Paris is in France"""]]
        with self.assertRaises(A       ):
            text_classifier(A       )

        # This used to be valid for doing text pairs
        # We're keeping it working because of backward compatibility
        _SCREAMING_SNAKE_CASE									=			text_classifier([[["""HuggingFace is in """, """Paris is in France"""]]]       )
        self.assertEqual(
            nested_simplify(A       ) ,		[{"""label""": ANY(A       ), """score""": ANY(A       )}] ,		)
        self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()       )










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


lowercase_					= """Hello world! cécé herlolip"""


lowercase_					= 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						(     __lowerCamelCase :    Optional[Any]					,       __lowerCamelCase :    Union[str, Any]    )						->List[Any]:
    _SCREAMING_SNAKE_CASE									=			BertAbsConfig(
        temp_dir="""."""					,       finetune_bert=__lowerCamelCase					,       large=__lowerCamelCase					,       share_emb=__lowerCamelCase					,       use_bert_emb=__lowerCamelCase					,       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(__lowerCamelCase					,       lambda __lowerCamelCase					,       __lowerCamelCase    : storage    )
    _SCREAMING_SNAKE_CASE									=			AbsSummarizer(__lowerCamelCase					,       torch.device("""cpu"""    )					,       __lowerCamelCase    )
    original.eval()

    _SCREAMING_SNAKE_CASE									=			BertAbsSummarizer(__lowerCamelCase					,       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(__lowerCamelCase    ))    )
    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    ).unsqueeze(0    )
    _SCREAMING_SNAKE_CASE									=			tokenizer.encode("""This is sample 3 éàalj'-."""    )
    decoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(__lowerCamelCase    ))    )
    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    ).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(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase    )[0]
    _SCREAMING_SNAKE_CASE									=			original.generator(__lowerCamelCase    )

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

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

    _SCREAMING_SNAKE_CASE									=			torch.allclose(__lowerCamelCase					,       __lowerCamelCase					,       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__":
      lowercase_					= 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.""",
      )
      lowercase_					= parser.parse_args()

      convert_bertabs_checkpoints(
          args.bertabs_checkpoint_path,
          args.pytorch_dump_folder_path,
      )



