codingutf8 2021 the facebook ai research team and the huggingface inc team 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 orglicenseslicense2 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 mbart model configuration from collections import ordereddict from typing import any mapping optional from import pretrainedtokenizer from configurationutils import pretrainedconfig from onnx import onnxconfig onnxconfigwithpast onnxseq2seqconfigwithpast from onnx utils import computeeffectiveaxisdimension from utils import tensortype istorchavailable logging logger logging getloggername mbartpretrainedconfigarchivemap facebookmbartlargecc25 https huggingface cofacebookmbartlargecc25resolvemainconfig json see all mbart models at https huggingface comodels filtermbart class mbartconfigpretrainedconfig r this is the configuration class to store the configuration of a mbartmodel it is used to instantiate an mbart model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the mbart facebookmbartlargecc25https huggingface cofacebookmbartlargecc25 architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args vocabsize int optional defaults to 50265 vocabulary size of the mbart model defines the number of different tokens that can be represented by the inputsids passed when calling mbartmodel or tfmbartmodel dmodel int optional defaults to 1024 dimensionality of the layers and the pooler layer encoderlayers int optional defaults to 12 number of encoder layers decoderlayers int optional defaults to 12 number of decoder layers encoderattentionheads int optional defaults to 16 number of attention heads for each attention layer in the transformer encoder decoderattentionheads int optional defaults to 16 number of attention heads for each attention layer in the transformer decoder decoderffndim int optional defaults to 4096 dimensionality of the intermediate often named feedforward layer in decoder encoderffndim int optional defaults to 4096 dimensionality of the intermediate often named feedforward layer in decoder activationfunction str or function optional defaults to gelu the nonlinear activation function function or string in the encoder and pooler if string gelu relu silu and gelunew are supported dropout float optional defaults to 0 1 the dropout probability for all fully connected layers in the embeddings encoder and pooler attentiondropout float optional defaults to 0 0 the dropout ratio for the attention probabilities activationdropout float optional defaults to 0 0 the dropout ratio for activations inside the fully connected layer classifierdropout float optional defaults to 0 0 the dropout ratio for classifier maxpositionembeddings int optional defaults to 1024 the maximum sequence length that this model might ever be used with typically set this to something large just in case e g 512 or 1024 or 2048 initstd float optional defaults to 0 02 the standard deviation of the truncatednormalinitializer for initializing all weight matrices encoderlayerdrop float optional defaults to 0 0 the layerdrop probability for the encoder see the layerdrop papersee https arxiv orgabs1909 11556 for more details decoderlayerdrop float optional defaults to 0 0 the layerdrop probability for the decoder see the layerdrop papersee https arxiv orgabs1909 11556 for more details scaleembedding bool optional defaults to false scale embeddings by diving by sqrtdmodel usecache bool optional defaults to true whether or not the model should return the last keyvalues attentions not used by all models forcedeostokenid int optional defaults to 2 the id of the token to force as the last generated token when maxlength is reached usually set to eostokenid example python from transformers import mbartconfig mbartmodel initializing a mbart facebookmbartlargecc25 style configuration configuration mbartconfig initializing a model with random weights from the facebookmbartlargecc25 style configuration model mbartmodelconfiguration accessing the model configuration configuration model config modeltype mbart keystoignoreatinference pastkeyvalues attributemap numattentionheads encoderattentionheads hiddensize dmodel def init self vocabsize50265 maxpositionembeddings1024 encoderlayers12 encoderffndim4096 encoderattentionheads16 decoderlayers12 decoderffndim4096 decoderattentionheads16 encoderlayerdrop0 0 decoderlayerdrop0 0 usecachetrue isencoderdecodertrue activationfunctiongelu dmodel1024 dropout0 1 attentiondropout0 0 activationdropout0 0 initstd0 02 classifierdropout0 0 scaleembeddingfalse padtokenid1 bostokenid0 eostokenid2 forcedeostokenid2 kwargs self vocabsize vocabsize self maxpositionembeddings maxpositionembeddings self dmodel dmodel self encoderffndim encoderffndim self encoderlayers encoderlayers self encoderattentionheads encoderattentionheads self decoderffndim decoderffndim self decoderlayers decoderlayers self decoderattentionheads decoderattentionheads self dropout dropout self attentiondropout attentiondropout self activationdropout activationdropout self activationfunction activationfunction self initstd initstd self encoderlayerdrop encoderlayerdrop self decoderlayerdrop decoderlayerdrop self classifierdropout classifierdropout self usecache usecache self numhiddenlayers encoderlayers self scaleembedding scaleembedding scale factor will be sqrtdmodel if true super init padtokenidpadtokenid bostokenidbostokenid eostokenideostokenid isencoderdecoderisencoderdecoder forcedeostokenidforcedeostokenid kwargs copied from transformers models bart configurationbart bartonnxconfig with bartmbart class mbartonnxconfigonnxseq2seqconfigwithpast property def inputsself mappingstr mappingint str if self task in default seq2seqlm commoninputs ordereddict inputids 0 batch 1 encodersequence attentionmask 0 batch 1 encodersequence if self usepast commoninputsdecoderinputids 0 batch commoninputsdecoderattentionmask 0 batch 1 pastdecodersequence sequence else commoninputsdecoderinputids 0 batch 1 decodersequence commoninputsdecoderattentionmask 0 batch 1 decodersequence if self usepast self fillwithpastkeyvaluescommoninputs directioninputs elif self task causallm todo figure this case out commoninputs ordereddict inputids 0 batch 1 encodersequence attentionmask 0 batch 1 encodersequence if self usepast numencoderlayers self numlayers for i in rangenumencoderlayers commoninputsfpastkeyvalues i key 0 batch 2 pastsequence sequence commoninputsfpastkeyvalues i value 0 batch 2 pastsequence sequence else commoninputs ordereddict inputids 0 batch 1 encodersequence attentionmask 0 batch 1 encodersequence decoderinputids 0 batch 1 decodersequence decoderattentionmask 0 batch 1 decodersequence return commoninputs property def outputsself mappingstr mappingint str if self task in default seq2seqlm commonoutputs super outputs else commonoutputs superonnxconfigwithpast self outputs if self usepast numencoderlayers self numlayers for i in rangenumencoderlayers commonoutputsfpresent i key 0 batch 2 pastsequence sequence commonoutputsfpresent i value 0 batch 2 pastsequence sequence return commonoutputs def generatedummyinputsfordefaultandseq2seqlm self tokenizer pretrainedtokenizer batchsize int 1 seqlength int 1 ispair bool false framework optionaltensortype none mappingstr any encoderinputs self generatedummyinputsforsequenceclassificationandquestionanswering tokenizer batchsize seqlength ispair framework generate decoder inputs decoderseqlength seqlength if not self usepast else 1 decoderinputs self generatedummyinputsforsequenceclassificationandquestionanswering tokenizer batchsize decoderseqlength ispair framework decoderinputs fdecodername tensor for name tensor in decoderinputs items commoninputs dictencoderinputs decoderinputs if self usepast if not istorchavailable raise valueerrorcannot generate dummy pastkeys inputs without pytorch installed else import torch batch encoderseqlength commoninputsinputids shape decoderseqlength commoninputsdecoderinputids shape1 numencoderattentionheads numdecoderattentionheads self numattentionheads encodershape batch numencoderattentionheads encoderseqlength self config hiddensize numencoderattentionheads decoderpastlength decoderseqlength 3 decodershape batch numdecoderattentionheads decoderpastlength self config hiddensize numdecoderattentionheads commoninputsdecoderattentionmask torch cat commoninputsdecoderattentionmask torch onesbatch decoderpastlength dim1 commoninputspastkeyvalues if the number of encoder and decoder layers are present in the model configuration both are considered numencoderlayers numdecoderlayers self numlayers minnumlayers minnumencoderlayers numdecoderlayers maxnumlayers maxnumencoderlayers numdecoderlayers minnumlayers remainingsidename encoder if numencoderlayers numdecoderlayers else decoder for in rangeminnumlayers commoninputspastkeyvalues append torch zerosdecodershape torch zerosdecodershape torch zerosencodershape torch zerosencodershape todo test this shape encodershape if remainingsidename encoder else decodershape for in rangeminnumlayers maxnumlayers commoninputspastkeyvalues appendtorch zerosshape torch zerosshape return commoninputs def generatedummyinputsforcausallm self tokenizer pretrainedtokenizer batchsize int 1 seqlength int 1 ispair bool false framework optionaltensortype none mappingstr any commoninputs self generatedummyinputsforsequenceclassificationandquestionanswering tokenizer batchsize seqlength ispair framework if self usepast if not istorchavailable raise valueerrorcannot generate dummy pastkeys inputs without pytorch installed else import torch batch seqlen commoninputsinputids shape not using the same length for pastkeyvalues pastkeyvalueslength seqlen 2 numencoderlayers self numlayers numencoderattentionheads self numattentionheads pastshape batch numencoderattentionheads pastkeyvalueslength self config hiddensize numencoderattentionheads maskdtype commoninputsattentionmask dtype commoninputsattentionmask torch cat commoninputsattentionmask torch onesbatch pastkeyvalueslength dtypemaskdtype dim1 commoninputspastkeyvalues torch zerospastshape torch zerospastshape for in rangenumencoderlayers return commoninputs def generatedummyinputsforsequenceclassificationandquestionanswering self tokenizer pretrainedtokenizer batchsize int 1 seqlength int 1 ispair bool false framework optionaltensortype none mappingstr any copied from onnxconfig generatedummyinputs did not use superonnxconfigwithpast self generatedummyinputs for code clarity if dynamic axis 1 we forward with a fixed dimension of 2 samples to avoid optimizations made by onnx batchsize computeeffectiveaxisdimension batchsize fixeddimensiononnxconfig defaultfixedbatch numtokentoadd0 if dynamic axis 1 we forward with a fixed dimension of 8 tokens to avoid optimizations made by onnx tokentoadd tokenizer numspecialtokenstoaddispair seqlength computeeffectiveaxisdimension seqlength fixeddimensiononnxconfig defaultfixedsequence numtokentoaddtokentoadd generate dummy inputs according to compute batch and sequence dummyinput jointokenizer unktoken seqlength batchsize commoninputs dicttokenizerdummyinput returntensorsframework return commoninputs def generatedummyinputs self tokenizer pretrainedtokenizer batchsize int 1 seqlength int 1 ispair bool false framework optionaltensortype none mappingstr any if self task in default seq2seqlm commoninputs self generatedummyinputsfordefaultandseq2seqlm tokenizer batchsizebatchsize seqlengthseqlength ispairispair frameworkframework elif self task causallm commoninputs self generatedummyinputsforcausallm tokenizer batchsizebatchsize seqlengthseqlength ispairispair frameworkframework else commoninputs self generatedummyinputsforsequenceclassificationandquestionanswering tokenizer batchsizebatchsize seqlengthseqlength ispairispair frameworkframework return commoninputs def flattenpastkeyvaluesself flattenedoutput name idx t if self task in default seq2seqlm flattenedoutput super flattenpastkeyvaluesflattenedoutput name idx t else flattenedoutput superonnxseq2seqconfigwithpast self flattenpastkeyvalues flattenedoutput name idx t coding utf 8 2021 the facebook ai research team and the huggingface inc team 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 mbart model configuration see all mbart models at https huggingface co models filter mbart this is the configuration class to store the configuration of a mbartmodel it is used to instantiate an mbart model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the mbart facebook mbart large cc25 https huggingface co facebook mbart large cc25 architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args vocab_size int optional defaults to 50265 vocabulary size of the mbart model defines the number of different tokens that can be represented by the inputs_ids passed when calling mbartmodel or tfmbartmodel d_model int optional defaults to 1024 dimensionality of the layers and the pooler layer encoder_layers int optional defaults to 12 number of encoder layers decoder_layers int optional defaults to 12 number of decoder layers encoder_attention_heads int optional defaults to 16 number of attention heads for each attention layer in the transformer encoder decoder_attention_heads int optional defaults to 16 number of attention heads for each attention layer in the transformer decoder decoder_ffn_dim int optional defaults to 4096 dimensionality of the intermediate often named feed forward layer in decoder encoder_ffn_dim int optional defaults to 4096 dimensionality of the intermediate often named feed forward layer in decoder activation_function str or function optional defaults to gelu the non linear activation function function or string in the encoder and pooler if string gelu relu silu and gelu_new are supported dropout float optional defaults to 0 1 the dropout probability for all fully connected layers in the embeddings encoder and pooler attention_dropout float optional defaults to 0 0 the dropout ratio for the attention probabilities activation_dropout float optional defaults to 0 0 the dropout ratio for activations inside the fully connected layer classifier_dropout float optional defaults to 0 0 the dropout ratio for classifier max_position_embeddings int optional defaults to 1024 the maximum sequence length that this model might ever be used with typically set this to something large just in case e g 512 or 1024 or 2048 init_std float optional defaults to 0 02 the standard deviation of the truncated_normal_initializer for initializing all weight matrices encoder_layerdrop float optional defaults to 0 0 the layerdrop probability for the encoder see the layerdrop paper see https arxiv org abs 1909 11556 for more details decoder_layerdrop float optional defaults to 0 0 the layerdrop probability for the decoder see the layerdrop paper see https arxiv org abs 1909 11556 for more details scale_embedding bool optional defaults to false scale embeddings by diving by sqrt d_model use_cache bool optional defaults to true whether or not the model should return the last key values attentions not used by all models forced_eos_token_id int optional defaults to 2 the id of the token to force as the last generated token when max_length is reached usually set to eos_token_id example python from transformers import mbartconfig mbartmodel initializing a mbart facebook mbart large cc25 style configuration configuration mbartconfig initializing a model with random weights from the facebook mbart large cc25 style configuration model mbartmodel configuration accessing the model configuration configuration model config scale factor will be sqrt d_model if true copied from transformers models bart configuration_bart bartonnxconfig with bart mbart todo figure this case out generate decoder inputs if the number of encoder and decoder layers are present in the model configuration both are considered todo test this not using the same length for past_key_values copied from onnxconfig generate_dummy_inputs did not use super onnxconfigwithpast self generate_dummy_inputs for code clarity if dynamic axis 1 we forward with a fixed dimension of 2 samples to avoid optimizations made by onnx if dynamic axis 1 we forward with a fixed dimension of 8 tokens to avoid optimizations made by onnx generate dummy inputs according to compute batch and sequence
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeq2SeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


logger = logging.get_logger(__name__)

MBART_PRETRAINED_CONFIG_ARCHIVE_MAP = {
    "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json",
    
}


class MBartConfig(PretrainedConfig):
    r

    model_type = "mbart"
    keys_to_ignore_at_inference = ["past_key_values"]
    attribute_map = {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}

    def __init__(
        self,
        vocab_size=50265,
        max_position_embeddings=1024,
        encoder_layers=12,
        encoder_ffn_dim=4096,
        encoder_attention_heads=16,
        decoder_layers=12,
        decoder_ffn_dim=4096,
        decoder_attention_heads=16,
        encoder_layerdrop=0.0,
        decoder_layerdrop=0.0,
        use_cache=True,
        is_encoder_decoder=True,
        activation_function="gelu",
        d_model=1024,
        dropout=0.1,
        attention_dropout=0.0,
        activation_dropout=0.0,
        init_std=0.02,
        classifier_dropout=0.0,
        scale_embedding=False,
        pad_token_id=1,
        bos_token_id=0,
        eos_token_id=2,
        forced_eos_token_id=2,
        **kwargs,
    ):
        self.vocab_size = vocab_size
        self.max_position_embeddings = max_position_embeddings
        self.d_model = d_model
        self.encoder_ffn_dim = encoder_ffn_dim
        self.encoder_layers = encoder_layers
        self.encoder_attention_heads = encoder_attention_heads
        self.decoder_ffn_dim = decoder_ffn_dim
        self.decoder_layers = decoder_layers
        self.decoder_attention_heads = decoder_attention_heads
        self.dropout = dropout
        self.attention_dropout = attention_dropout
        self.activation_dropout = activation_dropout
        self.activation_function = activation_function
        self.init_std = init_std
        self.encoder_layerdrop = encoder_layerdrop
        self.decoder_layerdrop = decoder_layerdrop
        self.classifier_dropout = classifier_dropout
        self.use_cache = use_cache
        self.num_hidden_layers = encoder_layers
        self.scale_embedding = scale_embedding  
        super().__init__(
            pad_token_id=pad_token_id,
            bos_token_id=bos_token_id,
            eos_token_id=eos_token_id,
            is_encoder_decoder=is_encoder_decoder,
            forced_eos_token_id=forced_eos_token_id,
            **kwargs,
        )



class MBartOnnxConfig(OnnxSeq2SeqConfigWithPast):
    @property
    def inputs(self) -> Mapping[str, Mapping[int, str]]:
        if self.task in ["default", "seq2seq-lm"]:
            common_inputs = OrderedDict(
                [
                    ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                    ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                ]
            )

            if self.use_past:
                common_inputs["decoder_input_ids"] = {0: "batch"}
                common_inputs["decoder_attention_mask"] = {0: "batch", 1: "past_decoder_sequence + sequence"}
            else:
                common_inputs["decoder_input_ids"] = {0: "batch", 1: "decoder_sequence"}
                common_inputs["decoder_attention_mask"] = {0: "batch", 1: "decoder_sequence"}

            if self.use_past:
                self.fill_with_past_key_values_(common_inputs, direction="inputs")
        elif self.task == "causal-lm":
            
            common_inputs = OrderedDict(
                [
                    ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                    ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                ]
            )
            if self.use_past:
                num_encoder_layers, _ = self.num_layers
                for i in range(num_encoder_layers):
                    common_inputs[f"past_key_values.{i}.key"] = {0: "batch", 2: "past_sequence + sequence"}
                    common_inputs[f"past_key_values.{i}.value"] = {0: "batch", 2: "past_sequence + sequence"}
        else:
            common_inputs = OrderedDict(
                [
                    ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                    ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                    ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                    ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
                ]
            )

        return common_inputs

    @property
    def outputs(self) -> Mapping[str, Mapping[int, str]]:
        if self.task in ["default", "seq2seq-lm"]:
            common_outputs = super().outputs
        else:
            common_outputs = super(OnnxConfigWithPast, self).outputs
            if self.use_past:
                num_encoder_layers, _ = self.num_layers
                for i in range(num_encoder_layers):
                    common_outputs[f"present.{i}.key"] = {0: "batch", 2: "past_sequence + sequence"}
                    common_outputs[f"present.{i}.value"] = {0: "batch", 2: "past_sequence + sequence"}
        return common_outputs

    def _generate_dummy_inputs_for_default_and_seq2seq_lm(
        self,
        tokenizer: PreTrainedTokenizer,
        batch_size: int = -1,
        seq_length: int = -1,
        is_pair: bool = False,
        framework: Optional[TensorType] = None,
    ) -> Mapping[str, Any]:
        encoder_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            tokenizer, batch_size, seq_length, is_pair, framework
        )

        
        decoder_seq_length = seq_length if not self.use_past else 1
        decoder_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            tokenizer, batch_size, decoder_seq_length, is_pair, framework
        )
        decoder_inputs = {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
        common_inputs = dict(**encoder_inputs, **decoder_inputs)

        if self.use_past:
            if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
            else:
                import torch
            batch, encoder_seq_length = common_inputs["input_ids"].shape
            decoder_seq_length = common_inputs["decoder_input_ids"].shape[1]
            num_encoder_attention_heads, num_decoder_attention_heads = self.num_attention_heads
            encoder_shape = (
                batch,
                num_encoder_attention_heads,
                encoder_seq_length,
                self._config.hidden_size // num_encoder_attention_heads,
            )
            decoder_past_length = decoder_seq_length + 3
            decoder_shape = (
                batch,
                num_decoder_attention_heads,
                decoder_past_length,
                self._config.hidden_size // num_decoder_attention_heads,
            )

            common_inputs["decoder_attention_mask"] = torch.cat(
                [common_inputs["decoder_attention_mask"], torch.ones(batch, decoder_past_length)], dim=1
            )

            common_inputs["past_key_values"] = []
            
            num_encoder_layers, num_decoder_layers = self.num_layers
            min_num_layers = min(num_encoder_layers, num_decoder_layers)
            max_num_layers = max(num_encoder_layers, num_decoder_layers) - min_num_layers
            remaining_side_name = "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

            for _ in range(min_num_layers):
                common_inputs["past_key_values"].append(
                    (
                        torch.zeros(decoder_shape),
                        torch.zeros(decoder_shape),
                        torch.zeros(encoder_shape),
                        torch.zeros(encoder_shape),
                    )
                )
            
            shape = encoder_shape if remaining_side_name == "encoder" else decoder_shape
            for _ in range(min_num_layers, max_num_layers):
                common_inputs["past_key_values"].append((torch.zeros(shape), torch.zeros(shape)))
        return common_inputs

    def _generate_dummy_inputs_for_causal_lm(
        self,
        tokenizer: PreTrainedTokenizer,
        batch_size: int = -1,
        seq_length: int = -1,
        is_pair: bool = False,
        framework: Optional[TensorType] = None,
    ) -> Mapping[str, Any]:
        common_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            tokenizer, batch_size, seq_length, is_pair, framework
        )

        if self.use_past:
            if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
            else:
                import torch
            batch, seqlen = common_inputs["input_ids"].shape
            
            past_key_values_length = seqlen + 2
            num_encoder_layers, _ = self.num_layers
            num_encoder_attention_heads, _ = self.num_attention_heads
            past_shape = (
                batch,
                num_encoder_attention_heads,
                past_key_values_length,
                self._config.hidden_size // num_encoder_attention_heads,
            )

            mask_dtype = common_inputs["attention_mask"].dtype
            common_inputs["attention_mask"] = torch.cat(
                [common_inputs["attention_mask"], torch.ones(batch, past_key_values_length, dtype=mask_dtype)], dim=1
            )
            common_inputs["past_key_values"] = [
                (torch.zeros(past_shape), torch.zeros(past_shape)) for _ in range(num_encoder_layers)
            ]
        return common_inputs

    def _generate_dummy_inputs_for_sequence_classification_and_question_answering(
        self,
        tokenizer: PreTrainedTokenizer,
        batch_size: int = -1,
        seq_length: int = -1,
        is_pair: bool = False,
        framework: Optional[TensorType] = None,
    ) -> Mapping[str, Any]:
        
        
        
        batch_size = compute_effective_axis_dimension(
            batch_size, fixed_dimension=OnnxConfig.default_fixed_batch, num_token_to_add=0
        )

        
        token_to_add = tokenizer.num_special_tokens_to_add(is_pair)
        seq_length = compute_effective_axis_dimension(
            seq_length, fixed_dimension=OnnxConfig.default_fixed_sequence, num_token_to_add=token_to_add
        )

        
        dummy_input = [" ".join([tokenizer.unk_token]) * seq_length] * batch_size
        common_inputs = dict(tokenizer(dummy_input, return_tensors=framework))
        return common_inputs

    def generate_dummy_inputs(
        self,
        tokenizer: PreTrainedTokenizer,
        batch_size: int = -1,
        seq_length: int = -1,
        is_pair: bool = False,
        framework: Optional[TensorType] = None,
    ) -> Mapping[str, Any]:
        if self.task in ["default", "seq2seq-lm"]:
            common_inputs = self._generate_dummy_inputs_for_default_and_seq2seq_lm(
                tokenizer, batch_size=batch_size, seq_length=seq_length, is_pair=is_pair, framework=framework
            )

        elif self.task == "causal-lm":
            common_inputs = self._generate_dummy_inputs_for_causal_lm(
                tokenizer, batch_size=batch_size, seq_length=seq_length, is_pair=is_pair, framework=framework
            )
        else:
            common_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                tokenizer, batch_size=batch_size, seq_length=seq_length, is_pair=is_pair, framework=framework
            )

        return common_inputs

    def _flatten_past_key_values_(self, flattened_output, name, idx, t):
        if self.task in ["default", "seq2seq-lm"]:
            flattened_output = super()._flatten_past_key_values_(flattened_output, name, idx, t)
        else:
            flattened_output = super(OnnxSeq2SeqConfigWithPast, self)._flatten_past_key_values_(
                flattened_output, name, idx, t
            )