[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,113 @@ 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 dtype 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. Qualified ``torch.*`` and ``paddle.*`` dtype or tensor
+            type strings are supported. When it is ``None``, returns a Paddle
+            dtype string. Default: ``None``.
+        non_blocking (bool, optional): Whether the conversion may occur
+            asynchronously. Default: ``False``.
+
+    Returns:
+        str|Tensor: A Paddle dtype 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:
+        return str(input.dtype)
+
+    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.", "paddle.")):
+            raise ValueError(f"invalid type: {dtype_string!r}")
+        if tensor_type in _TENSOR_TYPE_DTYPES:
+            dtype = _TENSOR_TYPE_DTYPES[tensor_type]
+            device = (
+                "gpu"
+                if dtype_string.startswith(("torch.cuda.", "paddle.cuda."))
+                else "cpu"
+            )
+        elif tensor_type in _TENSOR_TYPE_NAMES:
+            dtype = tensor_type
+            if dtype_string.startswith(("torch.cuda.", "paddle.cuda.")):
+                device = "gpu"
+        else:
+            raise ValueError(f"invalid type: {dtype_string!r}")
+
+    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

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""``enable_compat(level=2)`` API dispatch: route ``paddle.*`` (and
-``paddle.Tensor`` methods) to the torch-aligned ``paddle.compat.*`` for
-external callers while paddle-internal callers keep native semantics.
+"""``enable_compat(level=2)`` and ``enable_compat(level=3)`` API dispatch:
+route ``paddle.*`` (and ``paddle.Tensor`` methods) to the torch-aligned
+``paddle.compat.*`` for external callers while paddle-internal callers keep
+native semantics.
 
 The enable/disable/level lifecycle lives in ``paddle.compat.proxy``; this
 module only installs/removes the dispatchers and holds the dispatch state.
@@ -54,9 +55,10 @@ def _caller_is_paddle_internal() -> bool:
 def dispatch_function(compat_fn: Any) -> Any:
     """Wrap a native ``paddle`` callable to route external callers to
     ``compat_fn`` while compat is enabled; paddle-internal callers and the
-    disabled state get the native callable. Installed only under
-    ``enable_compat(level=2)``; ``disable_compat`` restores the originals,
-    so the default hot path is untouched."""
+    disabled state get the native callable. Installed under
+    ``enable_compat(level=2)`` or ``enable_compat(level=3)``;
+    ``disable_compat`` restores the originals, so the default hot path is
+    untouched."""
 
     def decorator(native_fn: Any) -> Any:
         @wraps(native_fn)
@@ -77,11 +79,12 @@ def dispatcher(*args: Any, **kwargs: Any) -> Any:
 
 
 def _iter_compat_modules() -> Generator[types.ModuleType, None, None]:
-    """Yield ``paddle.compat`` modules that declare ``__all__``.
-
-    ``pkgutil.walk_packages`` skips the starting package, so the root
-    ``paddle.compat`` (holding the top-level functions) is yielded explicitly.
-    """
+    """Wrap a native ``paddle`` callable to route external callers to
+    ``compat_fn`` while compat is enabled; paddle-internal callers and the
+    disabled state get the native callable. Installed under
+    ``enable_compat(level=2)`` or ``enable_compat(level=3)``;
+    ``disable_compat`` restores the originals, so the default hot path is
+    untouched."""
     import paddle.compat
 
     if hasattr(paddle.compat, "__all__"):
@@ -123,27 +126,64 @@ def __call__(cls, *args: Any, **kwargs: Any) -> Any:
     return proxy
 
 
+def dispatch_property(compat_attr: Any) -> Any:
+    """Route a Tensor API when either side uses the property protocol."""
+
+    def decorator(native_attr: Any) -> Any:
+        compat_is_property = isinstance(compat_attr, property)
+        compat_fn = compat_attr.fget if compat_is_property else compat_attr
+
+        class _PropertyDispatcher:
+            def __get__(self, instance: Any, owner: type | None = None) -> Any:
+                if instance is None:
+                    if _caller_is_paddle_internal():
+                        return native_attr
+                    return self if compat_is_property else compat_fn
+                if (
+                    len(_PADDLE_NAMESPACE_SAVED) > 0
+                    and not _caller_is_paddle_internal()
+                ):
+                    if compat_is_property:
+                        return compat_fn(instance)
+                    return compat_fn.__get__(instance, owner)
+                return native_attr.__get__(instance, owner)
+
+        dispatcher = _PropertyDispatcher()
+        dispatcher.__native_fn__ = native_attr
+        dispatcher.__compat_fn__ = compat_fn
+        dispatcher.__doc__ = compat_fn.__doc__
+        dispatcher.__name__ = compat_fn.__name__
+        dispatcher.__signature__ = inspect.signature(compat_fn)
+        return dispatcher
+
+    return decorator
+
+
 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
+        if isinstance(compat_attr, property) or inspect.isdatadescriptor(
+            native_attr
+        ):
+            dispatcher = dispatch_property
+        else:
+            dispatcher = dispatch_function
         setattr(
             paddle.Tensor,
             attr_name,
-            dispatch_function(compat_fn)(native_method),
+            dispatcher(compat_attr)(native_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 = (