在smooth_l1_loss函数中加入is_huber参数 (#73416)

Qin-sx · web-flow · commit 0e713e2e40a9 · 2025-06-20T15:02:42.000+08:00
diff --git a/python/paddle/nn/functional/loss.py b/python/paddle/nn/functional/loss.py
@@ -1105,6 +1105,7 @@ def smooth_l1_loss(
     label: Tensor,
     reduction: _ReduceMode = 'mean',
     delta: float = 1.0,
+    is_huber: bool = True,
     name: str | None = None,
 ) -> Tensor:
     r"""
@@ -1143,6 +1144,7 @@ def smooth_l1_loss(
             The value determines how large the errors need to be to use L1. Errors
             smaller than delta are minimized with L2. Parameter is ignored for
             negative/zero values. Default = 1.0
+        is_huber (bool, optional): If True, use the Huber loss, otherwise use a modified version where the Huber loss is divided by delta. Default is True.
         name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Returns:
@@ -1192,6 +1194,9 @@ def smooth_l1_loss(
             attrs={'delta': delta},
         )
 
+    if not is_huber:
+        out = out / delta
+
     if reduction not in ['sum', 'mean', 'none']:
         raise ValueError(
             "The value of 'reduction' in smooth_l1_loss should be 'sum', 'mean' or"
diff --git a/python/paddle/nn/layer/loss.py b/python/paddle/nn/layer/loss.py
@@ -1481,6 +1481,7 @@ class SmoothL1Loss(Layer):
             The value determines how large the errors need to be to use L1. Errors
             smaller than delta are minimized with L2. Parameter is ignored for
             negative/zero values. Default value is :math:`1.0`.
+        is_huber (bool, optional): If True, use the Huber loss, otherwise use a modified version where the Huber loss is divided by delta. Default is True.
         name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Call Parameters:
@@ -1517,11 +1518,13 @@ def __init__(
         self,
         reduction: _ReduceMode = 'mean',
         delta: float = 1.0,
+        is_huber: bool = True,
         name: str | None = None,
     ) -> None:
         super().__init__()
         self.reduction = reduction
         self.delta = delta
+        self.is_huber = is_huber
         self.name = name
 
     def forward(self, input: Tensor, label: Tensor) -> Tensor:
@@ -1530,6 +1533,7 @@ def forward(self, input: Tensor, label: Tensor) -> Tensor:
             label,
             reduction=self.reduction,
             delta=self.delta,
+            is_huber=self.is_huber,
             name=self.name,
         )
 
diff --git a/test/legacy_test/test_smooth_l1_loss.py b/test/legacy_test/test_smooth_l1_loss.py
@@ -39,6 +39,25 @@ def smooth_l1_loss_np(input, label, reduction='mean', delta=1.0):
         return out
 
 
+def smooth_l1_loss_div_delta_forward(val, delta):
+    abs_val = abs(val)
+    if abs_val <= delta:
+        return 0.5 * val * val / delta
+    else:
+        return abs_val - 0.5 * delta
+
+
+def smooth_l1_loss_div_delta_np(input, label, reduction='mean', delta=1.0):
+    diff = input - label
+    out = np.vectorize(smooth_l1_loss_div_delta_forward)(diff, delta)
+    if reduction == 'sum':
+        return np.sum(out)
+    elif reduction == 'mean':
+        return np.mean(out)
+    elif reduction == 'none':
+        return out
+
+
 class SmoothL1Loss(unittest.TestCase):
     def setUp(self):
         np.random.seed(123)
@@ -234,6 +253,219 @@ def test_static():
         np.testing.assert_allclose(dy_ret_value, expected, rtol=1e-05)
 
 
+class SmoothL1LossDivDelta(unittest.TestCase):
+    def setUp(self):
+        np.random.seed(123)
+
+    def test_smooth_l1_loss_mean(self):
+        input_np = np.random.random([100, 200]).astype(np.float32)
+        label_np = np.random.random([100, 200]).astype(np.float32)
+
+        place = (
+            base.CUDAPlace(0)
+            if base.core.is_compiled_with_cuda()
+            else base.CPUPlace()
+        )
+
+        expected = smooth_l1_loss_div_delta_np(
+            input_np, label_np, reduction='mean'
+        )
+
+        def test_static():
+            prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(prog, startup_prog):
+                input = paddle.static.data(
+                    name='input', shape=[100, 200], dtype='float32'
+                )
+                label = paddle.static.data(
+                    name='label', shape=[100, 200], dtype='float32'
+                )
+                smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(is_huber=False)
+                ret = smooth_l1_loss(input, label)
+
+                exe = paddle.static.Executor(place)
+                (static_ret,) = exe.run(
+                    feed={
+                        'input': input_np,
+                        'label': label_np,
+                    },
+                    fetch_list=[ret],
+                )
+                self.assertIsNotNone(static_ret)
+                np.testing.assert_allclose(static_ret, expected, rtol=1e-05)
+
+        with base.dygraph.guard():
+            smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(is_huber=False)
+            dy_ret = smooth_l1_loss(
+                paddle.to_tensor(input_np),
+                paddle.to_tensor(label_np),
+            )
+            dy_ret_value = dy_ret.numpy()
+            self.assertIsNotNone(dy_ret_value)
+
+        test_static()
+        np.testing.assert_allclose(dy_ret_value, expected, rtol=1e-05)
+
+    def test_smooth_l1_loss_sum(self):
+        input_np = np.random.random([100, 200]).astype(np.float32)
+        label_np = np.random.random([100, 200]).astype(np.float32)
+
+        place = (
+            base.CUDAPlace(0)
+            if base.core.is_compiled_with_cuda()
+            else base.CPUPlace()
+        )
+        expected = smooth_l1_loss_div_delta_np(
+            input_np, label_np, reduction='sum'
+        )
+
+        def test_static():
+            prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(prog, startup_prog):
+                input = paddle.static.data(
+                    name='input', shape=[100, 200], dtype='float32'
+                )
+                label = paddle.static.data(
+                    name='label', shape=[100, 200], dtype='float32'
+                )
+                smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                    reduction='sum', is_huber=False
+                )
+                ret = smooth_l1_loss(input, label)
+
+                exe = paddle.static.Executor(place)
+                (static_ret,) = exe.run(
+                    feed={
+                        'input': input_np,
+                        'label': label_np,
+                    },
+                    fetch_list=[ret],
+                )
+                self.assertIsNotNone(static_ret)
+                np.testing.assert_allclose(static_ret, expected, rtol=1e-05)
+
+        with base.dygraph.guard():
+            smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                reduction='sum', is_huber=False
+            )
+            dy_ret = smooth_l1_loss(
+                paddle.to_tensor(input_np),
+                paddle.to_tensor(label_np),
+            )
+            dy_ret_value = dy_ret.numpy()
+            self.assertIsNotNone(dy_ret_value)
+
+        test_static()
+        np.testing.assert_allclose(dy_ret_value, expected, rtol=1e-05)
+
+    def test_smooth_l1_loss_none(self):
+        input_np = np.random.random([100, 200]).astype(np.float32)
+        label_np = np.random.random([100, 200]).astype(np.float32)
+
+        place = (
+            base.CUDAPlace(0)
+            if base.core.is_compiled_with_cuda()
+            else base.CPUPlace()
+        )
+        expected = smooth_l1_loss_div_delta_np(
+            input_np, label_np, reduction='none'
+        )
+
+        def test_static():
+            prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(prog, startup_prog):
+                input = paddle.static.data(
+                    name='input', shape=[100, 200], dtype='float32'
+                )
+                label = paddle.static.data(
+                    name='label', shape=[100, 200], dtype='float32'
+                )
+                smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                    reduction='none', is_huber=False
+                )
+                ret = smooth_l1_loss(input, label)
+
+                exe = paddle.static.Executor(place)
+                (static_ret,) = exe.run(
+                    feed={
+                        'input': input_np,
+                        'label': label_np,
+                    },
+                    fetch_list=[ret],
+                )
+                self.assertIsNotNone(static_ret)
+                np.testing.assert_allclose(static_ret, expected, rtol=1e-05)
+
+        with base.dygraph.guard():
+            smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                reduction='none', is_huber=False
+            )
+            dy_ret = smooth_l1_loss(
+                paddle.to_tensor(input_np),
+                paddle.to_tensor(label_np),
+            )
+            dy_ret_value = dy_ret.numpy()
+            self.assertIsNotNone(dy_ret_value)
+
+        test_static()
+        np.testing.assert_allclose(dy_ret_value, expected, rtol=1e-05)
+
+    def test_smooth_l1_loss_delta(self):
+        input_np = np.random.random([100, 200]).astype(np.float32)
+        label_np = np.random.random([100, 200]).astype(np.float32)
+        delta = np.random.rand()
+
+        place = (
+            base.CUDAPlace(0)
+            if base.core.is_compiled_with_cuda()
+            else base.CPUPlace()
+        )
+        expected = smooth_l1_loss_div_delta_np(input_np, label_np, delta=delta)
+
+        def test_static():
+            prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(prog, startup_prog):
+                input = paddle.static.data(
+                    name='input', shape=[100, 200], dtype='float32'
+                )
+                label = paddle.static.data(
+                    name='label', shape=[100, 200], dtype='float32'
+                )
+                smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                    delta=delta, is_huber=False
+                )
+                ret = smooth_l1_loss(input, label)
+
+                exe = paddle.static.Executor(place)
+                (static_ret,) = exe.run(
+                    feed={
+                        'input': input_np,
+                        'label': label_np,
+                    },
+                    fetch_list=[ret],
+                )
+                self.assertIsNotNone(static_ret)
+                np.testing.assert_allclose(static_ret, expected, rtol=1e-05)
+
+        with base.dygraph.guard():
+            smooth_l1_loss = paddle.nn.loss.SmoothL1Loss(
+                delta=delta, is_huber=False
+            )
+            dy_ret = smooth_l1_loss(
+                paddle.to_tensor(input_np),
+                paddle.to_tensor(label_np),
+            )
+            dy_ret_value = dy_ret.numpy()
+            self.assertIsNotNone(dy_ret_value)
+
+        test_static()
+        np.testing.assert_allclose(dy_ret_value, expected, rtol=1e-05)
+
+
 if __name__ == "__main__":
     paddle.enable_static()
     unittest.main()
