linalg.py 45.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
14

myq406450149's avatar
myq406450149 已提交
15
import numpy as np
Z
Zhang Ting 已提交
16 17
from ..fluid.layer_helper import LayerHelper
from ..fluid.data_feeder import check_variable_and_dtype, check_type
18
from ..fluid.framework import in_dygraph_mode, _varbase_creator, Variable
19

20
from ..fluid.layers import transpose, cast  # noqa: F401
21 22
from paddle.common_ops_import import core
from paddle.common_ops_import import VarDesc
W
wanghuancoder 已提交
23
from paddle import _C_ops
24

25 26
__all__ = []

27

S
ShenLiang 已提交
28
def matmul(x, y, transpose_x=False, transpose_y=False, name=None):
29
    """
30 31
    Applies matrix multiplication to two tensors. `matmul` follows
    the complete broadcast rules,
S
ShenLiang 已提交
32
    and its behavior is consistent with `np.matmul`.
S
swtkiwi 已提交
33

S
ShenLiang 已提交
34 35
    Currently, the input tensors' number of dimensions can be any, `matmul` can be used to
    achieve the `dot`, `matmul` and `batchmatmul`.
36 37 38 39 40

    The actual behavior depends on the shapes of :math:`x`, :math:`y` and the
    flag values of :attr:`transpose_x`, :attr:`transpose_y`. Specifically:

    - If a transpose flag is specified, the last two dimensions of the tensor
41 42
      are transposed. If the tensor is ndim-1 of shape, the transpose is invalid. If the tensor
      is ndim-1 of shape :math:`[D]`, then for :math:`x` it is treated as :math:`[1, D]`, whereas
S
ShenLiang 已提交
43 44 45 46 47 48 49 50
      for :math:`y` it is the opposite: It is treated as :math:`[D, 1]`.

    The multiplication behavior depends on the dimensions of `x` and `y`. Specifically:

    - If both tensors are 1-dimensional, the dot product result is obtained.

    - If both tensors are 2-dimensional, the matrix-matrix product is obtained.

51 52
    - If the `x` is 1-dimensional and the `y` is 2-dimensional,
      a `1` is prepended to its dimension in order to conduct the matrix multiply.
S
ShenLiang 已提交
53
      After the matrix multiply, the prepended dimension is removed.
54 55

    - If the `x` is 2-dimensional and `y` is 1-dimensional,
S
ShenLiang 已提交
56 57
      the matrix-vector product is obtained.

58 59 60 61 62 63 64 65 66
    - If both arguments are at least 1-dimensional and at least one argument
      is N-dimensional (where N > 2), then a batched matrix multiply is obtained.
      If the first argument is 1-dimensional, a 1 is prepended to its dimension
      in order to conduct the batched matrix multiply and removed after.
      If the second argument is 1-dimensional, a 1 is appended to its
      dimension for the purpose of the batched matrix multiple and removed after.
      The non-matrix (exclude the last two dimensions) dimensions are
      broadcasted according the broadcast rule.
      For example, if input is a (j, 1, n, m) tensor and the other is a (k, m, p) tensor,
S
ShenLiang 已提交
67
      out will be a (j, k, n, p) tensor.
68 69

    Args:
S
ShenLiang 已提交
70 71
        x (Tensor): The input tensor which is a Tensor.
        y (Tensor): The input tensor which is a Tensor.
72 73 74 75 76 77
        transpose_x (bool): Whether to transpose :math:`x` before multiplication.
        transpose_y (bool): Whether to transpose :math:`y` before multiplication.
        name(str|None): A name for this layer(optional). If set None, the layer
            will be named automatically.

    Returns:
S
ShenLiang 已提交
78
        Tensor: The output Tensor.
79 80 81

    Examples:

S
ShenLiang 已提交
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    .. code-block:: python

        import paddle
        import numpy as np

        # vector * vector
        x_data = np.random.random([10]).astype(np.float32)
        y_data = np.random.random([10]).astype(np.float32)
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
        z = paddle.matmul(x, y)
        print(z.numpy().shape)
        # [1]

        # matrix * vector
        x_data = np.random.random([10, 5]).astype(np.float32)
        y_data = np.random.random([5]).astype(np.float32)
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
        z = paddle.matmul(x, y)
        print(z.numpy().shape)
        # [10]

        # batched matrix * broadcasted vector
        x_data = np.random.random([10, 5, 2]).astype(np.float32)
        y_data = np.random.random([2]).astype(np.float32)
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
        z = paddle.matmul(x, y)
        print(z.numpy().shape)
        # [10, 5]

        # batched matrix * batched matrix
        x_data = np.random.random([10, 5, 2]).astype(np.float32)
        y_data = np.random.random([10, 2, 5]).astype(np.float32)
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
        z = paddle.matmul(x, y)
        print(z.numpy().shape)
        # [10, 5, 5]

        # batched matrix * broadcasted matrix
        x_data = np.random.random([10, 1, 5, 2]).astype(np.float32)
        y_data = np.random.random([1, 3, 2, 5]).astype(np.float32)
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
        z = paddle.matmul(x, y)
        print(z.numpy().shape)
        # [10, 3, 5, 5]
131 132

    """
S
ShenLiang 已提交
133 134
    op_type = 'matmul_v2'
    if in_dygraph_mode():
W
wanghuancoder 已提交
135
        op = getattr(_C_ops, op_type)
S
ShenLiang 已提交
136 137
        return op(x, y, 'trans_x', transpose_x, 'trans_y', transpose_y)

138
    attrs = {
S
ShenLiang 已提交
139 140
        'trans_x': transpose_x,
        'trans_y': transpose_y,
141 142 143 144 145
    }

    def __check_input(x, y):
        var_names = {'x': x, 'y': y}
        for name, val in var_names.items():
S
ShenLiang 已提交
146 147
            check_variable_and_dtype(
                val, name, ['float16', 'float32', 'float64'], 'matmul')
148 149 150

    __check_input(x, y)

S
ShenLiang 已提交
151
    helper = LayerHelper('matmul_v2', **locals())
152 153
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
    helper.append_op(
S
ShenLiang 已提交
154
        type='matmul_v2',
155 156 157 158 159
        inputs={'X': x,
                'Y': y},
        outputs={'Out': out},
        attrs=attrs)
    return out
Z
Zhang Ting 已提交
160 161


myq406450149's avatar
myq406450149 已提交
162
def norm(x, p='fro', axis=None, keepdim=False, name=None):
163
    """
S
swtkiwi 已提交
164

165 166 167
    Returns the matrix norm (Frobenius) or vector norm (the 1-norm, the Euclidean
    or 2-norm, and in general the p-norm for p > 0) of a given tensor.

168 169 170 171 172 173
    .. note::
        This norm API is different from `numpy.linalg.norm`.
        This api supports high-order input tensors (rank >= 3), and certain axis need to be pointed out to calculate the norm.
        But `numpy.linalg.norm` only supports 1-D vector or 2-D matrix as input tensor.
        For p-order matrix norm, this api actually treats matrix as a flattened vector to calculate the vector norm, NOT REAL MATRIX NORM.

174
    Args:
myq406450149's avatar
myq406450149 已提交
175
        x (Tensor): The input tensor could be N-D tensor, and the input data
176
            type could be float32 or float64.
myq406450149's avatar
myq406450149 已提交
177
        p (float|string, optional): Order of the norm. Supported values are `fro`, `0`, `1`, `2`,
178
            `inf`, `-inf` and any positive real number yielding the corresponding p-norm. Not supported: ord < 0 and nuclear norm.
myq406450149's avatar
myq406450149 已提交
179
            Default value is `fro`.
myq406450149's avatar
myq406450149 已提交
180 181
        axis (int|list|tuple, optional): The axis on which to apply norm operation. If axis is int
            or list(int)/tuple(int)  with only one element, the vector norm is computed over the axis.
182
            If `axis < 0`, the dimension to norm operation is rank(input) + axis.
myq406450149's avatar
myq406450149 已提交
183
            If axis is a list(int)/tuple(int) with two elements, the matrix norm is computed over the axis.
myq406450149's avatar
myq406450149 已提交
184
            Defalut value is `None`.
185 186 187 188 189 190 191 192
        keepdim (bool, optional): Whether to reserve the reduced dimension in the
            output Tensor. The result tensor will have fewer dimension
            than the :attr:`input` unless :attr:`keepdim` is true, default
            value is False.
        name (str, 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`.

    Returns:
myq406450149's avatar
myq406450149 已提交
193
        Tensor: results of norm operation on the specified axis of input tensor,
194
        it's data type is the same as input's Tensor.
195

196 197
    Examples:
        .. code-block:: python
198

199
            import paddle
myq406450149's avatar
myq406450149 已提交
200 201 202 203 204 205 206 207
            import numpy as np
            shape=[2, 3, 4]
            np_input = np.arange(24).astype('float32') - 12
            np_input = np_input.reshape(shape)
            x = paddle.to_tensor(np_input)
            #[[[-12. -11. -10.  -9.] [ -8.  -7.  -6.  -5.] [ -4.  -3.  -2.  -1.]]
            # [[  0.   1.   2.   3.] [  4.   5.   6.   7.] [  8.   9.  10.  11.]]]

208
            # compute frobenius norm along last two dimensions.
myq406450149's avatar
myq406450149 已提交
209 210 211
            out_fro = paddle.norm(x, p='fro', axis=[0,1])
            # out_fro.numpy() [17.435596 16.911535 16.7332   16.911535]

212 213
            # compute 2-order vector norm along last dimension.
            out_pnorm = paddle.norm(x, p=2, axis=-1)
myq406450149's avatar
myq406450149 已提交
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
            #out_pnorm.numpy(): [[21.118711  13.190906   5.477226]
            #                    [ 3.7416575 11.224972  19.131126]]

            # compute 2-order  norm along [0,1] dimension.
            out_pnorm = paddle.norm(x, p=2, axis=[0,1])
            #out_pnorm.numpy(): [17.435596 16.911535 16.7332   16.911535]

            # compute inf-order  norm
            out_pnorm = paddle.norm(x, p=np.inf)
            #out_pnorm.numpy()  = [12.]
            out_pnorm = paddle.norm(x, p=np.inf, axis=0)
            #out_pnorm.numpy(): [[12. 11. 10. 9.] [8. 7. 6. 7.] [8. 9. 10. 11.]]

            # compute -inf-order  norm
            out_pnorm = paddle.norm(x, p=-np.inf)
            #out_pnorm.numpy(): [0.]
            out_pnorm = paddle.norm(x, p=-np.inf, axis=0)
            #out_pnorm.numpy(): [[0. 1. 2. 3.] [4. 5. 6. 5.] [4. 3. 2. 1.]]
232 233
    """

myq406450149's avatar
myq406450149 已提交
234
    def frobenius_norm(input, dim=None, keepdim=False, name=None):
235 236 237 238 239 240 241 242 243 244 245
        """
        The frobenius norm OP is to calculate the frobenius norm of certain two dimensions of Tensor `input`.
        Args:
          input (Variable): Tensor, data type float32, float64.
          dim (list, optional): None for last two dimensions.
          keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False.
        """
        if dim is not None and not (isinstance(dim, list) and len(dim) == 2):
            raise ValueError(
                "The dim of frobenius norm op should be None or two elements list!"
            )
myq406450149's avatar
myq406450149 已提交
246
        if in_dygraph_mode():
myq406450149's avatar
myq406450149 已提交
247
            if dim is None:
W
wanghuancoder 已提交
248 249 250 251
                return _C_ops.frobenius_norm(input, 'keep_dim', keepdim,
                                             'reduce_all', True)
            return _C_ops.frobenius_norm(input, 'dim', dim, 'keep_dim', keepdim,
                                         'reduce_all', False)
myq406450149's avatar
myq406450149 已提交
252 253
        attrs = {'dim': dim, 'keep_dim': keepdim, 'reduce_all': False}
        if dim is None:
254 255 256 257 258
            attrs['reduce_all'] = True
        check_variable_and_dtype(input, 'input', ['float32', 'float64'],
                                 'frobenius_norm')

        helper = LayerHelper('frobenius_norm', **locals())
myq406450149's avatar
myq406450149 已提交
259 260
        out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())
261 262 263 264 265 266 267 268 269 270 271 272

        helper.append_op(
            type='frobenius_norm',
            inputs={'X': input},
            outputs={'Out': out},
            attrs=attrs)
        return out

    def vector_norm(input,
                    porder=None,
                    axis=None,
                    keepdim=False,
myq406450149's avatar
myq406450149 已提交
273
                    asvector=False,
274 275 276 277 278 279 280 281 282
                    name=None):
        """
        Calculate the p-order vector norm for certain  dimension of Tensor `input`.
        Args:
          input (Variable): Tensor, data type float32, float64.
          porder (float, optional): None for porder=2.0.
          axis (int, optional): None for last dimension.
          keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False.
        """
myq406450149's avatar
myq406450149 已提交
283 284
        if in_dygraph_mode():
            if axis is None: axis = -1
W
wanghuancoder 已提交
285 286
            return _C_ops.p_norm(input, 'porder', porder, 'axis', axis,
                                 'keepdim', keepdim, 'asvector', asvector)
287 288 289 290
        if porder is not None:
            check_type(porder, 'porder', (float, int), 'p_norm')
        if axis is not None:
            check_type(axis, 'axis', (int), 'p_norm')
myq406450149's avatar
myq406450149 已提交
291 292 293
        check_variable_and_dtype(input, 'input', ['float32', 'float64'],
                                 'p_norm')

294 295 296 297
        attrs = {
            'axis': axis if axis is not None else -1,
            'porder': float(porder) if porder is not None else 2.0,
            'keepdim': keepdim,
myq406450149's avatar
myq406450149 已提交
298
            'asvector': asvector,
299 300 301
            'epsilon': 1e-12,
        }
        helper = LayerHelper('p_norm', **locals())
myq406450149's avatar
myq406450149 已提交
302 303
        out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())
304 305 306 307 308 309 310 311

        helper.append_op(
            type='p_norm',
            inputs={'X': input},
            outputs={'Out': out},
            attrs=attrs)
        return out

myq406450149's avatar
myq406450149 已提交
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
    def inf_norm(input,
                 porder=None,
                 axis=axis,
                 keepdim=False,
                 asvector=False,
                 name=None):
        helper = LayerHelper('frobenius_norm', **locals())
        out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())
        helper.append_op(type='abs', inputs={'X': input}, outputs={'Out': out})
        reduce_out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())

        reduce_all = True if axis == None or axis == [] or asvector == True else False
        axis = axis if axis != None and axis != [] else [0]

        reduce_type = 'reduce_max' if porder == np.float(
            'inf') else 'reduce_min'
        helper.append_op(
            type=reduce_type,
            inputs={'X': out},
            outputs={'Out': reduce_out},
            attrs={'dim': axis,
                   'keep_dim': keepdim,
                   'reduce_all': reduce_all})

        return reduce_out

    def p_matrix_norm(input, porder=1., axis=axis, keepdim=False, name=None):
341 342 343 344
        """
        NOTE:
            This function actually treats the matrix as flattened vector to calculate vector norm instead of matrix norm.
        """
myq406450149's avatar
myq406450149 已提交
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
        block = LayerHelper('norm', **locals())
        out = block.create_variable_for_type_inference(
            dtype=block.input_dtype())
        abs_out = block.create_variable_for_type_inference(
            dtype=block.input_dtype())
        block.append_op(
            type='abs', inputs={'X': input}, outputs={'Out': abs_out})
        pow_out = block.create_variable_for_type_inference(
            dtype=block.input_dtype())

        block.append_op(
            type='pow',
            inputs={'X': abs_out},
            outputs={'Out': pow_out},
            attrs={'factor': porder})
        sum_out = block.create_variable_for_type_inference(
            dtype=block.input_dtype())
        block.append_op(
            type='reduce_sum',
            inputs={'X': pow_out},
            outputs={'Out': sum_out},
            attrs={
                'dim': axis,
                'keep_dim': keepdim,
                'reduce_all': True if axis is None else False
            })
        porder
        block.append_op(
            type='pow',
            inputs={'X': sum_out},
            outputs={'Out': out},
            attrs={'factor': float(1. / porder)})
        return out

379 380 381
    if axis is None and p is not None:
        if isinstance(p, str):
            if p == "fro":
myq406450149's avatar
myq406450149 已提交
382
                return frobenius_norm(x, dim=axis, keepdim=keepdim, name=name)
383 384 385 386 387
            else:
                raise ValueError(
                    "only valid string values are 'fro', found {}".format(p))
        elif isinstance(p, (int, float)):
            return vector_norm(
myq406450149's avatar
myq406450149 已提交
388 389 390 391 392 393
                x,
                porder=p,
                axis=axis,
                keepdim=keepdim,
                asvector=True,
                name=name)
394 395 396 397
        else:
            raise ValueError("only valid p type is string or float, found {}".
                             format(type(p)))

myq406450149's avatar
myq406450149 已提交
398 399
    if isinstance(axis, tuple):
        axis = list(axis)
400 401 402 403 404
    if isinstance(axis, list) and len(axis) == 1:
        axis = axis[0]

    #calculate vector norm, where axis is int or list with only one integer
    if isinstance(axis, int):
myq406450149's avatar
myq406450149 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417 418
        if isinstance(p, str):
            if p == "fro":
                return vector_norm(
                    x,
                    porder=2,
                    axis=axis,
                    keepdim=keepdim,
                    asvector=False,
                    name=name)

            else:
                raise ValueError(
                    "only valid string values are 'fro', found {}".format(p))
        elif isinstance(p, (int, float)):
419
            return vector_norm(
myq406450149's avatar
myq406450149 已提交
420 421 422 423 424 425
                x,
                axis=axis,
                porder=p,
                keepdim=keepdim,
                asvector=False,
                name=name)
426 427 428 429 430 431 432
        else:
            raise ValueError(
                "unspport p for p-order vector norm. except float, found {}".
                format(p))
    #calculate matrix norm, where axis is list with two integers
    elif isinstance(axis, list) and len(axis) == 2:
        if p == "fro":
myq406450149's avatar
myq406450149 已提交
433 434 435
            return frobenius_norm(x, dim=axis, keepdim=keepdim, name=name)
        elif p == np.inf or p == -np.inf:
            return inf_norm(x, porder=p, axis=axis, keepdim=keepdim, name=name)
myq406450149's avatar
myq406450149 已提交
436 437 438 439
        elif p == 0:
            raise ValueError(
                "just suport axis type int or list (length of list <=1) if p = 0, found {}".
                format(axis))
440
        else:
myq406450149's avatar
myq406450149 已提交
441 442
            return p_matrix_norm(
                x, porder=p, axis=axis, keepdim=keepdim, name=name)
443 444 445 446 447 448
    else:
        raise ValueError(
            "except axis type int or list (length of list <=2), found {}".
            format(axis))


Z
Zhang Ting 已提交
449
def dist(x, y, p=2):
450
    r"""
S
swtkiwi 已提交
451

Z
Zhang Ting 已提交
452
    This OP returns the p-norm of (x - y). It is not a norm in a strict sense, only as a measure
453 454
    of distance. The shapes of x and y must be broadcastable. The definition is as follows, for
    details, please refer to the `numpy's broadcasting <https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`_:
Z
Zhang Ting 已提交
455

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
    - Each input has at least one dimension.
    - Match the two input dimensions from back to front, the dimension sizes must either be equal, one of them is 1, or one of them does not exist.

    Where, z = x - y, the shapes of x and y are broadcastable, then the shape of z can be
    obtained as follows:

    1. If the number of dimensions of x and y are not equal, prepend 1 to the dimensions of the
    tensor with fewer dimensions.

    For example, The shape of x is [8, 1, 6, 1], the shape of y is [7, 1, 5], prepend 1 to the
    dimension of y.

    x (4-D Tensor):  8 x 1 x 6 x 1

    y (4-D Tensor):  1 x 7 x 1 x 5

    2. Determine the size of each dimension of the output z: choose the maximum value from the
    two input dimensions.

    z (4-D Tensor):  8 x 7 x 6 x 5

    If the number of dimensions of the two inputs are the same, the size of the output can be
    directly determined in step 2. When p takes different values, the norm formula is as follows:
Z
Zhang Ting 已提交
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504

    When p = 0, defining $0^0=0$, the zero-norm of z is simply the number of non-zero elements of z.

    .. math::

        ||z||_{0}=\lim_{p \\rightarrow 0}\sum_{i=1}^{m}|z_i|^{p}

    When p = inf, the inf-norm of z is the maximum element of z.

    .. math::

        ||z||_\infty=\max_i |z_i|

    When p = -inf, the negative-inf-norm of z is the minimum element of z.

    .. math::

        ||z||_{-\infty}=\min_i |z_i|

    Otherwise, the p-norm of z follows the formula,

    .. math::

        ||z||_{p}=(\sum_{i=1}^{m}|z_i|^p)^{\\frac{1}{p}}

    Args:
505 506
        x (Tensor): 1-D to 6-D Tensor, its data type is float32 or float64.
        y (Tensor): 1-D to 6-D Tensor, its data type is float32 or float64.
Z
Zhang Ting 已提交
507 508 509
        p (float, optional): The norm to be computed, its data type is float32 or float64. Default: 2.

    Returns:
510
        Tensor: Tensor that is the p-norm of (x - y).
Z
Zhang Ting 已提交
511 512 513 514 515 516 517

    Examples:
        .. code-block:: python

            import paddle
            import numpy as np

518 519 520 521
            x = paddle.to_tensor(np.array([[3, 3],[3, 3]]), "float32")
            y = paddle.to_tensor(np.array([[3, 3],[3, 1]]), "float32")
            out = paddle.dist(x, y, 0)
            print(out) # out = [1.]
Z
Zhang Ting 已提交
522

523 524
            out = paddle.dist(x, y, 2)
            print(out) # out = [2.]
Z
Zhang Ting 已提交
525

526 527
            out = paddle.dist(x, y, float("inf"))
            print(out) # out = [2.]
Z
Zhang Ting 已提交
528

529 530
            out = paddle.dist(x, y, float("-inf"))
            print(out) # out = [0.]
Z
Zhang Ting 已提交
531 532 533 534 535 536 537 538 539 540 541 542 543
    """
    check_variable_and_dtype(x, 'dtype', ['float32', 'float64'], 'dist')
    check_variable_and_dtype(y, 'dtype', ['float32', 'float64'], 'dist')
    check_type(p, 'p', (float, int), 'dist')
    helper = LayerHelper("dist", **locals())
    out = helper.create_variable_for_type_inference(x.dtype)

    inputs = {"X": [x], "Y": [y]}
    outputs = {'Out': [out]}
    attrs = {"p": float(p)}
    helper.append_op(
        type='dist', inputs=inputs, outputs={'Out': out}, attrs=attrs)
    return out
L
liuwei1031 已提交
544 545 546 547 548


def dot(x, y, name=None):
    """
    This operator calculates inner product for vectors.
549

L
liuwei1031 已提交
550
    .. note::
551 552
       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.
L
liuwei1031 已提交
553 554

    Parameters:
S
ShenLiang 已提交
555 556
        x(Tensor): 1-D or 2-D ``Tensor``. Its dtype should be ``float32``, ``float64``, ``int32``, ``int64``
        y(Tensor): 1-D or 2-D ``Tensor``. Its dtype soulde be ``float32``, ``float64``, ``int32``, ``int64``
L
liuwei1031 已提交
557 558
        name(str, optional): Name of the output. Default is None. It's used to print debug info for developers. Details: :ref:`api_guide_Name`

559
    Returns:
560
        Tensor: the calculated result Tensor.
561

L
liuwei1031 已提交
562 563 564 565 566 567
    Examples:

    .. code-block:: python

        import paddle
        import numpy as np
568 569 570

        x_data = np.random.uniform(0.1, 1, [10]).astype(np.float32)
        y_data = np.random.uniform(1, 3, [10]).astype(np.float32)
S
ShenLiang 已提交
571 572
        x = paddle.to_tensor(x_data)
        y = paddle.to_tensor(y_data)
573
        z = paddle.dot(x, y)
574
        print(z)
L
liuwei1031 已提交
575 576 577

    """
    op_type = 'dot'
578 579
    # skip var type check in dygraph mode to improve efficiency
    if in_dygraph_mode():
W
wanghuancoder 已提交
580
        op = getattr(_C_ops, op_type)
581 582
        return op(x, y)

L
liuwei1031 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
    assert x is not None, 'x cannot be None in {}'.format(op_type)
    assert y is not None, 'y cannot be None in {}'.format(op_type)

    check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
                             op_type)
    check_variable_and_dtype(y, 'y', ['float32', 'float64', 'int32', 'int64'],
                             op_type)

    helper = LayerHelper(op_type, **locals())
    if name is None:
        out = helper.create_variable_for_type_inference(dtype=x.dtype)
    else:
        out = helper.create_variable(
            name=name, dtype=x.dtype, persistable=False)
    helper.append_op(
        type="dot", inputs={'X': x,
                            'Y': y}, attrs={}, outputs={"Out": out})
    return out
601 602 603 604


def t(input, name=None):
    """
605 606
    Transpose <=2-D tensor.
    0-D and 1-D tensors are returned as it is and 2-D tensor is equal to
607
    the paddle.transpose function which perm dimensions set 0 and 1.
608

609
    Args:
610
        input (Tensor): The input Tensor. It is a N-D (N<=2) Tensor of data types float16, float32, float64, int32.
611
        name(str, optional): The default value is None.  Normally there is no need for
612 613
            user to set this property.  For more information, please refer to :ref:`api_guide_Name`
    Returns:
614
        Tensor: A transposed n-D Tensor, with data type being float16, float32, float64, int32, int64.
615

616
    For Example:
617

618
        .. code-block:: text
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

             # Example 1 (0-D tensor)
             x = tensor([0.79])
             paddle.t(x) = tensor([0.79])

             # Example 2 (1-D tensor)
             x = tensor([0.79, 0.84, 0.32])
             paddle.t(x) = tensor([0.79, 0.84, 0.32])

             # Example 3 (2-D tensor)
             x = tensor([0.79, 0.84, 0.32],
                        [0.64, 0.14, 0.57])
             paddle.t(x) = tensor([0.79, 0.64],
                                  [0.84, 0.14],
                                  [0.32, 0.57])

635
     Examples:
636

637
        .. code-block:: python
638

639
            import paddle
640
            x = paddle.ones(shape=[2, 3], dtype='int32')
641
            x_transposed = paddle.t(x)
642 643
            print(x_transposed.shape)
            # [3, 2]
644 645 646 647 648 649 650 651 652 653 654
    """
    if len(input.shape) > 2:
        raise ValueError(
            "Input(input) only support N-D (N<=2) tensor, but received "
            "length of Input(input) is %s. Perhaps you can use paddle."
            "tensor.transpose() instead." % len(input.shape))
    if in_dygraph_mode():
        if len(input.shape) == 1:
            return input
        # 2-D tensor
        perm = [1, 0]
W
wanghuancoder 已提交
655
        out, _ = _C_ops.transpose2(input, 'axis', perm)
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
        return out

    check_variable_and_dtype(
        input, 'input', ['float16', 'float32', 'float64', 'int32', 'int64'],
        'transpose')

    helper = LayerHelper('t', **locals())
    out = helper.create_variable_for_type_inference(input.dtype)
    input_shape = helper.create_variable_for_type_inference(input.dtype)
    if len(input.shape) == 1:
        out = input
    else:
        helper.append_op(
            type='transpose2',
            inputs={'X': [input]},
            outputs={'Out': [out],
                     'XShape': [input_shape]},
            attrs={'axis': [1, 0]})
    return out
675 676


677
def cross(x, y, axis=None, name=None):
678
    """
679
    Computes the cross product between two tensors along an axis.
680

681 682
    Inputs must have the same shape, and the length of their axes should be equal to 3.
    If `axis` is not given, it defaults to the first axis found with the length 3.
683

684
    Args:
685 686
        x (Tensor): The first input tensor.
        y (Tensor): The second input tensor.
687
        axis (int, optional): The axis along which to compute the cross product. It defaults to the first axis found with the length 3.
688
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
689 690

    Returns:
691
        Tensor. A Tensor with same data type as `x`.
692

693 694
    Examples:
        .. code-block:: python
695

696
            import paddle
697

Z
Zhou Wei 已提交
698 699 700 701 702 703
            x = paddle.to_tensor([[1.0, 1.0, 1.0],
                                  [2.0, 2.0, 2.0],
                                  [3.0, 3.0, 3.0]])
            y = paddle.to_tensor([[1.0, 1.0, 1.0],
                                  [1.0, 1.0, 1.0],
                                  [1.0, 1.0, 1.0]])
704

705 706 707 708 709 710 711 712 713
            z1 = paddle.cross(x, y)
            # [[-1. -1. -1.]
            #  [ 2.  2.  2.]
            #  [-1. -1. -1.]]

            z2 = paddle.cross(x, y, axis=1)
            # [[0. 0. 0.]
            #  [0. 0. 0.]
            #  [0. 0. 0.]]
714 715
    """
    if in_dygraph_mode():
716
        if axis is not None:
W
wanghuancoder 已提交
717
            return _C_ops.cross(x, y, 'dim', axis)
718
        else:
W
wanghuancoder 已提交
719
            return _C_ops.cross(x, y)
720

721 722
    helper = LayerHelper("cross", **locals())
    out = helper.create_variable_for_type_inference(x.dtype)
723
    attrs = dict()
724
    attrs['dim'] = axis
725 726 727

    helper.append_op(
        type='cross',
728 729
        inputs={'X': x,
                'Y': y},
730 731 732
        outputs={'Out': out},
        attrs=attrs)
    return out
733 734


735
def cholesky(x, upper=False, name=None):
736
    r"""
G
Guo Sheng 已提交
737
    Computes the Cholesky decomposition of one symmetric positive-definite
738 739
    matrix or batches of symmetric positive-definite matrice.

G
Guo Sheng 已提交
740 741 742 743 744 745
    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:
746
        x (Tensor): The input tensor. Its shape should be `[*, M, M]`,
G
Guo Sheng 已提交
747 748 749 750 751 752 753
            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.
        upper (bool): The flag indicating whether to return upper or lower
            triangular matrices. Default: False.

    Returns:
754
        Tensor: A Tensor with same shape and data type as `x`. It represents \
G
Guo Sheng 已提交
755
            triangular matrices generated by Cholesky decomposition.
756

G
Guo Sheng 已提交
757 758 759 760 761 762
    Examples:
        .. code-block:: python

            import paddle
            import numpy as np

763 764 765
            a = np.random.rand(3, 3)
            a_t = np.transpose(a, [1, 0])
            x_data = np.matmul(a, a_t) + 1e-03
766
            x = paddle.to_tensor(x_data)
767
            out = paddle.cholesky(x, upper=False)
768
            print(out)
769 770 771
            # [[1.190523   0.         0.        ]
            #  [0.9906703  0.27676893 0.        ]
            #  [1.25450498 0.05600871 0.06400121]]
G
Guo Sheng 已提交
772 773

    """
774
    if in_dygraph_mode():
W
wanghuancoder 已提交
775
        return _C_ops.cholesky(x, "upper", upper)
G
Guo Sheng 已提交
776 777 778 779 780 781 782 783 784 785 786 787
    check_variable_and_dtype(x, 'dtype', ['float32', 'float64'], 'cholesky')
    check_type(upper, 'upper', bool, 'cholesky')
    helper = LayerHelper('cholesky', **locals())
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
    helper.append_op(
        type='cholesky',
        inputs={'X': [x]},
        outputs={'Out': out},
        attrs={'upper': upper})
    return out


788 789 790 791
def matrix_rank(x, tol=None, hermitian=False, name=None):
    r"""
    Computes the rank of a matrix.

792
    The rank of a matrix is the number of singular values that are greater than the specified tol threshold when hermitian=False,
793 794 795
    or the number of eigenvalues in absolute value that are greater than the specified tol threshold when hermitian=True.

    Args:
796 797 798 799 800 801
        x (Tensor): The input tensor.
            Its shape should be [..., m, n], where ... is zero or more batch dimensions. If x is a batch of matrices then the output
            has the same batch dimensions. The data type of x should be float32 or float64.
        tol (float,Tensor,optional): the tolerance value. Default: None.
            If tol is not specified, and sigma is the largest singular value (or eigenvalue in absolute value), and eps is the
            epsilon value for the dtype of x, then tol is computed with formula tol=sigma * max(m,n) * eps. Note that if x is
802 803
            a batch of matrices, tol is computed this way for every batch.
        hermitian (bool,optional): indicates whether x is Hermitian. Default: False.
804
            When hermitian=True, x is assumed to be Hermitian, but x is not checked inside the function. Instead, We just use the
805 806 807 808 809
            lower triangular of the matrix to compute.
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

    Returns:
        Tensor: Rank of tensor x.
810

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
    Examples:
        .. code-block:: python

            import paddle

            a = paddle.eye(10)
            b = paddle.linalg.matrix_rank(a)
            print(b)
            # b = [10]

            c = paddle.ones(shape=[3, 4, 5, 5])
            d = paddle.linalg.matrix_rank(c, tol=0.01, hermitian=True)
            print(d)
            # d = [[1, 1, 1, 1],
            #      [1, 1, 1, 1],
            #      [1, 1, 1, 1]]
827

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
    """

    if in_dygraph_mode():
        if tol is None:
            tol_tensor = None
            tol_attr = 0.0
            use_default_tol = True
        elif isinstance(tol, Variable):
            if tol.dtype != x.dtype:
                tol_tensor = cast(tol, x.dtype)
            else:
                tol_tensor = tol
            tol_attr = 0.0
            use_default_tol = False
        else:
            tol_tensor = None
            tol_attr = float(tol)
            use_default_tol = False
        return _C_ops.matrix_rank(x, tol_tensor, "tol", tol_attr, 'hermitian',
                                  hermitian, 'use_default_tol', use_default_tol)

    inputs = {}
    attrs = {}
    check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'matrix_rank')
    inputs['X'] = x
    if tol is None:
        attrs['use_default_tol'] = True
    elif isinstance(tol, Variable):
        check_variable_and_dtype(tol, 'tol', ['float32'], 'matrix_rank')
        attrs['use_default_tol'] = False
        if tol.dtype != x.dtype:
            inputs['TolTensor'] = cast(tol, x.dtype)
        else:
            inputs['TolTensor'] = tol
    else:
        check_type(tol, 'tol', float, 'matrix_rank')
        attrs['use_default_tol'] = False
        attrs['tol'] = tol
    check_type(hermitian, 'hermitian', bool, 'matrix_rank')
    attrs['hermitian'] = hermitian

    helper = LayerHelper('matrix_rank', **locals())
    out = helper.create_variable_for_type_inference(dtype='int32')
    helper.append_op(
        type='matrix_rank', inputs=inputs, outputs={'Out': out}, attrs=attrs)
    return out


876 877 878 879 880 881 882 883 884
def bmm(x, y, name=None):
    """
    Applies batched matrix multiplication to two tensors.

    Both of the two input tensors must be three-dementional and share the same batch size.

    if x is a (b, m, k) tensor, y is a (b, k, n) tensor, the output will be a (b, m, n) tensor.

    Args:
Y
yaoxuefeng 已提交
885 886
        x (Tensor): The input Tensor.
        y (Tensor): The input Tensor.
887 888 889 890
        name(str|None): A name for this layer(optional). If set None, the layer
            will be named automatically.

    Returns:
Y
yaoxuefeng 已提交
891
        Tensor: The product Tensor.
892 893

    Examples:
S
sunzhongkai588 已提交
894 895 896
        .. code-block:: python

            import paddle
Y
yaoxuefeng 已提交
897

S
sunzhongkai588 已提交
898 899 900 901 902 903 904 905 906 907 908 909 910 911
            # In imperative mode:
            # size x: (2, 2, 3) and y: (2, 3, 2)
            x = paddle.to_tensor([[[1.0, 1.0, 1.0],
                                [2.0, 2.0, 2.0]],
                                [[3.0, 3.0, 3.0],
                                [4.0, 4.0, 4.0]]])
            y = paddle.to_tensor([[[1.0, 1.0],[2.0, 2.0],[3.0, 3.0]],
                                [[4.0, 4.0],[5.0, 5.0],[6.0, 6.0]]])
            out = paddle.bmm(x, y)
            #output size: (2, 2, 2)
            #output value:
            #[[[6.0, 6.0],[12.0, 12.0]],[[45.0, 45.0],[60.0, 60.0]]]
            out_np = out.numpy()
            
912
    """
Y
yaoxuefeng 已提交
913 914 915 916 917 918 919 920 921 922
    x_shape = x.shape
    y_shape = y.shape
    if not len(x_shape) == len(y_shape) == 3:
        raise ValueError(
            "x and y should be 3-dimensional. But received x's dimention: {}, y's dimention: {}".
            format(x_shape, y_shape))
    if x_shape[2] != y_shape[1]:
        raise ValueError(
            "x's width must be equal with y's height. But received x's shape: {}, y's shape: {}".
            format(x_shape, y_shape))
923 924 925 926
    if x_shape[0] != y_shape[0]:
        raise ValueError(
            "x's batch (shape[0]) must be equal with y's batch (shape[0]). But received x's shape: {}, y's shape: {}".
            format(x_shape, y_shape))
927

928
    if in_dygraph_mode():
W
wanghuancoder 已提交
929
        return _C_ops.bmm(x, y)
930 931

    helper = LayerHelper('bmm', **locals())
932 933 934
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
    helper.append_op(type='bmm', inputs={'X': x, 'Y': y}, outputs={'Out': out})
    return out
Q
Qi Li 已提交
935 936 937 938


def histogram(input, bins=100, min=0, max=0):
    """
939
    Computes the histogram of a tensor. The elements are sorted into equal width bins between min and max.
Q
Qi Li 已提交
940 941 942
    If min and max are both zero, the minimum and maximum values of the data are used.

    Args:
943
        input (Tensor): A Tensor(or LoDTensor) with shape :math:`[N_1, N_2,..., N_k]` . The data type of the input Tensor
Q
Qi Li 已提交
944 945 946 947 948 949
            should be float32, float64, int32, int64.
        bins (int): number of histogram bins
        min (int): lower end of the range (inclusive)
        max (int): upper end of the range (inclusive)

    Returns:
950
        Tensor: data type is int64, shape is (nbins,).
Q
Qi Li 已提交
951

952
    Examples:
Q
Qi Li 已提交
953
        .. code-block:: python
954

Q
Qi Li 已提交
955
            import paddle
956

957
            inputs = paddle.to_tensor([1, 2, 1])
958 959
            result = paddle.histogram(inputs, bins=4, min=0, max=3)
            print(result) # [0, 2, 1, 0]
Q
Qi Li 已提交
960 961
    """
    if in_dygraph_mode():
W
wanghuancoder 已提交
962
        return _C_ops.histogram(input, "bins", bins, "min", min, "max", max)
Q
Qi Li 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975

    helper = LayerHelper('histogram', **locals())
    check_variable_and_dtype(
        input, 'X', ['int32', 'int64', 'float32', 'float64'], 'histogram')
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
    helper.append_op(
        type='histogram',
        inputs={'X': input},
        outputs={'Out': out},
        attrs={'bins': bins,
               'min': min,
               'max': max})
    return out
976 977 978 979 980 981 982


def mv(x, vec, name=None):
    """
    Performs a matrix-vector product of the matrix x and the vector vec.

    Args:
F
furnace 已提交
983
        x (Tensor): A tensor with shape :math:`[M, N]` , The data type of the input Tensor x
984
            should be one of float32, float64.
F
furnace 已提交
985
        vec (Tensor): A tensor with shape :math:`[N]` , The data type of the input Tensor x
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
            should be one of float32, float64.
        name(str, 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`.

    Returns:
        Tensor: The tensor which is producted by x and vec.

    Examples:
        .. code-block:: python

            # x: [M, N], vec: [N]
            # paddle.mv(x, vec)  # out: [M]

            import numpy as np
            import paddle

            x_data = np.array([[2, 1, 3], [3, 0, 1]]).astype("float64")
            x = paddle.to_tensor(x_data)
            vec_data = np.array([3, 5, 1])
            vec = paddle.to_tensor(vec_data).astype("float64")
            out = paddle.mv(x, vec)
    """
    if in_dygraph_mode():
W
wanghuancoder 已提交
1009
        out = _C_ops.mv(x, vec)
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
        return out

    def __check_input(x, vec):
        var_names = {'x': x, 'vec': vec}
        for name, val in var_names.items():
            check_variable_and_dtype(val, name, ['float32', 'float64'], 'mv')
        x_shape = list(x.shape)
        vec_shape = list(vec.shape)
        if len(x_shape) != 2:
            raise ValueError(
                "x should be 2-dimensional. But received x's dimention: {}".
                format(x_shape))
        if len(vec_shape) != 1:
            raise ValueError(
                "vec should be 1-dimensional. But received vec's dimention: {}".
                format(vec_shape))

    __check_input(x, vec)

    helper = LayerHelper('mv', **locals())
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
    helper.append_op(
        type='mv', inputs={'X': x,
                           'Vec': vec}, outputs={'Out': out})
    return out
1035 1036


1037 1038
def svd(x, full_matrices=False, name=None):
    r"""
1039 1040 1041 1042 1043 1044 1045
    Computes the singular value decomposition of one matrix or a batch of regular matrices.

    Let :math:`X` be the input matrix or a batch of input matrices, the output should satisfies:

    .. math::
        X = U * diag(S) * VT 
 
1046 1047
    Args:
        x (Tensor): The input tensor. Its shape should be `[..., N, M]`,
1048
            where `...` is zero or more batch dimensions. N and M can be arbitraty
1049
            positive number. Note that if x is sigular matrices, the grad is numerical 
1050 1051
            instable. The data type of x should be float32 or float64. 
        full_matrices (bool): A flag to control the behavor of svd. 
1052
            If full_matrices = True, svd op will compute full U and V matrics, 
1053
            which means shape of U is `[..., N, N]`, shape of V is `[..., M, M]`. K = min(M, N).
1054
            If full_matrices = False, svd op will use a economic method to store U and V. 
1055 1056 1057
            which means shape of U is `[..., N, K]`, shape of V is `[..., M, K]`. K = min(M, N).
        name (str, optional): Name for the operation (optional, default is None). 
            For more information, please refer to :ref:`api_guide_Name`.
1058 1059

    Returns:
1060
        Tuple of 3 tensors: (U, S, VH). VH is the conjugate transpose of V. S is the singlar value vectors of matrics with shape `[..., K]`
1061

1062 1063 1064 1065
    Examples:
        .. code-block:: python

            import paddle
1066 1067 1068

            x = paddle.to_tensor([[1.0, 2.0], [1.0, 3.0], [4.0, 6.0]]).astype('float64')
            x = x.reshape([3, 2])
1069
            u, s, vh = paddle.linalg.svd(x)
1070 1071 1072 1073 1074
            print (u)
            #U = [[ 0.27364809, -0.21695147  ],
            #      [ 0.37892198, -0.87112408 ],
            #      [ 0.8840446 ,  0.44053933 ]]

1075
            print (s)
1076
            #S = [8.14753743, 0.78589688]
1077
            print (vh)
1078 1079 1080
            #VT= [[ 0.51411221,  0.85772294],
            #     [ 0.85772294, -0.51411221]]
            
1081 1082 1083
            # one can verify : U * S * VT == X
            #                  U * UH == I 
            #                  V * VH == I
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
    """

    if in_dygraph_mode():
        return _C_ops.svd(x, 'full_matrices', full_matrices)
    check_variable_and_dtype(x, 'dtype', ['float32', 'float64'], 'svd')
    check_type(full_matrices, 'full_matrices', bool, 'svd')
    helper = LayerHelper('svd', **locals())
    u = helper.create_variable_for_type_inference(dtype=x.dtype)
    vh = helper.create_variable_for_type_inference(dtype=x.dtype)
    s = helper.create_variable_for_type_inference(dtype=x.dtype)
    attrs = dict()
    attrs['full_matrices'] = full_matrices
    helper.append_op(
        type='svd',
        inputs={'X': [x]},
        outputs={'U': u,
                 'VH': vh,
                 'S': s},
        attr=attrs, )
    return u, s, vh


1106 1107 1108 1109 1110 1111 1112 1113 1114
def matrix_power(x, n, name=None):
    r"""
    Computes the n-th power of a square matrix or a batch of square matrices.

    Let :math:`X` be a sqaure matrix or a batch of square matrices, :math:`n` be
    an exponent, the equation should be:

    .. math::
        Out = X ^ {n}
1115

1116 1117 1118 1119
    Specifically,

    - If `n > 0`, it returns the matrix or a batch of matrices raised to the power
    of `n`.
1120

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
    - If `n = 0`, it returns the identity matrix or a batch of identity matrices.

    - If `n < 0`, it returns the inverse of each matrix (if invertible) raised to
    the power of `abs(n)`.

    Args:
        x (Tensor): A square matrix or a batch of square matrices to be raised
            to power `n`. Its shape should be `[*, M, M]`, where `*` is zero or
            more batch dimensions. Its data type should be float32 or float64.
        n (int): The exponent. It can be any positive, negative integer or zero.
1131
        name (str, optional): Name for the operation (optional, default is None).
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
            For more information, please refer to :ref:`api_guide_Name`.

    Returns:
        Tensor: The n-th power of the matrix (or the batch of matrices) `x`. Its
            data type should be the same as that of `x`.

    Examples:
        .. code-block:: python

            import paddle

            x = paddle.to_tensor([[1, 2, 3],
                                  [1, 4, 9],
                                  [1, 8, 27]], dtype='float64')
            print(paddle.matrix_power(x, 2))
            # [[6.  , 34. , 102.],
            #  [14. , 90. , 282.],
            #  [36. , 250., 804.]]

            print(paddle.matrix_power(x, 0))
            # [[1., 0., 0.],
            #  [0., 1., 0.],
            #  [0., 0., 1.]]

            print(paddle.matrix_power(x, -2))
            # [[ 12.91666667, -12.75000000,  2.83333333 ],
            #  [-7.66666667 ,  8.         , -1.83333333 ],
            #  [ 1.80555556 , -1.91666667 ,  0.44444444 ]]
    """
    if in_dygraph_mode():
        return core.ops.matrix_power(x, "n", n)

    check_variable_and_dtype(x, 'dtype', ['float32', 'float64'], 'matrix_power')
    check_type(n, 'n', int, 'matrix_power')
    helper = LayerHelper('matrix_power', **locals())
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
    helper.append_op(
        type='matrix_power',
        inputs={'X': x},
        outputs={'Out': out},
        attrs={'n': n})
    return out
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253


def multi_dot(x, name=None):
    """
    Multi_dot is an operator that calculates multiple matrix multiplications.

    Supports inputs of float, double and float16 dtypes. This function does not
    support batched inputs.

    The input tensor in [x] must be 2-D except for the first and last can be 1-D.
    If the first tensor is a 1-D vector of shape(n, ) it is treated as row vector
    of shape(1, n), similarly if the last tensor is a 1D vector of shape(n, ), it
    is treated as a column vector of shape(n, 1).

    If the first and last tensor are 2-D matrix, then the output is also 2-D matrix,
    otherwise the output is a 1-D vector.

    Multi_dot will select the lowest cost multiplication order for calculation. The
    cost of multiplying two matrices with shapes (a, b) and (b, c) is a * b * c.
    Given matrices A, B, C with shapes (20, 5), (5, 100), (100, 10) respectively,
    we can calculate the cost of different multiplication orders as follows:
    - Cost((AB)C) = 20x5x100 + 20x100x10 = 30000
    - Cost(A(BC)) = 5x100x10 + 20x5x10 = 6000

    In this case, multiplying B and C first, then multiply A, which is 5 times faster
    than sequential calculation.

    Args:
        x ([Tensor]): The input tensors which is a list Tensor.
        name(str|None): A name for this layer(optional). If set None, the layer
            will be named automatically.

    Returns:
        Tensor: The output Tensor.


    Examples:

    .. code-block:: python

        import paddle
        import numpy as np

        # A * B
        A_data = np.random.random([3, 4]).astype(np.float32)
        B_data = np.random.random([4, 5]).astype(np.float32)
        A = paddle.to_tensor(A_data)
        B = paddle.to_tensor(B_data)
        out = paddle.multi_dot([A, B])
        print(out.numpy().shape)
        # [3, 5]

        # A * B * C
        A_data = np.random.random([10, 5]).astype(np.float32)
        B_data = np.random.random([5, 8]).astype(np.float32)
        C_data = np.random.random([8, 7]).astype(np.float32)
        A = paddle.to_tensor(A_data)
        B = paddle.to_tensor(B_data)
        C = paddle.to_tensor(C_data)
        out = paddle.multi_dot([A, B, C])
        print(out.numpy().shape)
        # [10, 7]

    """
    if in_dygraph_mode():
        return _C_ops.multi_dot(x)

    check_type(x, 'x', (list, tuple), 'multi_dot')
    for id, item in enumerate(x):
        check_variable_and_dtype(item, 'x[' + str(id) + ']',
                                 ['float16', 'float32', 'float64'], 'multi_dot')
        if item.dtype != x[0].dtype:
            raise TypeError(
                "All the Tensors in the input must have the same data type.")

    helper = LayerHelper('multi_dot', **locals())
    dtype = helper.input_dtype(input_param_name='x')
    out = helper.create_variable_for_type_inference(dtype)
    helper.append_op(type='multi_dot', inputs={"X": x}, outputs={"Out": out})
    return out