[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,74 @@ 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) and dtype.__name__ in _TENSOR_TYPE_DTYPES:
+        tensor_type = dtype.__name__
+        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/compat/nn/__init__.py

@@ -40,6 +40,7 @@
 __all__ = [
     'Unfold',
     'Linear',
+    'PReLU',
     'Softmax',
     'AvgPool1D',
     'AvgPool2D',
@@ -662,6 +663,22 @@ def reset_parameters(self) -> None:
             nn.init.uniform_(self.bias, -bound, bound)
 
 
+class PReLU(nn.PReLU, metaclass=_CompatClassMeta):
+    def __init__(
+        self,
+        num_parameters: int = 1,
+        init: float = 0.25,
+        device: PlaceLike | None = None,
+        dtype: DTypeLike | None = None,
+    ) -> None:
+        super().__init__(
+            num_parameters=num_parameters,
+            init=init,
+            device=device,
+            dtype=dtype,
+        )
+
+
 class Softmax(nn.Layer, metaclass=_CompatClassMeta):
     r"""
     Softmax Activation.

python/paddle/compat/proxy.py

@@ -26,6 +26,7 @@
 from typing import TYPE_CHECKING, Any, Literal
 
 from .api_dispatch import (
+    _PADDLE_NAMESPACE_SAVED,
     _apply_paddle_namespace_aliases,
     _iter_compat_modules,
     _restore_paddle_namespace_aliases,
@@ -604,6 +605,7 @@ def use_compat_guard(
     already_has_torch_proxy = TORCH_PROXY_FINDER in sys.meta_path
     original_local_enabled_scope = set(TORCH_PROXY_FINDER._local_enabled_scope)
     original_globally_enabled = TORCH_PROXY_FINDER._globally_enabled
+    original_level = 2 if _PADDLE_NAMESPACE_SAVED else 1
     if enable == already_has_torch_proxy and (
         (original_globally_enabled and scope is None)
         or (original_local_enabled_scope == (scope or set()))
@@ -625,7 +627,7 @@ def use_compat_guard(
         try:
             yield
         finally:
-            enable_compat(scope=None, silent=True)
+            enable_compat(scope=None, silent=True, level=original_level)
             TORCH_PROXY_FINDER._local_enabled_scope = (
                 original_local_enabled_scope
             )

python/paddle/nn/layer/activation.py

@@ -586,6 +586,9 @@ def __init__(
         device: PlaceLike | None = None,
         dtype: DTypeLike | None = None,
     ) -> None:
+        if not isinstance(data_format, str):
+            device, dtype = weight_attr, data_format
+            weight_attr, data_format = None, "NCHW"
         super().__init__()
         self._num_parameters = num_parameters
         self._init = init