【SCU】【Paddle Tensor No.25】新增paddle.vecdot , paddle.linalg.vecdot

python/paddle/__init__.py

@@ -240,6 +240,7 @@
     t_,
     transpose,
     transpose_,
+    vecdot,
 )
 from .tensor.logic import (
     allclose,
@@ -1204,4 +1205,5 @@
     'positive',
     'from_dlpack',
     'to_dlpack',
+    'vecdot',
 ]

python/paddle/linalg.py

@@ -47,6 +47,7 @@
     svd_lowrank,
     triangular_solve,
     vector_norm,
+    vecdot,
 )
 
 __all__ = [
@@ -55,6 +56,7 @@
     'norm',
     'matrix_norm',
     'vector_norm',
+    'vecdot',
     'cond',
     'cov',
     'corrcoef',

python/paddle/tensor/__init__.py

@@ -102,6 +102,7 @@
     t_,
     transpose,
     transpose_,
+    vecdot,
 )
 from .logic import (  # noqa: F401
     allclose,

python/paddle/tensor/linalg.py

@@ -1867,6 +1867,48 @@ def dot(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
         return out
 
 
+def vecdot(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
+    """
+    This operator calculates inner product for vectors.
+
+    Note:
+       Support 1-d and 2-d Tensor. When it is 2d, the first dimension of this matrix
+       is the batch dimension, which means that the vectors of multiple batches are dotted.
+
+    Parameters:
+        x(Tensor): 1-D or 2-D ``Tensor``. Its dtype should be ``float32``, ``float64``, ``int32``, ``int64``, ``complex64``, ``complex128``
+        y(Tensor): 1-D or 2-D ``Tensor``. Its dtype should be ``float32``, ``float64``, ``int32``, ``int64``, ``complex64``, ``complex128``
+        name(str|None, optional): Name of the output. Default is None. It's used to print debug info for developers. Details: :ref:`api_guide_Name`
+
+    Returns:
+        Tensor: the calculated result Tensor.
+
+    Examples:
+
+        .. code-block:: python
+
+            >>> import paddle
+
+            >>> # 1-D Tensor * 1-D Tensor
+            >>> x = paddle.to_tensor([1, 2, 3])
+            >>> y = paddle.to_tensor([4, 5, 6])
+            >>> z = paddle.linalg.vecdot(x, y)
+            >>> print(z)
+            Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True,
+            32)
+
+            >>> # 2-D Tensor * 2-D Tensor
+            >>> x = paddle.to_tensor([[1, 2, 3], [2, 4, 6]])
+            >>> y = paddle.to_tensor([[4, 5, 6], [4, 5, 6]])
+            >>> z = paddle.linalg.vecdot(x, y)
+            >>> print(z)
+            Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [32, 64])
+
+    """
+    return dot(x, y)
+
+
 def cov(
     x: Tensor,
     rowvar: bool = True,

test/legacy_test/test_dot_op.py

@@ -138,6 +138,122 @@ def init_dtype(self):
         self.dtype = np.float64
 
 
+class VecDotOp(OpTest):
+    def setUp(self):
+        self.op_type = "dot"
+        self.prim_op_type = "prim"
+        self.python_api = paddle.vecdot
+        self.public_python_api = paddle.vecdot
+        self.init_dtype()
+        self.init_input_output()
+
+        self.inputs = {
+            'X': OpTest.np_dtype_to_base_dtype(self.x),
+            'Y': OpTest.np_dtype_to_base_dtype(self.y),
+        }
+        self.outputs = {'Out': self.out}
+        self.attrs = {}
+
+    def test_check_output(self):
+        self.check_output(check_pir=True)
+
+    def test_check_grad_normal(self):
+        if self.dtype == np.complex64 or self.dtype == np.complex128:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['X', 'Y'],
+                    'Out',
+                    user_defined_grads=[self.inputs['Y'], self.inputs['X']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(['X', 'Y'], 'Out', check_pir=True)
+        else:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['X', 'Y'],
+                    'Out',
+                    user_defined_grads=[self.inputs['Y'], self.inputs['X']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(
+                    ['X', 'Y'], 'Out', check_pir=True, check_prim_pir=True
+                )
+
+    def test_check_grad_ignore_x(self):
+        if self.dtype == np.complex64 or self.dtype == np.complex128:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['Y'],
+                    'Out',
+                    no_grad_set=set("X"),
+                    user_defined_grads=[self.inputs['X']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(
+                    ['Y'], 'Out', no_grad_set=set("X"), check_pir=True
+                )
+        else:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['Y'],
+                    'Out',
+                    no_grad_set=set("X"),
+                    user_defined_grads=[self.inputs['X']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(
+                    ['Y'],
+                    'Out',
+                    no_grad_set=set("X"),
+                    check_pir=True,
+                    check_prim_pir=True,
+                )
+
+    def test_check_grad_ignore_y(self):
+        if self.dtype == np.complex64 or self.dtype == np.complex128:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['X'],
+                    'Out',
+                    no_grad_set=set('Y'),
+                    user_defined_grads=[self.inputs['Y']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(
+                    ['X'], 'Out', no_grad_set=set('Y'), check_pir=True
+                )
+        else:
+            if core.is_compiled_with_rocm():
+                self.check_grad(
+                    ['X'],
+                    'Out',
+                    no_grad_set=set('Y'),
+                    user_defined_grads=[self.inputs['Y']],
+                    check_pir=True,
+                )
+            else:
+                self.check_grad(
+                    ['X'],
+                    'Out',
+                    no_grad_set=set('Y'),
+                    check_pir=True,
+                    check_prim_pir=True,
+                )
+
+    def init_input_output(self):
+        self.x = np.random.uniform(0.1, 1, [121]).astype(self.dtype)
+        self.y = np.random.uniform(1, 3, [121]).astype(self.dtype)
+        self.out = np.dot(self.x, self.y).astype(self.dtype)
+
+    def init_dtype(self):
+        self.dtype = np.float64
+
+
 class DotOpBatch(DotOp):
     def init_input_output(self):
         self.x = (