fix_loss_args_legacy

Author: zty-king

python/paddle/nn/layer/loss.py

@@ -19,6 +19,7 @@
 import paddle
 from paddle import base, in_dynamic_mode
 from paddle.base.framework import in_dynamic_or_pir_mode
+from paddle.nn.layer.utils import check_deprecated_params
 from paddle.utils.decorator_utils import ParamAliasDecorator
 
 from .. import functional as F
@@ -36,6 +37,7 @@
 __all__ = []
 
 
+@check_deprecated_params
 class BCEWithLogitsLoss(Layer):
     r"""
 
@@ -151,6 +153,7 @@ def forward(self, logit: Tensor, label: Tensor) -> Tensor:
         return out
 
 
+@check_deprecated_params
 class CrossEntropyLoss(Layer):
     r"""
 
@@ -603,6 +606,7 @@ def forward(
         return out
 
 
+@check_deprecated_params
 class MSELoss(Layer):
     r"""
     **Mean Square Error Loss**
@@ -688,6 +692,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         return paddle.mean(square_out)
 
 
+@check_deprecated_params
 class L1Loss(Layer):
     r"""
 
@@ -776,6 +781,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class BCELoss(Layer):
     """
 
@@ -872,6 +878,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         return out
 
 
+@check_deprecated_params
 class NLLLoss(Layer):
     r"""
 
@@ -989,6 +996,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class PoissonNLLLoss(Layer):
     r"""Generate a callable object of 'PoissonNLLLoss' to calculate the
     Poisson negative log likelihood loss between Input(input) and
@@ -1084,6 +1092,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class KLDivLoss(Layer):
     r"""
 
@@ -1191,6 +1200,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         return out
 
 
+@check_deprecated_params
 class MarginRankingLoss(Layer):
     r"""
 
@@ -1460,6 +1470,7 @@ def forward(
         )
 
 
+@check_deprecated_params
 class SmoothL1Loss(Layer):
     r"""
     This operator calculates smooth_l1_loss. Creates a criterion that uses a squared
@@ -1548,6 +1559,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class MultiLabelSoftMarginLoss(Layer):
     r"""Creates a criterion that optimizes a multi-class multi-classification
     hinge loss (margin-based loss) between input :math:`x` (a 2D mini-batch `Tensor`)
@@ -1638,6 +1650,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class HingeEmbeddingLoss(Layer):
     r"""
     Create a callable object of `HingeEmbeddingLoss` to calculates hinge_embedding_loss. Measures the loss given an input tensor :math:`x` and a labels tensor :math:`y`(containing 1 or -1).
@@ -1745,6 +1758,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class CosineEmbeddingLoss(Layer):
     r"""
     This interface is used to construct a callable object of the ``CosineEmbeddingLoss`` class.
@@ -1975,6 +1989,7 @@ def forward(
         )
 
 
+@check_deprecated_params
 class TripletMarginLoss(Layer):
     r"""
     Creates a criterion that measures the triplet loss given an input
@@ -2097,6 +2112,7 @@ def forward(
         )
 
 
+@check_deprecated_params
 class MultiMarginLoss(Layer):
     r"""Creates a criterion that optimizes a multi-class classification hinge loss (margin-based loss) between
     input :math:`input` and label :math:`label`:
@@ -2207,6 +2223,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class MultiLabelMarginLoss(Layer):
     r"""Creates a criterion that optimizes a multi-class multi-classification hinge loss (margin-based loss)
     between input :math:`input` and label :math:`label`:
@@ -2293,6 +2310,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
         )
 
 
+@check_deprecated_params
 class SoftMarginLoss(Layer):
     r"""
 

python/paddle/nn/layer/utils.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+import functools
+
+_SENTINEL = object()
+
+
+def compute_legacy_reduction(reduce_val, size_average_val):
+    if reduce_val is False:
+        return 'none'
+    if reduce_val is True:
+        return 'sum' if size_average_val is False else 'mean'
+    return 'sum' if size_average_val is False else 'mean'
+
+
+def check_deprecated_params(cls):
+    """
+    Class decorator: intercept deprecated 'reduce' and 'size_average' kwargs.
+    - If provided by user, raise ValueError immediately with the suggested
+      'reduction' value.
+    - Pop these keys so that future policies (e.g., warn-and-continue) won't
+      pass unknown kwargs into the original __init__.
+    """
+    original_init = cls.__init__
+
+    @functools.wraps(original_init)
+    def new_init(self, *args, **kwargs):
+        reduce_raw = kwargs.pop('reduce', _SENTINEL)
+        size_avg_raw = kwargs.pop('size_average', _SENTINEL)
+
+        has_reduce = reduce_raw is not _SENTINEL
+        has_size_avg = size_avg_raw is not _SENTINEL
+
+        if has_reduce or has_size_avg:
+            reduce_val = None if reduce_raw is _SENTINEL else reduce_raw
+            size_avg_val = None if size_avg_raw is _SENTINEL else size_avg_raw
+            suggested = compute_legacy_reduction(reduce_val, size_avg_val)
+            raise ValueError(
+                f"{cls.__name__} no longer supports 'reduce' and 'size_average'."
+                f"\nDetected: reduce={reduce_val}, size_average={size_avg_val}"
+                f"\nPlease use: reduction='{suggested}' instead."
+            )
+
+        return original_init(self, *args, **kwargs)
+
+    cls.__init__ = new_init
+    return cls

test/legacy_test/CMakeLists.txt

@@ -873,6 +873,7 @@ endif()
 
 set_tests_properties(test_profiler PROPERTIES TIMEOUT 120)
 set_tests_properties(test_cross_entropy_loss PROPERTIES TIMEOUT 180)
+set_tests_properties(test_legacy_loss_args PROPERTIES TIMEOUT 30)
 set_tests_properties(test_activation_nn_grad PROPERTIES TIMEOUT 250)
 set_tests_properties(test_empty_op PROPERTIES TIMEOUT 120)
 set_tests_properties(test_elementwise_div_op PROPERTIES TIMEOUT 120)

test/legacy_test/test_legacy_loss_args.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+import unittest
+
+import paddle
+from paddle.nn import (
+    BCELoss,
+    BCEWithLogitsLoss,
+    CosineEmbeddingLoss,
+    CrossEntropyLoss,
+    HingeEmbeddingLoss,
+    KLDivLoss,
+    L1Loss,
+    MarginRankingLoss,
+    MSELoss,
+    MultiLabelMarginLoss,
+    MultiLabelSoftMarginLoss,
+    MultiMarginLoss,
+    NLLLoss,
+    PoissonNLLLoss,
+    SmoothL1Loss,
+    SoftMarginLoss,
+    TripletMarginLoss,
+)
+
+
+class TestLegacyLossArgs(unittest.TestCase):
+    def assertSuggests(self, loss_ctor, expected_reduction, **legacy_kwargs):
+        with self.assertRaises(ValueError) as cm:
+            loss_ctor(**legacy_kwargs)
+        msg = str(cm.exception)
+        self.assertIn(f"reduction='{expected_reduction}'", msg)
+
+    def test_no_legacy_all_constructible(self):
+        # Ensure all 17 losses still construct with reduction only
+        ctors = [
+            L1Loss,
+            NLLLoss,
+            PoissonNLLLoss,
+            KLDivLoss,
+            MSELoss,
+            BCELoss,
+            BCEWithLogitsLoss,
+            HingeEmbeddingLoss,
+            MultiLabelMarginLoss,
+            SmoothL1Loss,
+            SoftMarginLoss,
+            CrossEntropyLoss,
+            MultiLabelSoftMarginLoss,
+            CosineEmbeddingLoss,
+            MarginRankingLoss,
+            MultiMarginLoss,
+            TripletMarginLoss,
+        ]
+        for ctor in ctors:
+            _ = ctor(reduction='mean')
+
+    def test_no_args_all_constructible_with_defaults(self):
+        # Ensure all 17 losses construct with default args (no legacy, no explicit reduction)
+        ctors = [
+            L1Loss,
+            NLLLoss,
+            PoissonNLLLoss,
+            KLDivLoss,
+            MSELoss,
+            BCELoss,
+            BCEWithLogitsLoss,
+            HingeEmbeddingLoss,
+            MultiLabelMarginLoss,
+            SmoothL1Loss,
+            SoftMarginLoss,
+            CrossEntropyLoss,
+            MultiLabelSoftMarginLoss,
+            CosineEmbeddingLoss,
+            MarginRankingLoss,
+            MultiMarginLoss,
+            TripletMarginLoss,
+        ]
+        for ctor in ctors:
+            loss = ctor()
+            self.assertIsInstance(loss, paddle.nn.Layer)
+
+    # Cover legacy combos across the family (not each loss needs all combos)
+
+    def test_cross_entropy_reduce_false(self):
+        self.assertSuggests(CrossEntropyLoss, 'none', reduce=False)
+
+    def test_mse_reduce_true_size_average_false(self):
+        self.assertSuggests(MSELoss, 'sum', reduce=True, size_average=False)
+
+    def test_bcewithlogits_reduce_true_size_average_true(self):
+        self.assertSuggests(
+            BCEWithLogitsLoss, 'mean', reduce=True, size_average=True
+        )
+
+    def test_l1_size_average_false_only(self):
+        self.assertSuggests(L1Loss, 'sum', size_average=False)
+
+    def test_kldiv_reduce_true_size_average_none(self):
+        self.assertSuggests(KLDivLoss, 'mean', reduce=True, size_average=None)
+
+    def test_multimargin_reduce_false(self):
+        self.assertSuggests(MultiMarginLoss, 'none', reduce=False)
+
+    def test_multilabel_margin_size_average_false(self):
+        self.assertSuggests(MultiLabelMarginLoss, 'sum', size_average=False)
+
+    def test_cosine_embedding_reduce_true_size_average_true(self):
+        self.assertSuggests(
+            CosineEmbeddingLoss, 'mean', reduce=True, size_average=True
+        )
+
+    def test_margin_ranking_reduce_true_size_average_false(self):
+        self.assertSuggests(
+            MarginRankingLoss, 'sum', reduce=True, size_average=False
+        )
+
+    def test_soft_margin_reduce_false(self):
+        self.assertSuggests(SoftMarginLoss, 'none', reduce=False)
+
+    def test_smooth_l1_size_average_false(self):
+        self.assertSuggests(SmoothL1Loss, 'sum', size_average=False)
+
+    def test_bce_reduce_true_size_average_true(self):
+        self.assertSuggests(BCELoss, 'mean', reduce=True, size_average=True)
+
+    def test_nll_reduce_true_size_average_none(self):
+        self.assertSuggests(NLLLoss, 'mean', reduce=True, size_average=None)
+
+    def test_poisson_nll_reduce_false(self):
+        self.assertSuggests(PoissonNLLLoss, 'none', reduce=False)
+
+    def test_multilabel_soft_margin_size_average_false(self):
+        self.assertSuggests(MultiLabelSoftMarginLoss, 'sum', size_average=False)
+
+    def test_triplet_margin_reduce_true_size_average_false(self):
+        self.assertSuggests(
+            TripletMarginLoss, 'sum', reduce=True, size_average=False
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()