[API Compatibility] Fix Tensor.type

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',
@@ -56,6 +57,26 @@
 ]
 
 
+_TENSOR_TYPE_DTYPES = {
+    'HalfTensor': 'float16',
+    'FloatTensor': 'float32',
+    'DoubleTensor': 'float64',
+    'Float8_e4m3fnTensor': 'float8_e4m3fn',
+    'Float8_e5m2Tensor': 'float8_e5m2',
+    'BFloat16Tensor': 'bfloat16',
+    'ByteTensor': 'uint8',
+    'CharTensor': 'int8',
+    'ShortTensor': 'int16',
+    'IntTensor': 'int32',
+    'LongTensor': 'int64',
+    'BoolTensor': 'bool',
+    'ComplexFloatTensor': 'complex64',
+    'ComplexDoubleTensor': 'complex128',
+}
+
+_DTYPE_TENSOR_TYPES = {v: k for k, v in _TENSOR_TYPE_DTYPES.items()}
+
+
 def __getattr__(name):
     if name == "paddle_triton":
         return paddle_triton_fun()
@@ -66,6 +87,129 @@ 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_name(input: Tensor) -> str:
+    """The tensor type name of ``input``, e.g. ``'torch.cuda.sparse.FloatTensor'``,
+    following ``torch.Tensor.type``. The device segment is ``'cuda'`` for GPU,
+    ``'xpu'`` for XPU and the device type itself for custom devices, e.g.
+    ``'torch.npu.FloatTensor'``. Dtypes without a tensor type name fall back to
+    the dtype string."""
+    dtype_name = str(input.dtype).removeprefix("paddle.")
+    tensor_type = _DTYPE_TENSOR_TYPES.get(dtype_name)
+    if tensor_type is None:
+        return str(input.dtype)
+    segments = ["torch"]
+    place = input.place
+    if place.is_gpu_place():
+        segments.append("cuda")
+    elif place.is_xpu_place():
+        segments.append("xpu")
+    elif place.is_custom_place():
+        segments.append(place.custom_device_type().lower())
+    if input.is_sparse_coo():
+        segments.append("sparse")
+    segments.append(tensor_type)
+    return ".".join(segments)
+
+
+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. Qualified ``torch.*`` and ``paddle.*`` dtype or tensor
+            type strings are supported. When it is ``None``, returns the tensor
+            type name. Default: ``None``.
+        non_blocking (bool, optional): Whether the conversion may occur
+            asynchronously. Default: ``False``.
+
+    Returns:
+        str|Tensor: The tensor type name when ``dtype`` is ``None``, e.g.
+            ``'torch.FloatTensor'``, ``'torch.cuda.FloatTensor'`` or
+            ``'torch.cuda.sparse.FloatTensor'``, encoding the dtype, the place
+            and the sparse COO layout as ``torch.Tensor.type`` does; 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 _tensor_type_name(input)
+
+    device = None
+    if getattr(dtype, "__name__", None) in _TENSOR_TYPE_DTYPES:
+        # tensor factory classes, e.g. paddle.DoubleTensor
+        device = getattr(dtype, "_device", None) or "cpu"
+        dtype = getattr(paddle, _TENSOR_TYPE_DTYPES[dtype.__name__])
+    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 = getattr(paddle, _TENSOR_TYPE_DTYPES[tensor_type])
+            device = (
+                "gpu"
+                if dtype_string.startswith(("torch.cuda.", "paddle.cuda."))
+                else "cpu"
+            )
+        elif tensor_type in _TENSOR_TYPE_DTYPES.values():
+            dtype = getattr(paddle, tensor_type)
+        else:
+            raise ValueError(f"invalid type: {dtype_string!r}")
+
+    same_device = (
+        device is None
+        or (device == "cpu" and input.place.is_cpu_place())
+        or (device == "gpu" and input.place.is_gpu_place())
+    )
+    if input.dtype == dtype 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()
+
+
 def allclose(
     input: Tensor,
     other: Tensor,
@@ -1132,3 +1276,21 @@ def GetShapeOnDimInRange(shape, dim: int) -> int:
                     split_size_or_sections
                 )
             return tuple(_C_ops.split(tensor, split_size_or_sections, dim))
+
+
+# ``paddle.Tensor`` APIs routed to their ``paddle.compat`` implementations
+_TENSOR_API_OVERRIDES = {
+    'allclose': allclose,
+    'equal': equal,
+    'slogdet': slogdet,
+    'sort': sort,
+    'split': split,
+    'min': min,
+    'max': max,
+    'unique': unique,
+    'median': median,
+    'nanmedian': nanmedian,
+    'numel': _tensor_numel,
+    'type': _tensor_type,
+    'is_sparse': _tensor_is_sparse,
+}

python/paddle/compat/api_dispatch.py

@@ -51,29 +51,19 @@ def _caller_is_paddle_internal() -> bool:
     return name == "paddle" or name.startswith("paddle.")
 
 
-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."""
-
-    def decorator(native_fn: Any) -> Any:
-        @wraps(native_fn)
-        def dispatcher(*args: Any, **kwargs: Any) -> Any:
-            if (
-                len(_PADDLE_NAMESPACE_SAVED) > 0
-                and not _caller_is_paddle_internal()
-            ):
-                return compat_fn(*args, **kwargs)
-            return native_fn(*args, **kwargs)
+def dispatch_function(native_fn: Any, compat_fn: Any) -> Any:
+    """Wrap a native ``paddle`` callable for caller-aware dispatch."""
 
-        dispatcher.__compat_fn__ = compat_fn
-        dispatcher.__native_fn__ = native_fn
-        dispatcher.__signature__ = inspect.signature(compat_fn)
-        return dispatcher
+    @wraps(native_fn)
+    def dispatcher(*args: Any, **kwargs: Any) -> Any:
+        if _caller_is_paddle_internal():
+            return native_fn(*args, **kwargs)
+        return compat_fn(*args, **kwargs)
 
-    return decorator
+    dispatcher.__compat_fn__ = compat_fn
+    dispatcher.__native_fn__ = native_fn
+    dispatcher.__signature__ = inspect.signature(compat_fn)
+    return dispatcher
 
 
 def _iter_compat_modules() -> Generator[types.ModuleType, None, None]:
@@ -123,28 +113,49 @@ def __call__(cls, *args: Any, **kwargs: Any) -> Any:
     return proxy
 
 
+def dispatch_property(
+    native_attr: Any,
+    compat_attr: Any,
+) -> Any:
+    """Route a Tensor API when either side uses the property protocol."""
+    compat_fn = (
+        compat_attr.fget if isinstance(compat_attr, property) else compat_attr
+    )
+
+    class _PropertyDispatcher:
+        def __get__(self, instance: Any, owner: type | None = None) -> Any:
+            if _caller_is_paddle_internal():
+                attr = native_attr
+            else:
+                attr = compat_attr
+            return 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
+
+
 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:
+    for attr_name, compat_attr in compat_root._TENSOR_API_OVERRIDES.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
-        setattr(
-            paddle.Tensor,
-            attr_name,
-            dispatch_function(compat_fn)(native_method),
-        )
+        _PADDLE_NAMESPACE_SAVED[(paddle.Tensor, attr_name)] = native_attr
+        if inspect.isdatadescriptor(native_attr) or isinstance(
+            compat_attr, property
+        ):
+            dispatcher = dispatch_property(native_attr, compat_attr)
+        else:
+            dispatcher = dispatch_function(native_attr, compat_attr)
+        setattr(paddle.Tensor, attr_name, dispatcher)
 
 
 def _apply_paddle_namespace_aliases() -> None:
@@ -177,7 +188,7 @@ def _apply_paddle_namespace_aliases() -> None:
                 setattr(
                     target_module,
                     attr_name,
-                    dispatch_function(compat_attr)(current),
+                    dispatch_function(current, compat_attr),
                 )
     _patch_tensor_methods()
 

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 = (