You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
435 lines
14 KiB
435 lines
14 KiB
/**
|
|
* Copyright 2019-2020 Huawei Technologies Co., Ltd
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef GE_OP_LINALG_OPS_H_
|
|
#define GE_OP_LINALG_OPS_H_
|
|
|
|
#include "graph/operator_reg.h"
|
|
#include "graph/operator.h"
|
|
|
|
namespace ge {
|
|
|
|
/**
|
|
*@brief Computes the reverse mode backpropagated gradient of the Cholesky \n
|
|
algorithm.
|
|
|
|
*@par Inputs:
|
|
*The input x has to be symmetric and positive definite. Inputs include: \n
|
|
*@li x:A Tensor. Must be one of the following types: double, float32. Output \n
|
|
of batch Cholesky algorithm x = cholesky(A). Shape is [..., M, M]. Algorithm \n
|
|
depends only on lower triangular part of the innermost matrices of this tensor.
|
|
*@li grad:A Tensor. Must have the same type as l. df/dx where f is some \n
|
|
scalar function. Shape is [..., M, M]. Algorithm depends only on lower \n
|
|
triangular part of the innermost matrices of this tensor.
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow CholeskyGrad operator.
|
|
*/
|
|
|
|
REG_OP(CholeskyGrad)
|
|
.INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(grad, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OP_END_FACTORY_REG(CholeskyGrad)
|
|
|
|
/**
|
|
*@brief Computes the Cholesky decomposition of one or more square matrices.
|
|
|
|
*@par Inputs:
|
|
*The input x has to be symmetric and positive definite.Inputs include: \n
|
|
*x:A Tensor. Must be one of the following types: double, float32. Shape \n
|
|
is [..., M, M].
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow Cholesky operator.
|
|
*/
|
|
|
|
REG_OP(Cholesky)
|
|
.INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OP_END_FACTORY_REG(Cholesky)
|
|
|
|
/**
|
|
*@brief Computes the sign and the log of the absolute value of the determinant \n
|
|
of one or more square matrices.
|
|
|
|
*@par Inputs:
|
|
*The input x is a tensor of shape [N, M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. Inputs include: \n
|
|
*x:A Tensor. Must be one of the following types: double, float32. Shape is \n
|
|
[..., M, M].
|
|
|
|
*@par Outputs:
|
|
*@li y:A Tensor. Has the same type as x.
|
|
*@li sign:A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [N, M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow LogMatrixDeterminant operator.
|
|
*/
|
|
|
|
REG_OP(LogMatrixDeterminant)
|
|
.INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(sign, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OP_END_FACTORY_REG(LogMatrixDeterminant)
|
|
|
|
/**
|
|
*@brief Computes the determinant of one or more square matrices.
|
|
|
|
*@par Inputs:
|
|
*The input x is a tensor of shape [N, M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. Inputs include: \n
|
|
*x:A Tensor. Must be one of the following types: double, float32. Shape is \n
|
|
[..., M, M].
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow MatrixDeterminant operator.
|
|
*/
|
|
|
|
REG_OP(MatrixDeterminant)
|
|
.INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OP_END_FACTORY_REG(MatrixDeterminant)
|
|
|
|
/**
|
|
*@brief Computes the inverse of one or more square invertible matrices or \n
|
|
their adjoints (conjugate transposes).
|
|
|
|
*@par Inputs:
|
|
*The input x is a tensor of shape [..., M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. Inputs include: \n
|
|
*x:A Tensor. Must be one of the following types: double, float. Shape is \n
|
|
[..., M, M].
|
|
|
|
*@par Attributes:
|
|
*adjoint:An optional bool. Defaults to False.Boolean indicating whether to \n
|
|
deal with matrix or its (block-wise) adjoint.
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., M, M] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow MatrixInverse operator.
|
|
*/
|
|
|
|
REG_OP(MatrixInverse)
|
|
.INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.ATTR(adjoint, Bool, false)
|
|
.OP_END_FACTORY_REG(MatrixInverse)
|
|
|
|
/**
|
|
*@brief Solves systems of linear equations.
|
|
|
|
*@par Inputs:
|
|
*The input rhs must have the same type as matrix. Inputs include: \n
|
|
*@li matrix:A Tensor. Must be one of the following types: double, float. \n
|
|
Shape is [..., M, M].
|
|
*@li rhs:A Tensor. Must have the same type as matrix. Shape is [..., M, K].
|
|
|
|
*@par Attributes:
|
|
*adjoint:An optional bool. Defaults to False.Boolean indicating whether to \n
|
|
solve with matrix or its (block-wise) adjoint.
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as matrix.
|
|
|
|
*@attention Constraints: \n
|
|
*The input matrix is a tensor of shape [..., M, M] whose inner-most 2 \n
|
|
dimensions form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow MatrixSolve operator.
|
|
*/
|
|
|
|
REG_OP(MatrixSolve)
|
|
.INPUT(matrix, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(rhs, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.ATTR(adjoint, Bool, false)
|
|
.OP_END_FACTORY_REG(MatrixSolve)
|
|
|
|
/**
|
|
*@brief Solves systems of linear equations.
|
|
|
|
*@par Inputs:
|
|
*The input rhs must have the same type as matrix. Inputs include: \n
|
|
*@li matrix:A Tensor. Shape is [..., M, M].
|
|
*@li rhs:A Tensor. Must have the same type as matrix. Shape is [..., M, K].
|
|
*@li l2:0-D double Tensor. Ignored if fast=False.
|
|
|
|
*@par Attributes:
|
|
*fast:bool. Defaults to True.
|
|
|
|
*@par Outputs:
|
|
*y:Tensor of shape [..., N, K] whose inner-most 2 dimensions form M-by-K \n
|
|
matrices that solve the equations matrix[..., :, :] * output[..., :, :] = \n
|
|
rhs[..., :, :] in the least squares sense.
|
|
|
|
*@attention Constraints: \n
|
|
*The input matrix matrix is a tensor of shape [..., M, M] whose inner-most 2 \n
|
|
dimensions form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow MatrixSolveLs operator.
|
|
*/
|
|
|
|
REG_OP(MatrixSolveLs)
|
|
.INPUT(matrix, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(rhs, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(l2, TensorType({DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.ATTR(fast, Bool, true)
|
|
.OP_END_FACTORY_REG(MatrixSolveLs)
|
|
|
|
/**
|
|
*@brief Solves systems of linear equations with upper or lower triangular \n
|
|
matrices by backsubstitution.
|
|
|
|
*@par Inputs:
|
|
*The input rhs must have the same type as matrix. Inputs include: \n
|
|
*@li matrix: A Tensor. Must be one of the following types: double, float. \n
|
|
Shape is [..., M, M].
|
|
*@li rhs:A Tensor. Must have the same type as matrix. Shape is [..., M, K].
|
|
|
|
*@par Attributes:
|
|
*@li lower: An optional bool. Defaults to True. Boolean indicating whether \n
|
|
the innermost matrices in matrix are lower or upper triangular.
|
|
*@li An optional bool. Defaults to False. Boolean indicating whether to solve \n
|
|
with matrix or its (block-wise) adjoint.
|
|
|
|
*@par Outputs:
|
|
*y:A Tensor. Has the same type as matrix.
|
|
|
|
*@attention Constraints: \n
|
|
*The input matrix is a tensor of shape [..., M, M] whose inner-most 2 \n
|
|
dimensions form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow MatrixTriangularSolve operator.
|
|
*/
|
|
|
|
REG_OP(MatrixTriangularSolve)
|
|
.INPUT(matrix, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(rhs, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.ATTR(lower, Bool, true)
|
|
.ATTR(adjoint, Bool, false)
|
|
.OP_END_FACTORY_REG(MatrixTriangularSolve)
|
|
|
|
/**
|
|
*@brief Computes the QR decompositions of one or more matrices.
|
|
|
|
*@par Inputs:
|
|
*The input shape of x must be [..., M, N]. Inputs include: \n
|
|
*x:A Tensor whose shape is [..., M, N]. Must be one of the following types: \n
|
|
double, float.
|
|
|
|
*@par Attributes:
|
|
*full_matrices: An optional bool. Defaults to False. If true, compute \n
|
|
full-sized q and r. If false (the default), compute only the leading P \n
|
|
columns of q.
|
|
|
|
*@par Outputs:
|
|
*@li q: A Tensor. Has the same type as x.
|
|
*@li r: A Tensor. Has the same type as x.
|
|
|
|
*@attention Constraints: \n
|
|
*The input matrix x is a tensor of shape [..., M, N] whose inner-most 2 \n
|
|
dimensions form matrices of size [M, N]. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow Qr operator.
|
|
*/
|
|
|
|
REG_OP(Qr)
|
|
.INPUT(x, TensorType({ DT_FLOAT16, DT_FLOAT, DT_DOUBLE }))
|
|
.OUTPUT(q, TensorType({ DT_FLOAT16, DT_FLOAT, DT_DOUBLE }))
|
|
.OUTPUT(r, TensorType({ DT_FLOAT16, DT_FLOAT, DT_DOUBLE }))
|
|
.ATTR(full_matrices, Bool, false)
|
|
.OP_END_FACTORY_REG(Qr)
|
|
|
|
/**
|
|
*@brief Computes the eigen decomposition of a batch of self-adjoint matrices.
|
|
|
|
*@par Inputs:
|
|
*The input shape of x must be [..., N, N]. Inputs include: \n
|
|
*x:Tensor of shape [..., N, N]. Only the lower triangular part of each inner \n
|
|
inner matrix is referenced.
|
|
|
|
*@par Attributes:
|
|
*compute_v:bool. Defaults to True.
|
|
|
|
*@par Outputs:
|
|
*@li eigen_value:Eigenvalues. Shape is [..., N]. Sorted in non-decreasing order.
|
|
*@li eigen_vector:Shape is [..., N, N]. The columns of the inner most matrices \n
|
|
contain eigenvectors of the corresponding matrices in tensor
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., N, N] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow SelfAdjointEig operator.
|
|
*/
|
|
|
|
REG_OP(SelfAdjointEig)
|
|
.INPUT(x, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.OUTPUT(eigen_value, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.OUTPUT(eigen_vector, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.ATTR(compute_v, Bool, true)
|
|
.OP_END_FACTORY_REG(SelfAdjointEig)
|
|
|
|
/**
|
|
*@brief Computes the singular value decompositions of one or more matrices.
|
|
|
|
*@par Inputs:
|
|
*The input shape of x must be [..., N, N]. Inputs include: \n
|
|
*x:Tensor of shape [..., M, N]. Let P be the minimum of M and N.
|
|
|
|
*@par Attributes:
|
|
*compute_uv:If True then left and right singular vectors will be computed and \n
|
|
returned in u and v, respectively. Otherwise, only the singular values will \n
|
|
be computed, which can be significantly faster.
|
|
|
|
*@par Outputs:
|
|
*@li sigma:Singular values. Shape is [..., P]. The values are sorted in \n
|
|
reverse order of magnitude, so s[..., 0] is the largest value, s[..., 1] \n
|
|
is the second largest, etc.
|
|
*@li u:Left singular vectors. If full_matrices is False (default) then shape \n
|
|
is [..., M, P]; if full_matrices is True then shape is [..., M, M]. Not \n
|
|
returned if compute_uv is False.
|
|
*@li v:Right singular vectors. If full_matrices is False (default) then shape \n
|
|
is [..., N, P]. If full_matrices is True then shape is [..., N, N]. Not \n
|
|
returned if compute_uv is False.
|
|
|
|
*@attention Constraints: \n
|
|
*The input x is a tensor of shape [..., N, N] whose inner-most 2 dimensions \n
|
|
form square matrices. \n
|
|
|
|
*@par Third-party framework compatibility
|
|
*Compatible with tensorflow Svd operator
|
|
*/
|
|
|
|
REG_OP(Svd)
|
|
.INPUT(x, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.OUTPUT(sigma, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.OUTPUT(u, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.OUTPUT(v, TensorType({ DT_DOUBLE, DT_FLOAT }))
|
|
.ATTR(compute_uv, Bool, true)
|
|
.ATTR(full_matrices, Bool, false)
|
|
.OP_END_FACTORY_REG(Svd)
|
|
|
|
/**
|
|
*@brief Computes the LU decomposition of one or more square matrices.
|
|
|
|
*@par Inputs:
|
|
*input: A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form \n
|
|
matrices of size `[M, M]`.
|
|
|
|
*@par Outputs:
|
|
*@li lu: A tensor of shape `[..., M, M]` whose strictly lower triangular part \n
|
|
denotes the lower triangular factor `L` with unit diagonal.
|
|
*@li p: upper triangular part denotes the upper triangular factor `U`.Permutation \n
|
|
of the rows encoded as a list of indices in `0..M-1`. Shape is `[..., M]`.
|
|
|
|
*@par Third-party framework compatibility
|
|
* Compatible with TensorFlow Lu operator.
|
|
*/
|
|
|
|
REG_OP(Lu)
|
|
.INPUT(input, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(lu, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(p, TensorType({DT_INT32, DT_INT64}))
|
|
.REQUIRED_ATTR(output_idx_type, Type)
|
|
.OP_END_FACTORY_REG(Lu)
|
|
|
|
/**
|
|
*@brief Computes the matrix square root of one or more square matrices.
|
|
|
|
*@par Inputs:
|
|
*input: Shape is `[..., M, M]`.
|
|
|
|
*@par Outputs:
|
|
y: Shape is `[..., M, M]`.
|
|
|
|
*@par Third-party framework compatibility
|
|
* Compatible with TensorFlow MatrixSquareRoot operator.
|
|
*/
|
|
|
|
REG_OP(MatrixSquareRoot)
|
|
.INPUT(input, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OP_END_FACTORY_REG(MatrixSquareRoot)
|
|
|
|
/**
|
|
*@brief Solves tridiagonal systems of equations.
|
|
|
|
*@par Inputs:
|
|
*@li diagonals: Tensor of shape `[..., 3, M]` whose innermost 2 dimensions represent the \n
|
|
tridiagonal matrices with three rows being the superdiagonal, diagonals, and \n
|
|
subdiagonals, in order. The last element of the superdiagonal and the first \n
|
|
element of the subdiagonal is ignored.
|
|
*@li rhs: Tensor of shape `[..., M, K]`, representing K right-hand sides per each \n
|
|
left-hand side.
|
|
|
|
*@par Outputs:
|
|
y: Tensor of shape `[..., M, K]` containing the solutions
|
|
|
|
*@par Third-party framework compatibility
|
|
* Compatible with TensorFlow TridiagonalSolve operator.
|
|
*/
|
|
|
|
REG_OP(TridiagonalSolve)
|
|
.INPUT(diagonals, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.INPUT(rhs, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
|
|
.ATTR(partial_pivoting, Bool, true)
|
|
.OP_END_FACTORY_REG(TridiagonalSolve)
|
|
|
|
} // namespace ge
|
|
|
|
#endif // GE_OP_LINALG_OPS_H_
|