[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,109 @@ def __getattr__(name):
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
+def _tensor_numel(input: Tensor) -> int:
+    """
+    Returns the total number of elements in the tensor.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        int: The number of elements in ``input``.
+    """
+    return int(input.size)
+
+
+def _tensor_type(
+    input: Tensor,
+    dtype: DTypeLike | str | type | None = None,
+    non_blocking: bool = False,
+    **kwargs: Any,
+) -> str | Tensor:
+    """
+    Returns the tensor type when ``dtype`` is not specified, otherwise casts
+    the tensor to the requested type.
+
+    Args:
+        input (Tensor): The input tensor.
+        dtype (DTypeLike|str|type|None, optional): The target tensor type or
+            data type. When it is ``None``, returns a PyTorch-style tensor type
+            string. Default: ``None``.
+        non_blocking (bool, optional): Whether the conversion may occur
+            asynchronously. Default: ``False``.
+
+    Returns:
+        str|Tensor: A tensor type string when ``dtype`` is ``None``; otherwise,
+            a tensor with the requested type.
+    """
+    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,
+    )
+
+
+@property
+def _tensor_is_sparse(input: Tensor) -> bool:
+    """
+    Whether the tensor uses the sparse COO layout.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        bool: ``True`` for a sparse COO tensor, otherwise ``False``.
+    """
+    return input.is_sparse_coo()
+
+
+_TENSOR_API_OVERRIDES = {
+    'numel': _tensor_numel,
+    'type': _tensor_type,
+    'is_sparse': _tensor_is_sparse,
+}
+
+
 def allclose(
     input: Tensor,
     other: Tensor,

python/paddle/compat/api_dispatch.py

@@ -123,27 +123,58 @@ def __call__(cls, *args: Any, **kwargs: Any) -> Any:
     return proxy
 
 
+class _TensorCompatDescriptor:
+    """Caller-aware dispatcher for a ``paddle.Tensor`` API."""
+
+    def __init__(
+        self,
+        native_attr: Any,
+        compat_attr: Any,
+    ) -> None:
+        self._compat_is_property = isinstance(compat_attr, property)
+        compat_fn = (
+            compat_attr.fget if self._compat_is_property else compat_attr
+        )
+        self.__native_fn__ = native_attr
+        self.__compat_fn__ = compat_fn
+        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._compat_is_property else self.__compat_fn__
+        if (
+            len(_PADDLE_NAMESPACE_SAVED) > 0
+            and not _caller_is_paddle_internal()
+        ):
+            if self._compat_is_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
-    ``x.max(dim=1)`` works torch-style for external callers (native for internal).
-    The dispatcher is patched directly like any paddle Tensor method: the
-    descriptor protocol forwards the tensor as the first positional argument,
-    which is exactly the compat function's ``input`` parameter.
-    """
+    """Route ``paddle.Tensor`` APIs to their root compat implementations."""
     import paddle
     import paddle.compat as compat_root
 
-    for attr_name in getattr(compat_root, "__all__", ()):
-        native_method = getattr(paddle.Tensor, attr_name, None)
-        if native_method is None:
+    tensor_apis = {
+        attr_name: getattr(compat_root, attr_name)
+        for attr_name in getattr(compat_root, "__all__", ())
+    }
+    tensor_apis.update(compat_root._TENSOR_API_OVERRIDES)
+    for attr_name, compat_attr in tensor_apis.items():
+        native_attr = inspect.getattr_static(paddle.Tensor, attr_name, None)
+        if native_attr is None:
             continue
-        compat_fn = getattr(compat_root, attr_name)
-        _PADDLE_NAMESPACE_SAVED[(paddle.Tensor, attr_name)] = native_method
+        _PADDLE_NAMESPACE_SAVED[(paddle.Tensor, attr_name)] = native_attr
         setattr(
             paddle.Tensor,
             attr_name,
-            dispatch_function(compat_fn)(native_method),
+            _TensorCompatDescriptor(native_attr, compat_attr),
         )
 
 

python/paddle/compat/distributions/categorical.py

@@ -22,6 +22,8 @@
 
 from ..utils import _CompatClassMeta
 
+__all__ = ["Categorical"]
+
 
 class Categorical(distribution.Distribution, metaclass=_CompatClassMeta):
     arg_constraints = {
@@ -66,6 +68,20 @@ def __init__(
         distribution.Distribution.__init__(
             self, batch_shape, validate_args=validate_args
         )
+        if self._validate_args_enabled and paddle.in_dynamic_mode():
+            if probs is not None:
+                param_name = "probs"
+                valid = paddle.all(self.probs >= 0, axis=-1) & (
+                    (self.probs.sum(-1) - 1).abs() < 1e-6
+                )
+            else:
+                param_name = "logits"
+                valid = constraint.real_vector.check(self.logits)
+            if not bool(valid.all()):
+                raise ValueError(
+                    f'Expected parameter {param_name} of distribution '
+                    'Categorical to satisfy its constraint'
+                )
 
     def expand(self, batch_shape, _instance=None):
         new = (