[API Compatibility] Add clip_、logsigmoid、_calculate_fan_in_and_fan_out、meshgrid、autocast

Author: AlAuAu

python/paddle/__init__.py

@@ -226,6 +226,7 @@ def new_init(self, *args, **kwargs):
     get_autocast_gpu_dtype,
     is_autocast_enabled,
 )
+from .amp.auto_cast import autocast as _autocast
 from .autograd import (
     enable_grad,
     grad,
@@ -970,7 +971,7 @@ def __dir__(self):
 manual_seed = seed
 sub = subtract
 sub_ = subtract_
-
+autocast = _autocast
 
 __all__ = [
     'block_diag',
@@ -1481,6 +1482,7 @@ def __dir__(self):
     'conv3d',
     'manual_seed',
     'softmax',
+    'autocast',
 ]
 import os
 

python/paddle/amp/auto_cast.py

@@ -1078,7 +1078,11 @@ def autocast(
     imperative mode.
 
     Args:
+<<<<<<< HEAD
         device_type(str, optional): Device type.But because the paddle does not distinguish between devices, this parameter does not work
+=======
+        device_type(str, optional): Device type. Default is 'gpu'. But this parameter is not used.
+>>>>>>> 0cddb652ad ([API Compatibility] Add clip_、logsigmoid、_calculate_fan_in_and_fan_out、meshgrid、autocast)
         enable(bool, optional): Enable auto-mixed-precision or not. Default is True.
         dtype(str, optional): Whether to use 'float16' or 'bfloat16'. Default is 'float16'.
         cache_enabled(bool, optional): whether to enable cache or not. Default is True. But this parameter is not used

python/paddle/functional.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from .compat import split
+from .tensor.creation import meshgrid
 from .tensor.einsum import einsum
 from .tensor.linalg import norm
 from .tensor.manipulation import (
@@ -31,4 +32,5 @@
     "norm",
     'split',
     'unique_consecutive',
+    "meshgrid",
 ]

python/paddle/nn/functional/__init__.py

@@ -172,6 +172,7 @@
     pixel_unshuffle,
 )
 
+logsigmoid = log_sigmoid
 __all__ = [
     'celu',
     'conv1d',
@@ -192,6 +193,7 @@
     'leaky_relu',
     'leaky_relu_',
     'log_sigmoid',
+    'logsigmoid',
     'maxout',
     'prelu',
     'relu',

python/paddle/nn/functional/activation.py

@@ -754,6 +754,7 @@ def relu_(x: Tensor, name: str | None = None) -> Tensor:
     return _C_ops.relu_(x)
 
 
+@param_one_alias(["x", "input"])
 def log_sigmoid(x: Tensor, name: str | None = None) -> Tensor:
     r"""
     log_sigmoid activation.
@@ -764,6 +765,7 @@ def log_sigmoid(x: Tensor, name: str | None = None) -> Tensor:
 
     Parameters:
         x (Tensor): The input Tensor with data type float32, float64, complex64, complex128.
+            Alias: ``input``.
         name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Returns:

python/paddle/nn/init.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+import numpy as np
+
 import paddle
 
 from ..base.framework import in_dygraph_mode, in_pir_mode
@@ -27,6 +29,41 @@
 from .initializer.xavier import XavierNormal, XavierUniform
 
 
+def _calculate_fan_in_and_fan_out(var: paddle.Tensor) -> tuple[int, int]:
+    """Compute the fan_in and the fan_out for layers
+
+    This method computes the fan_in and the fan_out
+    for neural network layers, if not specified. It is
+    not possible to perfectly estimate fan_in and fan_out.
+    This method will estimate it correctly for matrix multiply and
+    convolutions.
+
+    Args:
+        var: variable for which fan_in and fan_out have to be computed.
+
+    Returns:
+        tuple of two integers (fan_in, fan_out).
+    """
+    shape = var.shape
+    if not shape or len(shape) == 0:
+        fan_in = fan_out = 1
+    elif len(shape) == 1:
+        fan_in = fan_out = shape[0]
+    elif len(shape) == 2:
+        # This is the case for simple matrix multiply
+        fan_in = shape[0]
+        fan_out = shape[1]
+    else:
+        # Assume this to be a convolutional kernel
+        # In PaddlePaddle, the shape of the kernel is like:
+        # [num_filters, num_filter_channels, ...] where the remaining
+        # dimensions are the filter_size
+        receptive_field_size = np.prod(shape[2:])
+        fan_in = int(shape[1] * receptive_field_size)
+        fan_out = int(shape[0] * receptive_field_size)
+    return (fan_in, fan_out)
+
+
 def kaiming_uniform_(
     tensor: paddle.Tensor,
     a: float = 0,

test/legacy_test/test_activation_op.py

@@ -854,6 +854,53 @@ def test_errors(self):
             F.log_sigmoid(x_fp16)
 
 
+class TestLogSigmoidOutAndParaDecorator(unittest.TestCase):
+    def setUp(self) -> None:
+        paddle.disable_static()
+        self.apis = [
+            paddle.nn.functional.log_sigmoid,
+            paddle.nn.functional.logsigmoid,
+        ]
+        self.shape = [3, 4, 5]
+        self.input_np = np.random.random(self.shape).astype('float32')
+
+    def do_test(self, api, test_type):
+        self.test_types = [
+            "decorator1",
+        ]
+        x = paddle.to_tensor(self.input_np, stop_gradient=False)
+        out = paddle.zeros(self.shape, dtype='float32')
+        out.stop_gradient = False
+        if test_type == "raw":
+            out = paddle.nn.functional.log_sigmoid(x)
+            out.mean().backward()
+            return out, x.grad
+        elif test_type == "decorator1":
+            res = api(input=x)
+            loss = res.mean()
+            loss.backward()
+            x_grad = x.grad
+            return res, x_grad
+        else:
+            raise NotImplementedError(
+                f"Test type {test_type} is not implemented."
+            )
+
+    def test_api(self):
+        out_std, x_grad_std = self.do_test(
+            paddle.nn.functional.log_sigmoid, "raw"
+        )
+        for api in self.apis:
+            for test_type in self.test_types:
+                out, x_grad = self.do_test(api, test_type)
+                np.testing.assert_allclose(
+                    out.numpy(), out_std.numpy(), rtol=1e-20
+                )
+                np.testing.assert_allclose(
+                    x_grad.numpy(), x_grad_std.numpy(), rtol=1e-20
+                )
+
+
 class TestTanh(TestActivation, TestParameter):
     def setUp(self):
         self.op_type = "tanh"

test/legacy_test/test_autocast.py

@@ -0,0 +1,40 @@
+# 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
+
+
+class TestAutoCast(unittest.TestCase):
+    def init_net(self):
+        self._conv = paddle.nn.Conv2D(
+            in_channels=1, out_channels=6, kernel_size=3, bias_attr=False
+        )
+        self._linear = paddle.nn.Linear(in_features=4, out_features=4)
+
+    def test_autocast(self):
+        self.init_net()
+        with paddle.autocast():
+            out1 = self._conv(paddle.rand(shape=[1, 1, 6, 6], dtype='float32'))
+            out2 = out1 + paddle.rand(shape=out1.shape, dtype='float16')
+            out3 = self._linear(out2)
+
+        self.assertEqual(out1.dtype, paddle.float16)
+        self.assertEqual(out2.dtype, paddle.float16)
+        self.assertEqual(out3.dtype, paddle.float32)
+
+
+if __name__ == '__main__':
+    unittest.main()

test/legacy_test/test_nn_init_function.py

@@ -62,6 +62,22 @@ def _calculate_gain(nonlinearity, param):
     return recommended_gain[nonlinearity]
 
 
+def _calculate_fan_in_and_fan_out(var: paddle.Tensor) -> tuple[int, int]:
+    shape = var.shape
+    if not shape or len(shape) == 0:
+        fan_in = fan_out = 1
+    elif len(shape) == 1:
+        fan_in = fan_out = shape[0]
+    elif len(shape) == 2:
+        fan_in = shape[0]
+        fan_out = shape[1]
+    else:
+        receptive_field_size = np.prod(shape[2:])
+        fan_in = shape[1] * receptive_field_size
+        fan_out = shape[0] * receptive_field_size
+    return (fan_in, fan_out)
+
+
 class Test_calculate_gain(unittest.TestCase):
     def test(self):
         for nonlinearity in [
@@ -87,6 +103,27 @@ def test(self):
             )
 
 
+class TestCAlFanINOUT(unittest.TestCase):
+    def test_cal_fan_in_and_out(self):
+        x = paddle.tensor.randn([10])
+        self.assertEqual(
+            _calculate_fan_in_and_fan_out(x),
+            paddle.nn.init._calculate_fan_in_and_fan_out(x),
+        )
+
+        y = paddle.tensor.randn([10, 10])
+        self.assertEqual(
+            _calculate_fan_in_and_fan_out(y),
+            paddle.nn.init._calculate_fan_in_and_fan_out(y),
+        )
+
+        z = paddle.randn([10, 10, 10])
+        self.assertEqual(
+            _calculate_fan_in_and_fan_out(z),
+            paddle.nn.init._calculate_fan_in_and_fan_out(z),
+        )
+
+
 class Test_kaiming_uniform_(unittest.TestCase):
     def check_kaiming_uniform(
         self, tensor, a=0, mode='fan_in', nonlinearity='leaky_relu'