[API Compatibility] Align paddle.Tensor.is_sparse, paddle.Tensor.type, paddle.Tensor.size api, paddle.nn.PReLU and paddle.distributions.categorical.Categorical -part

python/paddle/compat/__init__.py

@@ -40,6 +40,7 @@
     from collections.abc import Sequence
 
     from paddle import Tensor
+    from paddle._typing import DTypeLike
 
 __all__ = [
     'allclose',
@@ -55,6 +56,26 @@
     'seed',
 ]
 
+_TENSOR_TYPE_NAMES = {
+    'float16': 'HalfTensor',
+    'float32': 'FloatTensor',
+    'float64': 'DoubleTensor',
+    'float8_e4m3fn': 'Float8_e4m3fnTensor',
+    'float8_e5m2': 'Float8_e5m2Tensor',
+    'bfloat16': 'BFloat16Tensor',
+    'uint8': 'ByteTensor',
+    'int8': 'CharTensor',
+    'int16': 'ShortTensor',
+    'int32': 'IntTensor',
+    'int64': 'LongTensor',
+    'bool': 'BoolTensor',
+    'complex64': 'ComplexFloatTensor',
+    'complex128': 'ComplexDoubleTensor',
+}
+_TENSOR_TYPE_DTYPES = {
+    tensor_type: dtype for dtype, tensor_type in _TENSOR_TYPE_NAMES.items()
+}
+
 
 def __getattr__(name):
     if name == "paddle_triton":
@@ -66,6 +87,76 @@ def __getattr__(name):
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
+def _tensor_numel(input: Tensor) -> int:
+    return int(input.size)
+
+
+def _tensor_type(
+    input: Tensor,
+    dtype: DTypeLike | str | type | None = None,
+    non_blocking: bool = False,
+    **kwargs: Any,
+) -> str | Tensor:
+    if "async" in kwargs:
+        non_blocking = kwargs.pop("async")
+    if kwargs:
+        key = next(iter(kwargs))
+        raise TypeError(f"type() got an unexpected keyword argument {key!r}")
+
+    if dtype is None:
+        dtype_name = str(input.dtype).removeprefix("paddle.")
+        tensor_type = _TENSOR_TYPE_NAMES[dtype_name]
+        prefix = "torch.cuda" if input.place.is_gpu_place() else "torch"
+        if input.is_sparse_coo():
+            prefix += ".sparse"
+        return f"{prefix}.{tensor_type}"
+
+    device = None
+    if isinstance(dtype, type):
+        tensor_type = dtype.__name__
+        if tensor_type not in _TENSOR_TYPE_DTYPES:
+            raise ValueError(f"invalid type: {tensor_type!r}")
+        dtype = _TENSOR_TYPE_DTYPES[tensor_type]
+        device = "cpu"
+    elif isinstance(dtype, str):
+        dtype_string = dtype
+        tensor_type = dtype_string.rsplit(".", 1)[-1]
+        if (
+            not dtype_string.startswith("torch.")
+            or tensor_type not in _TENSOR_TYPE_DTYPES
+        ):
+            raise ValueError(f"invalid type: {dtype_string!r}")
+        dtype = _TENSOR_TYPE_DTYPES[tensor_type]
+        device = "gpu" if dtype_string.startswith("torch.cuda.") else "cpu"
+
+    dtype_name = str(input.dtype).removeprefix("paddle.")
+    target_dtype_name = str(dtype).removeprefix("paddle.")
+    same_device = (
+        device is None
+        or (device == "cpu" and input.place.is_cpu_place())
+        or (device == "gpu" and input.place.is_gpu_place())
+    )
+    if dtype_name == target_dtype_name and same_device:
+        return input
+
+    return input.to(
+        device=device,
+        dtype=dtype,
+        blocking=not non_blocking,
+    )
+
+
+def _tensor_is_sparse(input: Tensor) -> bool:
+    return input.is_sparse_coo()
+
+
+_TENSOR_API_OVERRIDES = {
+    'numel': (_tensor_numel, False),
+    'type': (_tensor_type, False),
+    'is_sparse': (_tensor_is_sparse, True),
+}
+
+
 def allclose(
     input: Tensor,
     other: Tensor,

python/paddle/compat/api_dispatch.py

@@ -123,6 +123,37 @@ def __call__(cls, *args: Any, **kwargs: Any) -> Any:
     return proxy
 
 
+class _TensorCompatDescriptor:
+    """Caller-aware adapter for Tensor method/property shape differences."""
+
+    def __init__(
+        self,
+        native_attr: Any,
+        compat_fn: Any,
+        as_property: bool,
+    ) -> None:
+        self.__native_fn__ = native_attr
+        self.__compat_fn__ = compat_fn
+        self._as_property = as_property
+        self.__doc__ = compat_fn.__doc__
+        self.__name__ = compat_fn.__name__
+        self.__signature__ = inspect.signature(compat_fn)
+
+    def __get__(self, instance: Any, owner: type | None = None) -> Any:
+        if instance is None:
+            if _caller_is_paddle_internal():
+                return self.__native_fn__
+            return self if self._as_property else self.__compat_fn__
+        if (
+            len(_PADDLE_NAMESPACE_SAVED) > 0
+            and not _caller_is_paddle_internal()
+        ):
+            if self._as_property:
+                return self.__compat_fn__(instance)
+            return self.__compat_fn__.__get__(instance, owner)
+        return self.__native_fn__.__get__(instance, owner)
+
+
 def _patch_tensor_methods() -> None:
     """Route ``paddle.Tensor.<m>`` to the compat function for the root compat APIs
     that torch also exposes as Tensor methods (max/min/sort/split/unique/...), so
@@ -146,6 +177,20 @@ def _patch_tensor_methods() -> None:
             dispatch_function(compat_fn)(native_method),
         )
 
+    for attr_name, (
+        compat_fn,
+        as_property,
+    ) in compat_root._TENSOR_API_OVERRIDES.items():
+        native_attr = inspect.getattr_static(paddle.Tensor, attr_name, None)
+        if native_attr is None:
+            continue
+        _PADDLE_NAMESPACE_SAVED[(paddle.Tensor, attr_name)] = native_attr
+        setattr(
+            paddle.Tensor,
+            attr_name,
+            _TensorCompatDescriptor(native_attr, compat_fn, as_property),
+        )
+
 
 def _apply_paddle_namespace_aliases() -> None:
     """Install caller-aware dispatchers/proxies for every public ``paddle.compat.*``

python/paddle/nn/layer/activation.py

@@ -586,6 +586,17 @@ def __init__(
         device: PlaceLike | None = None,
         dtype: DTypeLike | None = None,
     ) -> None:
+        is_torch_device = weight_attr is None or (
+            isinstance(weight_attr, str)
+            and weight_attr.split(':', 1)[0].lower()
+            in {'cpu', 'cuda', 'gpu', 'xpu', 'mps', 'meta'}
+        )
+        if is_torch_device:
+            if not isinstance(data_format, str):
+                device, dtype = weight_attr, data_format
+                weight_attr, data_format = None, "NCHW"
+            elif weight_attr is not None and data_format == "NCHW":
+                device, weight_attr = weight_attr, None
         super().__init__()
         self._num_parameters = num_parameters
         self._init = init

test/compat/test_compat_namespace_aliased.py

@@ -60,6 +60,9 @@ class CompatNamespaceAliasBase(unittest.TestCase):
         (paddle, "allclose"),
         (paddle, "equal"),
         (paddle, "seed"),
+        (paddle.Tensor, "numel"),
+        (paddle.Tensor, "type"),
+        (paddle.Tensor, "is_sparse"),
         (paddle.nn, "AvgPool1d"),
         (paddle.nn, "AvgPool2d"),
         (paddle.nn, "AvgPool3d"),
@@ -152,6 +155,16 @@ def test_level1_default_does_not_alias(self):
         paddle.enable_compat()  # default level=1
         try:
             self.assertIs(paddle.sort, self._native[(paddle, "sort")])
+            self.assertIs(
+                paddle.Tensor.numel, self._native[(paddle.Tensor, "numel")]
+            )
+            self.assertIs(
+                paddle.Tensor.type, self._native[(paddle.Tensor, "type")]
+            )
+            self.assertIs(
+                paddle.Tensor.is_sparse,
+                self._native[(paddle.Tensor, "is_sparse")],
+            )
             self.assertFalse(hasattr(paddle.sort, "__compat_fn__"))
             with self.assertRaises(TypeError):
                 paddle.sort(
@@ -539,6 +552,9 @@ def test_tensor_methods_caller_aware(self):
         for paddle-internal ``x.max(axis=1)``; restored on disable."""
         native_max = paddle.Tensor.max
         native_split = paddle.Tensor.split
+        native_numel = paddle.Tensor.numel
+        native_type = paddle.Tensor.type
+        native_is_sparse = paddle.Tensor.is_sparse
         t = paddle.to_tensor([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0]])
         with level2_guard():
             r = t.max(dim=1)  # external -> compat namedtuple
@@ -551,15 +567,54 @@ def test_tensor_methods_caller_aware(self):
                 2,
             )
             self.assertEqual(len(paddle.split(t, split_size=1, dim=0)), 2)
+            self.assertEqual(t.numel(), 6)
+            self.assertIs(type(t.numel()), int)
+            self.assertIsInstance(paddle.numel(t), paddle.Tensor)
+            self.assertEqual(paddle.empty([0, 3]).numel(), 0)
+            self.assertEqual(t.type(), "torch.FloatTensor")
+            self.assertEqual(t.type(paddle.float64).dtype, paddle.float64)
+            self.assertEqual(t.type(paddle.DoubleTensor).dtype, paddle.float64)
+            self.assertEqual(t.type("torch.DoubleTensor").dtype, paddle.float64)
+            self.assertIs(t.type(paddle.float32), t)
+            self.assertIs(t.type("torch.FloatTensor"), t)
+            with self.assertRaises(ValueError):
+                t.type("float64")
+            self.assertEqual(
+                paddle.ones([1], dtype="int64").type(), "torch.LongTensor"
+            )
+            self.assertEqual(
+                paddle.ones([1], dtype="float8_e4m3fn").type(),
+                "torch.Float8_e4m3fnTensor",
+            )
+            self.assertEqual(
+                paddle.ones([1], dtype="float8_e5m2").type(),
+                "torch.Float8_e5m2Tensor",
+            )
+            self.assertIs(t.is_sparse, False)
+            coo = paddle.sparse.sparse_coo_tensor([[0], [1]], [1.0], [2, 2])
+            csr = paddle.sparse.sparse_csr_tensor([0, 1, 1], [0], [1.0], [2, 2])
+            self.assertIs(coo.is_sparse, True)
+            self.assertIs(csr.is_sparse, False)
             # paddle-internal native-style call (simulated) stays native
             ns = {"__name__": "paddle.fake_internal", "t": t}
             exec(
                 "internal_max = t.max(axis=1)\n"
-                "internal_split = t.split(num_or_sections=2, axis=0)",
+                "internal_split = t.split(num_or_sections=2, axis=0)\n"
+                "internal_numel = t.numel()\n"
+                "internal_type = t.type\n"
+                "internal_is_sparse = t.is_sparse()",
                 ns,
             )
+            self.assertIsInstance(ns["internal_numel"], paddle.Tensor)
+            self.assertEqual(
+                ns["internal_type"], native_type.__get__(t, paddle.Tensor)
+            )
+            self.assertIs(ns["internal_is_sparse"], False)
         self.assertIs(paddle.Tensor.max, native_max)  # restored on disable
         self.assertIs(paddle.Tensor.split, native_split)
+        self.assertIs(paddle.Tensor.numel, native_numel)
+        self.assertIs(paddle.Tensor.type, native_type)
+        self.assertIs(paddle.Tensor.is_sparse, native_is_sparse)
 
     @with_level2
     def test_aliased_class_caller_aware(self):

test/legacy_test/test_api_compatibility_part2.py

@@ -3176,17 +3176,30 @@ def test_dygraph_Compatibility(self):
         )(input=x)
         # 4. Mixed arguments
         out4 = paddle.nn.PReLU(2, init=0.5, device="cpu", dtype="float32")(x)
+        # 5. PyTorch positional arguments
+        out5 = paddle.nn.PReLU(2, 0.5, "cpu", paddle.float32)(x)
+        # 6. PyTorch positional device without dtype
+        out6 = paddle.nn.PReLU(2, 0.5, "cpu")(x)
+        # 7. PyTorch positional dtype without device
+        out7 = paddle.nn.PReLU(2, 0.5, None, paddle.float32)(x)
 
         expected = self._expected(self.np_x)
-        for out in [out1, out2, out3, out4]:
+        for out in [out1, out2, out3, out4, out5, out6, out7]:
             np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6)
 
         x64 = paddle.to_tensor(self.np_x64)
         layer64 = paddle.nn.PReLU(2, 0.5, device="cpu", dtype="float64")
-        out5 = layer64(input=x64)
+        out8 = layer64(input=x64)
         self.assertEqual(layer64._weight.dtype, paddle.float64)
         np.testing.assert_allclose(
-            out5.numpy(), self._expected(self.np_x64), rtol=1e-6
+            out8.numpy(), self._expected(self.np_x64), rtol=1e-6
+        )
+
+        layer64_positional = paddle.nn.PReLU(2, 0.5, None, paddle.float64)
+        out9 = layer64_positional(x64)
+        self.assertEqual(layer64_positional._weight.dtype, paddle.float64)
+        np.testing.assert_allclose(
+            out9.numpy(), self._expected(self.np_x64), rtol=1e-6
         )
 
         paddle.enable_static()
@@ -3212,13 +3225,15 @@ def test_static_Compatibility(self):
             out4 = paddle.nn.PReLU(2, init=0.5, device="cpu", dtype="float32")(
                 x
             )
+            # 5. PyTorch positional arguments
+            out5 = paddle.nn.PReLU(2, 0.5, "cpu", paddle.float32)(x)
 
             exe = paddle.static.Executor()
             exe.run(startup)
             fetches = exe.run(
                 main,
                 feed={"x": self.np_x},
-                fetch_list=[out1, out2, out3, out4],
+                fetch_list=[out1, out2, out3, out4, out5],
             )
 
             expected = self._expected(self.np_x)