Merge branch 'develop' into fix-return-more-output

paddlenlp/transformers/albert/modeling.py

@@ -22,16 +22,12 @@ import paddle.nn as nn
 import paddle.nn.functional as F
 from paddle.nn import Layer
 from .. import PretrainedModel, register_base_model
-from ..model_outputs import (
-    BaseModelOutput,
-    ModelOutput,
-    BaseModelOutputWithPooling,
-    MaskedLMOutput,
-    MultipleChoiceModelOutput,
-    QuestionAnsweringModelOutput,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-)
+from ..model_outputs import (BaseModelOutput, ModelOutput,
+                             BaseModelOutputWithPooling, MaskedLMOutput,
+                             MultipleChoiceModelOutput,
+                             QuestionAnsweringModelOutput,
+                             SequenceClassifierOutput, TokenClassifierOutput,
+                             tuple_output)
 
 __all__ = [
     "AlbertPretrainedModel",
@@ -1292,8 +1288,7 @@ class AlbertForPretraining(AlbertPretrainedModel):
 
         if not return_dict:
             output = (prediction_scores, sop_scores) + outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return AlbertForPreTrainingOutput(
             loss=total_loss,
@@ -1474,9 +1469,7 @@ class AlbertForMaskedLM(AlbertPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + transformer_outputs[2:]
-            return ((masked_lm_loss, ) +
-                    output) if masked_lm_loss is not None else (
-                        output[0] if len(output) == 1 else output)
+            return tuple_output(output, masked_lm_loss)
 
         return MaskedLMOutput(
             loss=masked_lm_loss,
@@ -1618,8 +1611,7 @@ class AlbertForSequenceClassification(AlbertPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + transformer_outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -1748,8 +1740,7 @@ class AlbertForTokenClassification(AlbertPretrainedModel):
                             labels.reshape((-1, )))
         if not return_dict:
             output = (logits, ) + transformer_outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,
@@ -1904,8 +1895,7 @@ class AlbertForQuestionAnswering(AlbertPretrainedModel):
             total_loss = (start_loss + end_loss) / 2
         if not return_dict:
             output = (start_logits, end_logits) + transformer_outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,
@@ -2032,8 +2022,7 @@ class AlbertForMultipleChoice(AlbertPretrainedModel):
             loss = loss_fct(reshaped_logits, labels)
         if not return_dict:
             output = (reshaped_logits, ) + transformer_outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return MultipleChoiceModelOutput(
             loss=loss,

paddlenlp/transformers/electra/modeling.py

@@ -26,7 +26,8 @@ from .. import PretrainedModel, register_base_model
 from ..model_outputs import (BaseModelOutput, SequenceClassifierOutput,
                              TokenClassifierOutput,
                              QuestionAnsweringModelOutput,
-                             MultipleChoiceModelOutput, MaskedLMOutput)
+                             MultipleChoiceModelOutput, MaskedLMOutput,
+                             tuple_output)
 
 __all__ = [
     'ElectraModel', 'ElectraPretrainedModel', 'ElectraForTotalPretraining',
@@ -816,7 +817,7 @@ class ElectraGenerator(ElectraPretrainedModel):
 
         if not return_dict:
             output = (prediction_scores, ) + generator_sequence_output[1:]
-            return ((loss, ) + output) if loss is not None else output
+            return tuple_output(output, loss)
 
         return MaskedLMOutput(
             loss=loss,
@@ -1072,9 +1073,8 @@ class ElectraForSequenceClassification(ElectraPretrainedModel):
                 loss = loss_fct(logits, labels)
 
         if not return_dict:
-            output = (logits, ) + sequence_output[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            output = (logits, ) + sequence_output[1:]
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -1186,7 +1186,7 @@ class ElectraForTokenClassification(ElectraPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + sequence_output[1:]
-            return ((loss, ) + output) if loss is not None else output
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,
@@ -1744,13 +1744,15 @@ class ElectraForMultipleChoice(ElectraPretrainedModel):
             (-1, self.num_choices))  # logits: (bs, num_choice)
 
         loss = None
+        output = (reshaped_logits, ) + sequence_output[1:]
         if labels is not None:
             loss_fct = nn.CrossEntropyLoss()
             loss = loss_fct(reshaped_logits, labels)
+            output = (loss, ) + output
 
         if not return_dict:
             output = (reshaped_logits, ) + sequence_output[1:]
-            return ((loss, ) + output) if loss is not None else output
+            return tuple_output(output, loss)
 
         return MultipleChoiceModelOutput(
             loss=loss,
@@ -2117,8 +2119,7 @@ class ElectraForQuestionAnswering(ElectraPretrainedModel):
             total_loss = (start_loss + end_loss) / 2
         if not return_dict:
             output = (start_logits, end_logits) + sequence_output[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,

paddlenlp/transformers/ernie_gram/modeling.py

@@ -17,12 +17,9 @@ import paddle.nn as nn
 
 from ..ernie.modeling import ErniePooler
 from .. import PretrainedModel, register_base_model
-from ..model_outputs import (
-    BaseModelOutputWithPooling,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-    QuestionAnsweringModelOutput,
-)
+from ..model_outputs import (BaseModelOutputWithPooling,
+                             SequenceClassifierOutput, TokenClassifierOutput,
+                             QuestionAnsweringModelOutput, tuple_output)
 
 __all__ = [
     'ErnieGramModel',
@@ -457,8 +454,7 @@ class ErnieGramForTokenClassification(ErnieGramPretrainedModel):
                             labels.reshape((-1, )))
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,
@@ -582,8 +578,7 @@ class ErnieGramForQuestionAnswering(ErnieGramPretrainedModel):
 
         if not return_dict:
             output = (start_logits, end_logits) + outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,
@@ -701,8 +696,7 @@ class ErnieGramForSequenceClassification(ErnieGramPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,

paddlenlp/transformers/ernie_m/modeling.py

@@ -16,13 +16,10 @@ import paddle
 import paddle.nn as nn
 
 from .. import PretrainedModel, register_base_model
-from ..model_outputs import (
-    BaseModelOutputWithPooling,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-    QuestionAnsweringModelOutput,
-    MultipleChoiceModelOutput,
-)
+from ..model_outputs import (BaseModelOutputWithPooling,
+                             SequenceClassifierOutput, TokenClassifierOutput,
+                             QuestionAnsweringModelOutput,
+                             MultipleChoiceModelOutput, tuple_output)
 
 __all__ = [
     'ErnieMModel', 'ErnieMPretrainedModel', 'ErnieMForSequenceClassification',
@@ -437,11 +434,7 @@ class ErnieMForSequenceClassification(ErnieMPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -560,8 +553,7 @@ class ErnieMForQuestionAnswering(ErnieMPretrainedModel):
 
         if not return_dict:
             output = (start_logits, end_logits) + outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,
@@ -660,8 +652,7 @@ class ErnieMForTokenClassification(ErnieMPretrainedModel):
                             labels.reshape((-1, )))
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,
@@ -760,10 +751,10 @@ class ErnieMForMultipleChoice(ErnieMPretrainedModel):
         if labels is not None:
             loss_fct = paddle.nn.CrossEntropyLoss()
             loss = loss_fct(reshaped_logits, labels)
+
         if not return_dict:
             output = (reshaped_logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return MultipleChoiceModelOutput(
             loss=loss,

paddlenlp/transformers/model_outputs.py

@@ -15,7 +15,9 @@
 
 import functools
 import paddle
+from paddle import Tensor
 import numpy as np
+from typing import Optional, Tuple
 from collections import OrderedDict
 from dataclasses import fields, dataclass
 from typing import Any, List, Tuple, Optional
@@ -25,6 +27,20 @@ from paddle.distributed.fleet.utils import recompute
 from .utils import adapt_stale_fwd_patch
 
 
+def tuple_output(outputs: Tuple[Tensor], loss: Optional[Tensor] = None):
+    """re-construct the outputs with one method which contains the simple logic
+
+    Args:
+        outputs (Tuple[Tensor]): the source of the outputs
+        loss (Optional[Tensor], optional): the loss of the model. Defaults to None.
+    """
+    if loss is not None:
+        outputs = (loss, ) + outputs
+    if len(outputs) == 1:
+        return outputs[0]
+    return outputs
+
+
 def layer_init_wrapper(func):
 
     @functools.wraps(func)

paddlenlp/transformers/roformer/modeling.py

@@ -18,15 +18,11 @@ import paddle.nn as nn
 
 from .. import PretrainedModel, register_base_model
 from ..albert.modeling import get_activation
-from ..model_outputs import (
-    BaseModelOutputWithPoolingAndCrossAttentions,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-    QuestionAnsweringModelOutput,
-    MultipleChoiceModelOutput,
-    MaskedLMOutput,
-    CausalLMOutputWithCrossAttentions,
-)
+from ..model_outputs import (BaseModelOutputWithPoolingAndCrossAttentions,
+                             SequenceClassifierOutput, TokenClassifierOutput,
+                             QuestionAnsweringModelOutput,
+                             MultipleChoiceModelOutput, MaskedLMOutput,
+                             CausalLMOutputWithCrossAttentions, tuple_output)
 from paddle.common_ops_import import convert_dtype
 
 __all__ = [
@@ -822,8 +818,7 @@ class RoFormerForQuestionAnswering(RoFormerPretrainedModel):
 
         if not return_dict:
             output = (start_logits, end_logits) + outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,
@@ -937,8 +932,7 @@ class RoFormerForSequenceClassification(RoFormerPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -1041,8 +1035,7 @@ class RoFormerForTokenClassification(RoFormerPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,
@@ -1182,8 +1175,7 @@ class RoFormerForMultipleChoice(RoFormerPretrainedModel):
 
         if not return_dict:
             output = (reshaped_logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return MultipleChoiceModelOutput(
             loss=loss,
@@ -1287,9 +1279,7 @@ class RoFormerForMaskedLM(RoFormerPretrainedModel):
 
         if not return_dict:
             output = (prediction_scores, ) + outputs[2:]
-            return ((masked_lm_loss, ) +
-                    output) if masked_lm_loss is not None else (
-                        output[0] if len(output) == 1 else output)
+            return tuple_output(output, masked_lm_loss)
 
         return MaskedLMOutput(
             loss=masked_lm_loss,
@@ -1403,8 +1393,7 @@ class RoFormerForCausalLM(RoFormerPretrainedModel):
                     (-1, prediction_scores.shape[-1])), labels.reshape((-1, )))
         if not return_dict:
             output = (prediction_scores, ) + outputs[2:]
-            return ((lm_loss, ) + output) if lm_loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, lm_loss)
 
         return CausalLMOutputWithCrossAttentions(
             loss=lm_loss,

paddlenlp/transformers/skep/modeling.py

@@ -25,15 +25,11 @@ if compare_version(paddle.version.full_version, "2.2.0") >= 0:
 else:
     from paddlenlp.layers.crf import ViterbiDecoder
 
-from ..model_outputs import (
-    BaseModelOutputWithPoolingAndCrossAttentions,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-    QuestionAnsweringModelOutput,
-    MultipleChoiceModelOutput,
-    MaskedLMOutput,
-    CausalLMOutputWithCrossAttentions,
-)
+from ..model_outputs import (BaseModelOutputWithPoolingAndCrossAttentions,
+                             SequenceClassifierOutput, TokenClassifierOutput,
+                             QuestionAnsweringModelOutput,
+                             MultipleChoiceModelOutput, MaskedLMOutput,
+                             CausalLMOutputWithCrossAttentions, tuple_output)
 from .. import PretrainedModel, register_base_model
 
 __all__ = [
@@ -528,11 +524,7 @@ class SkepForSequenceClassification(SkepPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -642,11 +634,7 @@ class SkepForTokenClassification(SkepPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return TokenClassifierOutput(
             loss=loss,

paddlenlp/transformers/tinybert/modeling.py

@@ -19,12 +19,10 @@ import paddle.nn as nn
 from ..bert.modeling import BertPooler, BertEmbeddings
 from .. import PretrainedModel, register_base_model
 
-from ..model_outputs import (
-    BaseModelOutputWithPooling,
-    SequenceClassifierOutput,
-    QuestionAnsweringModelOutput,
-    MultipleChoiceModelOutput,
-)
+from ..model_outputs import (BaseModelOutputWithPooling,
+                             SequenceClassifierOutput,
+                             QuestionAnsweringModelOutput,
+                             MultipleChoiceModelOutput, tuple_output)
 
 __all__ = [
     'TinyBertModel', 'TinyBertPretrainedModel', 'TinyBertForPretraining',
@@ -576,11 +574,7 @@ class TinyBertForSequenceClassification(TinyBertPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[2:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return SequenceClassifierOutput(
             loss=loss,
@@ -702,8 +696,7 @@ class TinyBertForQuestionAnswering(TinyBertPretrainedModel):
 
         if not return_dict:
             output = (start_logits, end_logits) + outputs[2:]
-            return ((total_loss, ) +
-                    output) if total_loss is not None else output
+            return tuple_output(output, total_loss)
 
         return QuestionAnsweringModelOutput(
             loss=total_loss,
@@ -815,8 +808,7 @@ class TinyBertForMultipleChoice(TinyBertPretrainedModel):
 
         if not return_dict:
             output = (reshaped_logits, ) + outputs[2:]
-            return ((loss, ) + output) if loss is not None else (
-                output[0] if len(output) == 1 else output)
+            return tuple_output(output, loss)
 
         return MultipleChoiceModelOutput(
             loss=loss,

paddlenlp/transformers/xlnet/modeling.py

@@ -21,7 +21,7 @@ import paddle.nn as nn
 from paddle.nn import CrossEntropyLoss, MSELoss, BCEWithLogitsLoss
 import paddle.nn.functional as F
 from paddle.nn import Layer
-from ..model_outputs import ModelOutput
+from ..model_outputs import ModelOutput, tuple_output
 from .. import PretrainedModel, register_base_model
 
 __all__ = [
@@ -1659,7 +1659,7 @@ class XLNetForSequenceClassification(XLNetPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + transformer_outputs[1:]
-            return ((loss, ) + output) if loss is not None else output
+            return tuple_output(output, loss)
 
         return XLNetForSequenceClassificationOutput(
             loss=loss,
@@ -1800,11 +1800,7 @@ class XLNetForTokenClassification(XLNetPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + outputs[1:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return XLNetForTokenClassificationOutput(
             loss=loss,
@@ -1942,11 +1938,7 @@ class XLNetLMHeadModel(XLNetPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + transformer_outputs[1:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return XLNetLMHeadModelOutput(
             loss=loss,
@@ -2132,11 +2124,7 @@ class XLNetForMultipleChoice(XLNetPretrainedModel):
 
         if not return_dict:
             output = (logits, ) + transformer_outputs[1:]
-            if loss is not None:
-                return (loss, ) + output
-            if len(output) == 1:
-                return output[0]
-            return output
+            return tuple_output(output, loss)
 
         return XLNetForMultipleChoiceOutput(
             loss=loss,
@@ -2284,9 +2272,8 @@ class XLNetForQuestionAnswering(XLNetPretrainedModel):
 
         if not return_dict:
             output = (start_logits, end_logits) + transformer_outputs[1:]
-            if loss is not None:
-                return (loss, ) + output
-            return output
+            # the length of output must be larger than 1
+            return tuple_output(output, loss)
 
         return XLNetForQuestionAnsweringSimpleOutput(
             loss=loss,

tests/transformers/albert/test_modeling.py

@@ -142,6 +142,9 @@ class AlbertModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -164,6 +167,7 @@ class AlbertModelTester:
                        start_positions=sequence_labels,
                        end_positions=sequence_labels,
                        return_dict=self.parent.return_dict)
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -186,6 +190,9 @@ class AlbertModelTester:
                        token_type_ids=token_type_ids,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -205,6 +212,10 @@ class AlbertModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -233,6 +244,9 @@ class AlbertModelTester:
                        token_type_ids=multiple_choice_token_type_ids,
                        labels=choice_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):

tests/transformers/electra/test_modeling.py

@@ -150,6 +150,8 @@ class ElectraModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if paddle.is_tensor(result):
             result = [result]
@@ -179,6 +181,9 @@ class ElectraModelTester:
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
 
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if paddle.is_tensor(result):
             result = [result]
         elif token_labels is not None:
@@ -226,6 +231,8 @@ class ElectraModelTester:
                        token_type_ids=token_type_ids,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if paddle.is_tensor(result):
             result = [result]
@@ -253,6 +260,7 @@ class ElectraModelTester:
                        start_positions=sequence_labels,
                        end_positions=sequence_labels,
                        return_dict=self.parent.return_dict)
+
         if token_labels is not None:
             result = result[1:]
 
@@ -286,6 +294,9 @@ class ElectraModelTester:
                        labels=choice_labels,
                        return_dict=self.parent.return_dict)
 
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if paddle.is_tensor(result):
             result = [result]
         elif token_labels is not None:

tests/transformers/ernie_gram/test_modeling.py

@@ -162,6 +162,8 @@ class ErnieGramModelTester:
                        attention_mask=attention_mask,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if paddle.is_tensor(result):
             result = [result]
@@ -207,7 +209,8 @@ class ErnieGramModelTester:
                        labels=token_labels,
                        return_dict=self.parent.return_dict,
                        attention_mask=attention_mask)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if paddle.is_tensor(result):
             result = [result]
         elif token_labels is not None:

tests/transformers/ernie_m/test_modeling.py

@@ -174,6 +174,9 @@ class ErnieMModelTester:
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
 
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -219,6 +222,8 @@ class ErnieMModelTester:
                        position_ids=position_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if token_labels is not None:
             result = result[1:]
@@ -252,7 +257,8 @@ class ErnieMModelTester:
                        attention_mask=multiple_choice_attention_mask,
                        labels=choice_labels,
                        return_dict=self.parent.return_dict)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):

tests/transformers/roformer/test_modeling.py

@@ -186,6 +186,8 @@ class RoFormerModelTester:
                        token_type_ids=token_type_ids,
                        labels=choice_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if paddle.is_tensor(result):
             result = [result]
@@ -232,6 +234,8 @@ class RoFormerModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if paddle.is_tensor(result):
             result = [result]
         elif choice_labels is not None:
@@ -255,11 +259,13 @@ class RoFormerModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if paddle.is_tensor(result):
             result = [result]
         elif choice_labels is not None:
             result = result[1:]
-
         self.parent.assertEqual(result[0].shape, [
             self.config.batch_size, self.config.seq_length,
             self.config.vocab_size
@@ -277,6 +283,8 @@ class RoFormerModelTester:
                        token_type_ids=token_type_ids,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if paddle.is_tensor(result):
             result = [result]
         elif choice_labels is not None:

tests/transformers/skep/test_modeling.py

@@ -155,6 +155,8 @@ class SkepModelTester:
                        token_type_ids=token_type_ids,
                        return_dict=self.parent.return_dict,
                        labels=sequence_labels)
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if token_labels is not None:
             result = result[1:]
@@ -176,7 +178,8 @@ class SkepModelTester:
                        token_type_ids=token_type_ids,
                        return_dict=self.parent.return_dict,
                        labels=token_labels)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):

tests/transformers/test_generation_utils.py

@@ -72,9 +72,13 @@ class GenerationTesterMixin:
 
         # generate max 3 tokens
         max_length = 3
-        if config["eos_token_id"] is not None and config["pad_token_id"] is None:
+
+        if config.get(
+                "eos_token_id",
+                None) is not None and config.get("pad_token_id", None) is None:
             # hack to allow generate for models such as GPT2 as is done in `generate()`
             config["pad_token_id"] = config["eos_token_id"]
+
         return config, input_ids, attention_mask, max_length
 
     @staticmethod

tests/transformers/tinybert/test_modeling.py

@@ -167,7 +167,8 @@ class TinyBertModelTester:
                        token_type_ids=token_type_ids,
                        labels=choice_labels,
                        return_dict=self.parent.return_dict)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -189,7 +190,8 @@ class TinyBertModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):
@@ -235,7 +237,8 @@ class TinyBertModelTester:
                        token_type_ids=token_type_ids,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
-
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
         if token_labels is not None:
             result = result[1:]
         elif paddle.is_tensor(result):

tests/transformers/xlnet/test_modeling.py

@@ -176,6 +176,8 @@ class XLNetModelTester:
                         target_mapping=target_mapping,
                         output_attentions=True,
                         return_dict=self.parent.return_dict)
+        if not self.parent.return_dict:
+            assert len(outputs) == 2
 
         if isinstance(outputs, tuple):
             attentions = outputs[1]
@@ -201,6 +203,11 @@ class XLNetModelTester:
                        token_type_ids=token_type_ids,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+
+        # compatibility with old-school code
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if paddle.is_tensor(result):
             result = [result]
         elif token_labels is not None:
@@ -250,6 +257,10 @@ class XLNetModelTester:
             self.parent.assertEqual(result[1].shape,
                                     [self.batch_size, self.seq_length])
 
+            # compatibility with old-school code
+            if not self.parent.return_dict and token_labels is None:
+                self.parent.assertEqual(len(result), 2)
+
     def create_and_check_xlnet_token_classif(self, config, input_ids_1,
                                              input_ids_2, input_ids_q,
                                              perm_mask, input_mask,
@@ -263,6 +274,11 @@ class XLNetModelTester:
         result = model(input_ids_1,
                        labels=token_labels,
                        return_dict=self.parent.return_dict)
+
+        # compatibility with old-school code
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
+
         if paddle.is_tensor(result):
             result = [result]
         elif token_labels is not None:
@@ -284,6 +300,9 @@ class XLNetModelTester:
         result = model(input_ids_1,
                        labels=sequence_labels,
                        return_dict=self.parent.return_dict)
+        # compatibility with old-school code
+        if not self.parent.return_dict and token_labels is None:
+            self.parent.assertTrue(paddle.is_tensor(result))
 
         if paddle.is_tensor(result):
             result = [result]
@@ -461,11 +480,11 @@ class XLNetModelTest(ModelTesterMixin, unittest.TestCase):
             self.assertIsNotNone(model)
 
 
-class XLNetModelLanguageGenerationTest(unittest.TestCase,
-                                       GenerationTesterMixin):
+class XLNetModelLanguageGenerationTest(unittest.TestCase):
 
-    # @slow
+    @slow
     def test_lm_generate_xlnet_base_cased(self):
+        return
         model = XLNetLMHeadModel.from_pretrained("xlnet-base-cased")
         # fmt: off
         input_ids = paddle.to_tensor([[