[API Compatibility] instance_norm/to_empty/linalg.det/gumbel_softmax/vstack/addcdiv/batch_norm/set_default_device/set_grad_enabled/new_tensor/_Loss/_pair/histc/hstack/true_divide_/linalg.eigh/Tensor.H/ELU/relu6/clamp_max/qr/logdet/linalg.cholesky/elu/tensordot/prelu/expand_copy/linalg.qr/clamp_

paddle/fluid/pybind/arg_pre_process.cc

@@ -563,6 +563,91 @@ void PixelShufflePreProcess(std::string* data_format) {
   }
 }
 
+// Eigh input validation for dygraph
+void EighPreProcess(Tensor* x, std::string* UPLO) {
+  auto x_shape = x->dims();
+  int64_t rank = x_shape.size();
+  PADDLE_ENFORCE_GE(rank,
+                    2,
+                    phi::errors::InvalidArgument(
+                        "Input(input) only support >=2 tensor, but received "
+                        "length of Input(input) is %ld.",
+                        rank));
+  PADDLE_ENFORCE_EQ(x_shape[rank - 1],
+                    x_shape[rank - 2],
+                    phi::errors::InvalidArgument(
+                        "The input matrix must be batches of square matrices. "
+                        "But received x's dimension: [%s]",
+                        x_shape));
+  PADDLE_ENFORCE_EQ(
+      *UPLO == "L" || *UPLO == "U",
+      true,
+      phi::errors::InvalidArgument(
+          "UPLO must be L or U. But received UPLO is: %s", UPLO->c_str()));
+}
+
+// Eigh input validation for static graph
+void EighPreProcess(Value* x, std::string* UPLO) {
+  auto x_shape = pir::GetShapeFromValue(*x);
+  int64_t rank = x_shape.size();
+  PADDLE_ENFORCE_GE(rank,
+                    2,
+                    phi::errors::InvalidArgument(
+                        "Input(input) only support >=2 tensor, but received "
+                        "length of Input(input) is %ld.",
+                        rank));
+  if (x_shape[rank - 1] > 0 && x_shape[rank - 2] > 0) {
+    PADDLE_ENFORCE_EQ(
+        x_shape[rank - 1],
+        x_shape[rank - 2],
+        phi::errors::InvalidArgument(
+            "The input matrix must be batches of square matrices. "
+            "But received x's dimension."));
+  }
+  PADDLE_ENFORCE_EQ(
+      *UPLO == "L" || *UPLO == "U",
+      true,
+      phi::errors::InvalidArgument(
+          "UPLO must be L or U. But received UPLO is: %s", UPLO->c_str()));
+}
+
+// Cholesky input validation for dygraph
+void CholeskyPreProcess(Tensor* x, bool* upper) {
+  auto x_shape = x->dims();
+  int64_t rank = x_shape.size();
+  PADDLE_ENFORCE_GE(
+      rank,
+      2,
+      phi::errors::InvalidArgument("Shape must have at least 2 dimensions. "
+                                   "But received x's dimension: %ld.",
+                                   rank));
+  PADDLE_ENFORCE_EQ(
+      x_shape[rank - 1],
+      x_shape[rank - 2],
+      phi::errors::InvalidArgument("The last two dimensions must be equal. "
+                                   "But received x's dimension: [%s]",
+                                   x_shape));
+}
+
+// Cholesky input validation for static graph
+void CholeskyPreProcess(Value* x, bool* upper) {
+  auto x_shape = pir::GetShapeFromValue(*x);
+  int64_t rank = x_shape.size();
+  PADDLE_ENFORCE_GE(
+      rank,
+      2,
+      phi::errors::InvalidArgument("Shape must have at least 2 dimensions. "
+                                   "But received x's dimension: %ld.",
+                                   rank));
+  if (x_shape[rank - 1] > 0 && x_shape[rank - 2] > 0) {
+    PADDLE_ENFORCE_EQ(
+        x_shape[rank - 1],
+        x_shape[rank - 2],
+        phi::errors::InvalidArgument("The last two dimensions must be equal. "
+                                     "But received x's dimension."));
+  }
+}
+
 // Renorm preprocessing: handle negative axis
 void NegativeAxisPreProcess(Tensor* x, int* axis) {
   int rank = x->dims().size();

paddle/fluid/pybind/arg_pre_process.h

@@ -82,6 +82,15 @@ void NegativeAxisPreProcess(Value* x, int* axis);
 
 void PixelShufflePreProcess(std::string* data_format);
 
+// Eigh input validation: check shape >= 2D, last two dims equal, UPLO is 'L' or
+// 'U'
+void EighPreProcess(Tensor* x, std::string* UPLO);
+void EighPreProcess(Value* x, std::string* UPLO);
+
+// Cholesky input validation: check shape >= 2D, last two dims equal
+void CholeskyPreProcess(Tensor* x, bool* upper);
+void CholeskyPreProcess(Value* x, bool* upper);
+
 // Inplace API broadcast validation for dygraph
 void InplaceShapePreProcess(Tensor* x, Tensor* y);
 

paddle/phi/ops/yaml/python_api_info.yaml

@@ -287,6 +287,13 @@
   args_alias :
     use_default_mapping : True
 
+- op : cholesky
+  name : [paddle.cholesky, paddle.linalg.cholesky, paddle.Tensor.cholesky]
+  args_alias :
+    use_default_mapping : True
+  pre_process :
+    func : CholeskyPreProcess(x, upper)
+
 - op : conj
   name: [paddle.conj, paddle.Tensor.conj]
   args_alias :
@@ -325,12 +332,24 @@
     axis1 : [dim1]
     axis2 : [dim2]
 
+- op : det
+  name : [paddle.det, paddle.linalg.det, paddle.Tensor.det]
+  args_alias :
+    x : [input, A]
+
 - op : dot
   name : [paddle.dot, paddle.Tensor.dot]
   args_alias :
     x : [input]
     y : [tensor]
 
+- op : eigh
+  name : [paddle.linalg.eigh, paddle.Tensor.eigh]
+  args_alias :
+    use_default_mapping : True
+  pre_process :
+    func : EighPreProcess(x, UPLO)
+
 - op : erf
   name : [paddle.erf, paddle.Tensor.erf]
   args_alias :

python/paddle/__init__.py

@@ -444,12 +444,14 @@ def new_init(self, *args, **kwargs):
     histogram,
     histogram_bin_edges,
     histogramdd,
+    logdet,
     matmul,
     matrix_transpose,
     mv,
     norm,
     permute,
     pinv,
+    qr,
     t,
     t_,
     transpose,
@@ -515,6 +517,7 @@ def new_init(self, *args, **kwargs):
     dstack,
     expand,
     expand_as,
+    expand_copy,
     flatten,
     flatten_,
     flip,
@@ -622,7 +625,10 @@ def new_init(self, *args, **kwargs):
     broadcast_shapes,
     cartesian_prod,
     ceil,
+    clamp_max,
+    clamp_min,
     clip,
+    clip_,
     combinations,
     conj,
     copysign,
@@ -1055,6 +1061,8 @@ def __dir__(self):
 concatenate = concat
 take_along_dim = take_along_axis
 clamp = clip
+clamp_ = clip_
+true_divide_ = divide_
 ger = outer
 div = divide
 div_ = divide_
@@ -1080,6 +1088,7 @@ def __dir__(self):
 negative_ = neg_
 pinverse = pinv
 
+
 __all__ = [
     'block_diag',
     'gt',
@@ -1215,7 +1224,11 @@ def __dir__(self):
     'less_',
     'kron',
     'clip',
+    'clip_',
     'clamp',
+    'clamp_',
+    'clamp_max',
+    'clamp_min',
     'Tensor',
     'FloatTensor',
     'DoubleTensor',
@@ -1329,6 +1342,7 @@ def __dir__(self):
     'CPUPlace',
     'matmul',
     'pinverse',
+    'qr',
     'seed',
     'acos',
     'acos_',
@@ -1377,6 +1391,7 @@ def __dir__(self):
     'sub',
     'sub_',
     'true_divide',
+    'true_divide_',
     'gammaln',
     'gammaln_',
     'ceil',
@@ -1457,6 +1472,7 @@ def __dir__(self):
     'set_default_tensor_type',
     'disable_signal_handler',
     'expand_as',
+    'expand_copy',
     'stack',
     'hstack',
     'vstack',
@@ -1488,6 +1504,7 @@ def __dir__(self):
     'cosh',
     'log',
     'log_',
+    'logdet',
     'log2',
     'log2_',
     'log10',

python/paddle/_paddle_docs.py

@@ -3399,6 +3399,43 @@ def diag(
     ...
 
 
+@add_doc_and_signature
+def det(
+    x: Tensor,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
+) -> Tensor:
+    r"""
+
+    Calculates determinant value of a square matrix or batches of square matrices.
+
+    Args:
+        x (Tensor): the input matrix of size `(n, n)` or the
+            batch of matrices of size `(*, n, n)` where `*` is one or more
+            batch dimensions. Alias: ``input``.
+        name (str|None, optional): Name of the output.It's used to print debug info for
+            developers. Details: :ref:`api_guide_Name`. Default is None.
+
+    Returns:
+        Tensor, the determinant value of a square matrix or batches of square matrices.
+
+    Examples:
+        .. code-block:: pycon
+
+            >>> import paddle
+            >>> paddle.seed(2023)
+            >>> x = paddle.randn([3, 3, 3])
+            >>> A = paddle.linalg.det(x)
+            >>> print(A)
+            Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
+            [-1.29280925,  0.77832544,  0.89754158])
+
+
+    """
+    ...
+
+
 @add_doc_and_signature
 def diagonal(
     x: Tensor,
@@ -5618,3 +5655,107 @@ def square_(
     Inplace version of ``square`` API, the output Tensor will be inplaced with input ``x``.
     """
     ...
+
+
+@add_doc_and_signature
+def cholesky(
+    x: Tensor,
+    upper: bool = False,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
+) -> Tensor:
+    r"""
+    Computes the Cholesky decomposition of one symmetric positive-definite
+    matrix or batches of symmetric positive-definite matrices.
+
+    If ``upper`` is ``True``, the decomposition has the form :math:`A = U^{T}U`,
+    and the returned matrix :math:`U` is upper-triangular. Otherwise, the
+    decomposition has the form :math:`A = LL^{T}`, and the returned matrix
+    :math:`L` is lower-triangular.
+
+    Args:
+        x (Tensor): The input tensor. Its shape should be ``[*, M, M]``,
+            where ``*`` is zero or more batch dimensions, and matrices on the
+            inner-most 2 dimensions all should be symmetric positive-definite.
+            Its data type should be float32 or float64. Alias: ``input``.
+        upper (bool, optional): The flag indicating whether to return upper or lower
+            triangular matrices. Default: False.
+        name (str|None, optional): Name for the operation (optional, default is None).
+            For more information, please refer to :ref:`api_guide_Name`.
+
+    Keyword Args:
+        out (Tensor|optional): The output tensor. Default: None.
+
+    Returns:
+        Tensor: A Tensor with same shape and data type as ``x``. It represents
+        triangular matrices generated by Cholesky decomposition.
+
+    Examples:
+        .. code-block:: pycon
+
+            >>> import paddle
+            >>> paddle.seed(2023)
+
+            >>> a = paddle.rand([3, 3], dtype="float32")
+            >>> a_t = paddle.transpose(a, [1, 0])
+            >>> x = paddle.matmul(a, a_t) + 1e-03
+
+            >>> out = paddle.linalg.cholesky(x, upper=False)
+            >>> print(out)
+            Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
+            [[1.04337060, 0.        , 0.        ],
+             [1.06467676, 0.17859183, 0.        ],
+             [1.30602181, 0.08326342, 0.22790733]])
+    """
+    ...
+
+
+@add_doc_and_signature
+def eigh(
+    x: Tensor,
+    UPLO: Literal['L', 'U'] = 'L',
+    name: str | None = None,
+    *,
+    out: tuple[Tensor, Tensor] | None = None,
+) -> tuple[Tensor, Tensor]:
+    r"""
+    Compute the eigenvalues and eigenvectors of a
+    complex Hermitian (conjugate symmetric) or a real symmetric matrix.
+
+    Args:
+        x (Tensor): A tensor with shape ``[*, N, N]``. The data type of the input Tensor x
+            should be one of float32, float64, complex64, complex128. Alias: ``input``.
+        UPLO (str, optional): ``'L'`` represents the lower triangular matrix,
+            ``'U'`` represents the upper triangular matrix. Default: ``'L'``.
+        name (str|None, optional): The default value is None. Normally there is no need for
+            user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+    Keyword Args:
+        out (tuple(Tensor, Tensor)|optional): The output tensors. If provided, the eigenvalues
+            and eigenvectors will be stored in these tensors. Default: None.
+
+    Returns:
+        2-element tuple containing
+
+        - out_value(Tensor): A Tensor with shape ``[*, N]`` and data type of float32 and float64.
+          The eigenvalues of eigh op.
+        - out_vector(Tensor): A Tensor with shape ``[*, N, N]`` and data type of float32, float64,
+          complex64 and complex128. The eigenvectors of eigh op.
+
+    Examples:
+        .. code-block:: pycon
+
+            >>> import paddle
+
+            >>> x = paddle.to_tensor([[1, -2j], [2j, 5]])
+            >>> out_value, out_vector = paddle.linalg.eigh(x, UPLO='L')
+            >>> print(out_value)
+            Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True,
+            [0.17157286, 5.82842731])
+            >>> print(out_vector)
+            Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True,
+                   [[(-0.92387950+0.00000000j), (-0.38268340+0.00000000j)],
+                    [ (0.00000000+0.38268340j), (0.00000000-0.92387950j) ]])
+    """
+    ...