|
- /**
- * 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.
- */
-
- /*!
- * \file elewise_calculation_ops.h
- * \brief
- */
- #ifndef OPS_BUILT_IN_OP_PROTO_INC_ELEWISE_CALCULATION_OPS_H_
- #define OPS_BUILT_IN_OP_PROTO_INC_ELEWISE_CALCULATION_OPS_H_
- #include "graph/operator_reg.h"
-
- namespace ge {
- /**
- *@brief Adds all input tensors element-wise. \n
-
- *@par Inputs:
- *Dynamic inputs, including:
- * @li x: A list of Tensor objects, each with same shape and type. The supported types are:
- * float16, float32, double, int32, uint8, int16, int8, complex64, int64,
- * qint8, quint8, qint32, uint16, complex128, uint32, uint64. It's a dynamic input. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same shape and type as the elements of "x". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AddN.
- */
- REG_OP(AddN)
- .DYNAMIC_INPUT(x, TensorType::NumberType())
- .OUTPUT(y, TensorType::NumberType())
- .REQUIRED_ATTR(N, Int)
- .OP_END_FACTORY_REG(AddN)
-
- /**
- *@brief Calculates the reversed outputs of the function "maximum"
-
- *@par Inputs:
- *Three inputs, including:
- * @li grads: A mutable Tensor. Must be one of the following types:
- * float16, float32, int32.
- * @li x1: A mutable Tensor of the same type as "grads".
- * @li x2: A mutable Tensor of the same type as "grads". \n
-
- *@par Attributes:
- *@li grad_x: An optional bool. Defaults to "True".
- * If "True", "y1" will be output.
- * If "False", "y1" will not be output. \n
-
- *@li grad_y: An optional bool. Defaults to "True".
- * If "True", "y2" will be output.
- * If "False", "y2" will not be output. \n
-
- *@par Outputs:
- * @li y1: A mutable Tensor. Has the same type as "grads".
- * @li y2: A mutable Tensor. Has the same type as "grads". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator MaximumGrad.
- */
- REG_OP(MaximumGrad)
- .INPUT(grads, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OUTPUT(y1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OUTPUT(y2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .ATTR(grad_x, Bool, true)
- .ATTR(grad_y, Bool, true)
- .OP_END_FACTORY_REG(MaximumGrad)
-
- /**
- *@brief Calculates the reversed outputs of the function "minimum"
-
- *@par Inputs:
- *Three inputs, including:
- * @li grads: A mutable Tensor. Must be one of the following types:
- * float16, float32, int32.
- * @li x1: A mutable Tensor of the same type as "grads".
- * @li x2: A mutable Tensor of the same type as "grads". \n
-
- *@par Attributes:
- *@li grad_x: An optional bool. Defaults to "True".
- * If "True", "y1" will be output.
- * If "False", "y1" will not be output. \n
-
- *@li grad_y: An optional bool. Defaults to "True".
- * If "True", "y2" will be output.
- * If "False", "y2" will not be output. \n
-
- *@par Outputs:
- * @li y1: A mutable Tensor. Has the same type as "grads".
- * @li y2: A mutable Tensor. Has the same type as "grads". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator MinimumGrad.
- */
- REG_OP(MinimumGrad)
- .INPUT(grads, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OUTPUT(y1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OUTPUT(y2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .ATTR(grad_x, Bool, true)
- .ATTR(grad_y, Bool, true)
- .OP_END_FACTORY_REG(MinimumGrad)
-
- /**
- *@brief Cast a tensor form src data type to dst data type. \n
-
- *@par Inputs:
- *One input:
- *x:A Tensor. Must be one of the following types: bool, float16, float, int8, int32, uint32, uint8,
- int64, uint64, int16, uint16, double, complex64, complex128, qint8, quint8, qint16, quint16, qint32. \n
-
- *@par Attributes:
- *dst_type: An required attribute of type int32, specifying the dst data type. \n
-
- *@par Outputs:
- *y:A Tensor. Has the same type as x.
- */
- REG_OP(Cast)
- .INPUT(x, TensorType({DT_BOOL, DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT32, DT_UINT8,
- DT_INT64, DT_UINT64, DT_INT16, DT_UINT16, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128, DT_QINT8, DT_QUINT8, DT_QINT16, DT_QUINT16, DT_QINT32}))
- .OUTPUT(y, TensorType({DT_BOOL, DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT32, DT_UINT8,
- DT_INT64, DT_UINT64, DT_INT16, DT_UINT16, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128, DT_QINT8, DT_QUINT8, DT_QINT16, DT_QUINT16, DT_QINT32}))
- .REQUIRED_ATTR(dst_type, Int)
- .OP_END_FACTORY_REG(Cast)
-
- /**
- *@brief Returns the truth value of (x1 >= x2) element-wise. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * double, int32, int8, uint8, int64, uint16, uint32, uint64.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the TensorFlow operator GreaterEqual.
- */
- REG_OP(GreaterEqual)
- .INPUT(x1, TensorType::RealNumberType())
- .INPUT(x2, TensorType::RealNumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(GreaterEqual)
-
- /**
- *@brief Returns the truth value of (x1 < x2) element-wise. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32, double, int32,
- * uint8, int16, int8, int64, uint16, uint32, uint64.
- * @li x2: A Tensor with the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of type bool. \n
-
- *@par Third-party framework compatibility:
- * Compatible with TensorFlow operator Less.
- */
- REG_OP(Less)
- .INPUT(x1, TensorType::RealNumberType())
- .INPUT(x2, TensorType::RealNumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(Less)
-
- /**
- *@brief Returns x1/x2 element-wise for real types. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types: float16, float32, double, uint16,
- int8, uint8, int16, int32, int64, complex64, DT_COMPLEX128.
- *@li x2: A Tensor. Must be one of the following types: float16, float32, double, uint16,
- int8, uint8, int16, int32, int64, complex64, DT_COMPLEX128. \n
-
- *@par Outputs:
- * y: A Tensor. Has the same type and format as input "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator RealDiv.
- */
- REG_OP(RealDiv)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(RealDiv)
-
- /**
- *@brief Computes square root of x element-wise. \n
-
- *@par Inputs:
- * x: A Tensor. Must be one of the following types: float16, float32, complex128, complex64, float64. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x".
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Sqrt.
- */
- REG_OP(Sqrt)
- .INPUT(x, TensorType{(DT_FLOAT. DT_FLOAT16, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128)})
- .OUTPUT(y, TensorType{(DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128)})
- .OP_END_FACTORY_REG(Sqrt)
-
- /**
- *@brief Returns the max of "x" and "y" (i.e. x > y ? x: y) element-wise. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32, double, int32, int64.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Maximum.
- */
- REG_OP(Maximum)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .OP_END_FACTORY_REG(Maximum)
-
- /**
- *@brief Returns the min of x and y (i.e. x1 < x2 ? x1 : x2) element-wise. \n
-
- *@par Inputs:
- *Two inputs, include:
- * @li x1: A Tensor. Must be one of the following types: float32, float16, double, int32, int64.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the TensorFlow operator Minimum.
- */
- REG_OP(Minimum)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_INT32,
- DT_INT64}))
- .OP_END_FACTORY_REG(Minimum)
-
- /**
- *@brief: Computes the reciprocal of "x". \n
-
- *@par Inputs:
- *One inputs, include:
- *x:A Tensor of type float16, float32, int32, int64, double,
- * complex64, complex128.the format can be [NCHW,NC1HWC0,NHWC,ND,NCHW,NC1HWC0,NHWC,ND]
-
- *@par Outputs:
- *y:A Tensor with same type as "x". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Reciprocal.
- */
- REG_OP(Reciprocal)
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64, DT_FLOAT16,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64, DT_FLOAT16
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Reciprocal)
-
- /**
- *@brief Returns x - y element-wise.
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: int8, int16, int32, int64, uint8, float64,
- * float16, float32, complex128, complex64, uint16.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x".
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Subtract.
- */
- REG_OP(Sub)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_UINT8, DT_INT8,
- DT_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Sub)
-
- /**
- *@brief computes the absolute value of a tensor. \n
-
- *@par Inputs:
- *One inputs, including:
- * @li x: A Tensor. Must be one of the following types: float16, float32, double, int32, int64. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Abs.
- */
- REG_OP(Abs)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64}))
- .OP_END_FACTORY_REG(Abs)
-
- /**
- *@brief Computes gradients for absolute operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor of type float16 or float32.
- *@li dy: A tensor of the same type as "y".
- *
- *@attention Constraints:
- * "dy" has the same type as "y".
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AbsGrad.
- *
- */
- REG_OP(AbsGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(AbsGrad)
-
- /**
- *@brief: Computes the sign of "x". \n
-
- *@par Inputs:
- *x:An ND Tensor of type float16, float32, int32, int64, double,
- * complex64, complex128. \n
-
- *@par Outputs:
- *y:An ND Tensor with same type as "x". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Sign.
- */
- REG_OP(Sign)
- .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Sign)
-
- /**
- *@brief Returns (x1 - x2)(x1 - x2) element-wise. \n
-
- *@par Inputs:
- *Two inputs, including: \n
- *@li x1: A Tensor. Must be one of the following types: float16, float32, float64, int32, int64, complex64,complex128
- *@li x2: A Tensor. Has the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator SquaredDifference.
- */
- REG_OP(SquaredDifference)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
- DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(SquaredDifference)
-
- /**
- *@brief Computes cosine of "x" element-wise. \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32, double, complex64, complex128.
- * the format can be [NCHW,NC1HWC0,NHWC,ND]
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Cos. \n
-
- */
- REG_OP(Cos)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Cos)
-
- /**
- *@brief Returns x1/x2 element-wise. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types:
- * float16, float32, int32, int8, uint8, float64, int64, uint16, int16,
- * complex64, complex128, the format can be [NCHW,NC1HWC0,NHWC,ND].
- *@li x2: A Tensor. Has the same type and format as input "x1". \n
-
- *@par Outputs:
- * y: A Tensor. Has the same type and format as input "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Div.
- */
- REG_OP(Div)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_INT64, DT_UINT16, DT_INT16,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_INT64, DT_UINT16, DT_INT16,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_INT64, DT_UINT16, DT_INT16,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Div)
-
- /**
- *@brief: Returns the truth value of (x = y) element-wise. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types:
- * float16, float32, int32, int8, uint8, double, int16, int64, complex64,
- * complex128, quint8, qint8, qint32, string, bool. the format can be
- * [NCHW, NC1HWC0, NHWC, ND]
- *@li x2: A Tensor of the same type and format as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of type bool. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Equal.
- */
- REG_OP(Equal)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT8, DT_UINT8,
- DT_DOUBLE, DT_INT16, DT_INT64, DT_COMPLEX64,
- DT_COMPLEX128, DT_QUINT8, DT_QINT8, DT_QINT32,
- DT_STRING, DT_BOOL}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT8, DT_UINT8,
- DT_DOUBLE, DT_INT16, DT_INT64, DT_COMPLEX64,
- DT_COMPLEX128, DT_QUINT8, DT_QINT8, DT_QINT32,
- DT_STRING, DT_BOOL}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(Equal)
-
- /**
- *@brief Computes the exponential of "x" element-wise. \n
-
- *@par Inputs:
- *One input:\n
- *x: A Tensor. Must be one of the following types: float16, float32, double, complex64, complex128. \n
-
- *@par Attributes:
- *@li base: An optional attribute of type float32, specifying the base gamma. Defaults to "-1.0".
- *@li scale: An optional attribute of type float32, specifying the scale alpha. Defaults to "1.0".
- *@li shift: An optional attribute of type float32, specifying the shift beta. Defaults to "0.0". \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Exp.
- */
- REG_OP(Exp)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .ATTR(base, Float, -1.0)
- .ATTR(scale, Float, 1.0)
- .ATTR(shift, Float, 0.0)
- .OP_END_FACTORY_REG(Exp)
-
- /**
- *@brief Computes the exp(x) - 1 element-wise, y = e^x - 1. \n
-
- *@par Inputs:
- *One input:
- *x: A Tensor. Must be one of the following types: float16, float32, double, complex64, complex128. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Expm1.
- */
- REG_OP(Expm1)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Expm1)
-
- /**
- *@brief: Computes the reciprocal of "x". \n
-
- *@par Inputs:\n
- *x: A Tensor. Must be one of the following types: float16, float32, int32, int64, double, complex64, complex128. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Inv.
- */
- REG_OP(Inv)
- .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT,DT_DOUBLE,DT_INT32,DT_INT64,DT_COMPLEX64,DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT,DT_INT32}))
- .OP_END_FACTORY_REG(Inv)
-
- /**
- *@brief: Computes "x" reciprocal grad, dx = -1*dy*y*y, where, "y = 1/x", and "dy"
- is the corresponding input gradient. \n
-
- *@par Inputs:
- * Two inputs, including:
- * @li x: A Tensor. Must be one of the following types: float16, float32, int32, int8.
- * @li grad: A Tensor. Has the same type as "x". \n
-
- *@par Outputs:
- *y: A Tensor, Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator InvGrad.
- */
- REG_OP(InvGrad)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT8}))
- .INPUT(grad, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT8}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT8}))
- .OP_END_FACTORY_REG(InvGrad)
-
- /**
- *@brief: Returns the truth value of (x <= y) element-wise. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types: float32, float64,
- * int32, uint8, int16, int8, int64, qint8, quint8, qint32, uint16,
- * float16, uint32, uint64.
- *@li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of type bool. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator LessEqual.
- */
- REG_OP(LessEqual)
- .INPUT(x1, TensorType::RealNumberType())
- .INPUT(x2, TensorType::RealNumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(LessEqual)
-
- /**
- *@brief Computes the logarithm of (x + 1) element-wise, y = ln(x + 1). \n
-
- *@par Inputs:
- *One input:\n
- *x: A Tensor. Must be one of the following types: float16, float32, double, complex64, complex128. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Log1p.
- */
- REG_OP(Log1p)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Log1p)
-
- /**
- *@brief Returns element-wise remainder of division.
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * int32, int64, int8, uint8, double.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1".
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Mod.
- */
- REG_OP(Mod)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT8, DT_UINT8,
- DT_INT64, DT_DOUBLE}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT8, DT_UINT8,
- DT_INT64, DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT8, DT_UINT8,
- DT_INT64, DT_DOUBLE}))
- .OP_END_FACTORY_REG(Mod)
-
- /**
- *@brief: Returns the truth value of (x != y) element-wise. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types: float16, float32, int32,
- * int8, uint8, double, int16, int64, uint16, half, uint32, uint64
- *@li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of type bool. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator NotEqual.
- */
- REG_OP(NotEqual)
- .INPUT(x1, TensorType::RealNumberType())
- .INPUT(x2, TensorType::RealNumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(NotEqual)
-
- /**
- *@brief Computes numerical negative value element-wise (y = -x)
-
- *@par Inputs:
- * One input:
- *x: A Tensor. Must be one of the following types: float16, float32, int32,
- * int64, complex64, complex128. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type and format as input "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Neg.
- */
- REG_OP(Neg)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Neg)
-
- /**
- *@brief Returns x1/x2 element-wise for integer types. \n
-
- *@par Inputs:
- *@li x1: A Tensor. Must be one of the following types:
- * float32, float64, int32, uint8, int16, int8,
- * complex64, int64, qint8, quint8, qint32, uint16,
- * complex128, float16, uint32, uint64, complex64, complex128.
- *@li x2: A Tensor of the same data type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1".
-
- *@attention Constraints:
- * Broadcasting is supported. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator TruncateDiv. \n
-
- */
- REG_OP(TruncateDiv)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_UINT16, DT_INT16, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_UINT16, DT_INT16, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_UINT8, DT_INT32,
- DT_DOUBLE, DT_UINT16, DT_INT16, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(TruncateDiv)
-
- /**
- *@brief Computes x1/x2 element-wise, if x1 == 0, return 0.
-
- *@par Inputs:
- * Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * double, complex64, complex128.
- * @li x2: A Tensor. Has the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Xdivy.
- */
- REG_OP(Xdivy)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Xdivy)
-
- /**
- *@brief Computes "x" multiplied by the logarithm of y element-wise,
- * if "x" == 0, return "0". \n
-
- *@par Inputs:
- * Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * double, complex64, complex128.
- * @li x2: A Tensor. Has the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Xlogy.
- */
- REG_OP(Xlogy)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Xlogy)
-
- /**
- *@brief Computes square of "x" element-wise. \n
-
- *@par Inputs:
- *One input: \n
- *x: A Tensor. Must be one of the following types: float16, float32, float64, int32, int64, complex64, complex128
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Square.
- */
- REG_OP(Square)
- .INPUT(x, TensorType({DT_DOUBLE, DT_FLOAT16, DT_FLOAT,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_DOUBLE, DT_FLOAT16, DT_FLOAT,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Square)
-
-
- /**
- *@brief Computes reciprocal of square root of "x" element-wise: y = 1/sqrt{x}. \n
-
- *
- *@par Inputs:
- * x: An ND or 5HD tensor. Must be one of the following types: float, double, half,
- * complex64, complex128.
- *
- *@par Outputs:
- * y: An ND or 5HD tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Rsqrt.
- *
- */
- REG_OP(Rsqrt)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Rsqrt)
-
- /**
- *@brief Computes the trignometric inverse sine of "x" element-wise. \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, int32, int64, complex64, complex128.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Asin.
- *
- */
- REG_OP(Asin)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Asin)
-
- /**
- *@brief Computes gradients for Asin operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor of type float16, float32, float64, int32, int64, complex64, complex128.
- *@li dy: A tensor of the same type as "y".
- *
- *@attention Constraints:
- * "dy" has the same type as "y".
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AsinGrad.
- *
- */
- REG_OP(AsinGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(AsinGrad)
-
- /**
- *@brief Computes acos of x element-wise. \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, int32, int64, complex64, complex128.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Acos.
- *
- */
- REG_OP(Acos)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE,
- DT_INT32, DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Acos)
-
- /**
- *@brief Computes gradients for Acos operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor of type float16 or float32.
- *@li dy: A tensor of the same type as "y".
- *
- *@attention Constraints:
- * "dy" has the same shape as "y".
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AcosGrad.
- *
- */
- REG_OP(AcosGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(AcosGrad)
-
- /**
- *@brief Computes inverse hyperbolic cosine of x element-wise. \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, complex64, complex128.
- *
- *@attention Constraints:
- * x Given an input tensor, the function computes inverse hyperbolic cosine of every element.\n
- * Input range is [1, inf].
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Acosh.
- *
- */
- REG_OP(Acosh)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Acosh)
-
- /**
- *@brief Computes gradients for Acosh operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor of type float16 or float32.
- *@li dy: A tensor of the same type as "y".
- *
- *@attention Constraints:
- * "dy" has the same type as "y".
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AcoshGrad.
- *
- */
- REG_OP(AcoshGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(AcoshGrad)
-
- /**
- *@brief Returns the truth value of x1 OR x2 element-wise. \n
-
- *
- *@par Inputs:
- *@li x1: A tensor of type bool.
- *@li x2: A tensor of the same type as "x1".
- *
- *@attention Constraints:
- * LogicalOr supports broadcasting.
- *
- *@par Outputs:
- * y: A tensor of the same type as "x1".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator LogicalOr.
- *
- */
- REG_OP(LogicalOr)
- .INPUT(x1, TensorType({DT_BOOL}))
- .INPUT(x2, TensorType({DT_BOOL}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(LogicalOr)
-
- /**
- *@brief Returns the truth value of x1 AND x2 element-wise. \n
-
- *
- *@par Inputs:
- *@li x1: A tensor of type bool.
- *@li x2: A tensor of the same type as "x1".
- *
- *@attention Constraints:
- * LogicalAnd supports broadcasting.
- *
- *@par Outputs:
- * y: A tensor of the same type as "x1".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator LogicalAnd.
- *
- */
- REG_OP(LogicalAnd)
- .INPUT(x1, TensorType({DT_BOOL}))
- .INPUT(x2, TensorType({DT_BOOL}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(LogicalAnd)
-
- /**
- *@brief Computes the Bessel i0e function of "x" element-wise.
- * Exponentially scaled modified Bessel function of order 0
- * defined as: bessel_i0e(x) = exp(-abs(x)) bessel_i0(x).
- * This function is faster and numerically stabler than "bessel_i0(x)".
- *
- *@par Inputs:
- * x: A tensor of type float16, float32, or float64.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator BesselI0e.
- *
- */
- REG_OP(BesselI0e)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(BesselI0e)
-
- /**
- *@brief Computes the Bessel i1e function of "x" element-wise.
- * Exponentially scaled modified Bessel function of order 0
- * defined as: bessel_i1e(x) = exp(-abs(x)) bessel_i1(x).
- * This function is faster and numerically stabler than "bessel_i1(x)".
- *
- *@par Inputs:
- * x: A tensor of type float16, float32, or float64.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator BesselI1e.
- *
- */
- REG_OP(BesselI1e)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(BesselI1e)
-
- /**
- * @brief Computes logarithm of x element-wise.
- * y = log_base(shift + scale * x), with "base" > 0. \n
-
- * @par Inputs:
- * @li x: A Tensor of type complex64, complex128, float16, float32 or double. \n
-
- * @par Attributes:
- * @li base: An optional float32, specifying the base "e". Defaults to "-1.0"
-
- * @li scale: An optional float32, specifying the scale of input "x". Defaults
- * to "1.0"
- * @li shift: An optional float32, specifying the shift. Defaults to "0.0"
-
- * @par Outputs:
- * y: A Tensor has same type as "x". \n
-
- * @attention Constraints:
- * @li "base" is supposed to be greater than 0. Retaining the default
- * value "-1" sets "base" to "e".
- * @li If the input value of operator Log is within the range (0, 0.01] or
- * [0.95, 1.05], the output accuracy is subject to change. \n
-
- * @par Third-party framework compatibility
- * @li Compatible with the TensorFlow operator Log.
- * @li Compatible with the Caffe operator Log.
- */
- REG_OP(Log)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .ATTR(base, Float, -1.0)
- .ATTR(scale, Float, 1.0)
- .ATTR(shift, Float, 0.0)
- .OP_END_FACTORY_REG(Log)
-
- /**
- * @brief Returns x1 * x2 element-wise.
- * y = x1 * x2
-
- * @par Inputs:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
- * @li x2: A Tensor. Must be one of the following types: float16, float32,
- * float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128. \n
-
- * @par Outputs:
- * y: A Tensor. Must be one of the following types: float16, float32, float64,
- * uint8, int8, uint16, int16, int32, int64, complex64, complex128. \n
-
- * @attention Constraints:
- * @li "x1" and "x2" have incompatible shapes or types. \n
-
- * @par Third-party framework compatibility
- * Compatible with the TensorFlow operator Multiply.
- */
- REG_OP(Mul)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_UINT8, DT_INT8,
- DI_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_UINT8, DT_INT8,
- DI_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_UINT8, DT_INT8,
- DI_UINT16, DT_INT16, DT_INT32, DT_INT64,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Mul)
-
- /**
- * @brief Computes the gradient of the square root of "x" with regard to its
- * input. grad = dy * 0.5/y, where y = sqrt(x), and "dy" is the corresponding
- * input gradient. \n
-
- * @par Inputs:
- * Two inputs, including:
- * @li y: A Tensor of type float32 or float16.
- * @li dy: A Tensor. Has the same type as "y". \n
-
- * @par Outputs:
- * z: A Tensor. Has the same type as "y". \n
-
- * @attention Constraints:
- * "dy" has the same shape and type as "y".
- */
- REG_OP(SqrtGrad)
- .INPUT(y, TensorType(UnaryDataType))
- .INPUT(dy, TensorType(UnaryDataType))
- .OUTPUT(z, TensorType(UnaryDataType))
- .OP_END_FACTORY_REG(SqrtGrad)
-
- /**
- *@brief Returns x + y element-wise.
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: int8, int16, int32, int64, uint8, float64,
- * float16, float32, complex128, complex64, string.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x".
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Add.
- */
- REG_OP(Add)
- .INPUT(x1, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,
- DT_COMPLEX64, DT_STRING}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,
- DT_COMPLEX64, DT_STRING}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX128,
- DT_COMPLEX64, DT_STRING}))
- .OP_END_FACTORY_REG(Add)
-
- /**
- *@brief Confuse broadcast, add and mul. \n
-
- *@par Inputs:
- *Five inputs, including:
- * @li x1: A Tensor. Must be one of the following types:int32 float16, float32.
- * @li x2: A Tensor of the same type as "x1".
- * @li x3: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *@li y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the TensorFlow operator LRN.
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
-
- REG_OP(FusedMulAdd)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .INPUT(x3, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32}))
- .OP_END_FACTORY_REG(FusedMulAdd)
-
- /**
- *@brief Returns x1 + x2 element-wise. \n
-
- *
- *@par Inputs:
- *@li x1: A tensor. Must be one of the following types: float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128.
- *@li x2: A tensor of the same type as "x1".
- *
- *@attention Constraints:
- * AddV2 supports broadcasting.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x1".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AddV2.
- *
- */
- REG_OP(AddV2)
- .INPUT(x1, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_INT32, DT_INT64, DT_FLOAT16, DT_INT16,
- DT_INT8, DT_UINT8, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128}))
- .OP_END_FACTORY_REG(AddV2)
-
- /**
- *@brief Updates "ref" by adding "value" to it. \n
-
- *@par Inputs:
- *@li ref: A Tensor. Must be one of the following types: float16, float32, int8, int16, int32, int64, uint8, uint16, uint32, uint64.
- *@li value: A Tensor of the same type as "ref". \n
-
- *@par Attributes:
- *use_locking: An optional bool. Defaults to "False".
- If "True", the addition will be protected by a lock;
- otherwise the behavior is undefined, but may exhibit less contention.
- * This attribute is reserved. \n
-
- *@par Outputs:
- *ref: A Tensor that holds the new value of ref after the value has been added. \n
-
- *@attention Constraints:
- *An input tensor of type int64 must have a shape with size 1. \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AssignAdd.
- */
- REG_OP(AssignAdd)
- .INPUT(ref, TensorType::BasicType())
- .INPUT(value,TensorType::BasicType())
- .OUTPUT(ref, TensorType::BasicType())
- .ATTR(use_locking, Bool, false)
- .OP_END_FACTORY_REG(AssignAdd)
-
- /**
- *@brief Updates "ref" by assigning "value" to it. \n
-
- *@par Inputs:
- *@li ref: A Tensor. Must be one of the following types: float16, float32, int8, int16, int32, int64, uint8, uint16, uint32, uint64.
- *@li value: A Tensor of the same type as "ref". \n
-
- *@par Attributes:
- *@li validate_shape: An optional bool. Defaults to "true".
- If "true", the operation will validate that the shape of "value" matches the shape of the Tensor being assigned to.
- * If "false", "ref" will take on the shape of "value".
- * This attribute is reserved.
- *@li use_locking: An optional bool. Defaults to True.
- If True, the assignment will be protected by a lock;
- otherwise the behavior is undefined, but may exhibit less contention.
- * This attribute is reserved. \n
-
- *@par Outputs:
- *ref: A Tensor that holds the new value of ref after the value has been assigned. \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Assign.
- */
- REG_OP(Assign)
- .INPUT(ref, TensorType::BasicType())
- .INPUT(value,TensorType::BasicType())
- .OUTPUT(ref, TensorType::BasicType())
- .ATTR(validate_shape, Bool, true)
- .ATTR(use_locking, Bool, false)
- .OP_END_FACTORY_REG(Assign)
-
- /**
- *@brief Updates "var" by subtracting "value" from it.\n
- * This operation outputs "var" after the update is done. \n
- * This makes it easier to chain operations that need to use the reset value. \n
-
- *
- *@par Inputs:
- *@li var: A tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, uint16, complex128, uint32, uint64
- *@li value: A tensor of the same type as "var".
- *
- *@par Attributes:
- * use_locking: An optional bool. Defaults to "False". If "True", the subtraction will be protected \n
- * by a lock; otherwise the behavior is undefined, but may exhibit less contention.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "var".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AssignSub.
- *
- */
- REG_OP(AssignSub)
- .INPUT(var, TensorType::NumberType())
- .INPUT(value,TensorType::NumberType())
- .OUTPUT(var, TensorType::NumberType())
- .ATTR(use_locking, Bool, false)
- .OP_END_FACTORY_REG(AssignSub)
-
- /**
- *@brief: Computes the backpropagation of the square root operation. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li y: An NCHW, NC1HWC0, NHWC, ND Tensor. Must be one of the following types: \
- * float, int32, int8, double, complex64, complex128, half.
- *@li dy: A Tensor of the same type and format as "y". \n
-
- *@par Outputs:
- *z: A Tensor of the same type and format as "y". \n
-
- *@see Matmul() | Rsqrt ()
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator RsqrtGrad.
- */
- REG_OP(RsqrtGrad)
- .INPUT(y, TensorType({UnaryDataType,int32,int8}))
- .INPUT(dy, TensorType({UnaryDataType,int32,int8}))
- .OUTPUT(z, TensorType({UnaryDataType,int32,int8}))
- .OP_END_FACTORY_REG(RsqrtGrad)
-
- /**
- *@brief Computes hyperbolic sine of "x" element-wise. \n
-
- *@par Inputs:
- *x: An NCHW, NC1HWC0, NHWC,or ND Tensor of type float, double, complex64,
- * complex128, half. \n
-
- *@par Outputs:
- *y: A NCHW, NC1HWC0, NHWC,or ND Tensor of type float, double, complex64,
- * complex128, half. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Sinh. \n
-
- */
- REG_OP(Sinh)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Sinh)
-
- /**
- *@brief: Clips tensor values to a specified min and max. \n
-
- *@par Inputs:
- * Three inputs, including:
- *@li x: A Tensor of type float32, float64, int32, uint8, int16, int8, complex64, int64,
- *qint8, quint8, qint32, uint16, complex128, float16, uint32, uint64.
- *@li clip_value_min: A Tensor of the same type as "x".
- *@li clip_value_max: A Tensor of the same type as "x". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator ClipByValue.
- */
- REG_OP(ClipByValue)
- .INPUT(x, TensorType::NumberType())
- .INPUT(clip_value_min, TensorType::NumberType())
- .INPUT(clip_value_max, TensorType::NumberType())
- .OUTPUT(y, TensorType::NumberType())
- .OP_END_FACTORY_REG(ClipByValue)
-
- /**
- *@brief Computes cosine of "x" element-wise. \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32, double, complex64, complex128.
- * the format can be [NCHW,NC1HWC0,NHWC,ND]. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Cosh. \n
-
- */
- REG_OP(Cosh)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Cosh)
-
- /**
- *@brief: Returns 0 if the denominator is zero, else, like Div. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types:float16, float32, int32,
- * int8, uint8, double, the format can be [NCHW,NC1HWC0,NHWC,ND].
- *@li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator DivNoNan.
- */
- REG_OP(DivNoNan)
- .INPUT(x1, TensorType({DT_FLOAT, DT_UINT8, DT_INT8, DT_INT32, DT_FLOAT16,
- DT_DOUBLE}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_UINT8, DT_INT8, DT_INT32, DT_FLOAT16,
- DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_UINT8, DT_INT8, DT_INT32, DT_FLOAT16,
- DT_DOUBLE}))
- .OP_END_FACTORY_REG(DivNoNan)
-
- /**
- *@brief Reverses specific dimensions of a tensor. \n
-
- *@par Inputs:
- * One input: \n
- *x: A Tensor, Must be one of the following types:
- * int32, uint8, int16, int8, int64, int64, uint16, uint32, uint64,
- * and format can be [NCHW,NC1HWC0,NHWC,ND]
-
- *@par Outputs:
- *y: A Tensor. Has the same type and format as "x"
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Invert.
- */
- REG_OP(Invert)
- .INPUT(x, TensorType::IntegerDataType())
- .OUTPUT(y, TensorType::IntegerDataType())
- .OP_END_FACTORY_REG(Invert)
-
- /**
- *@brief Returns a tensor of the same shape and type with all elements set to one.
- *@par Inputs:
- *One input: \n
- *x: A Tensor. Must be one of the following types: float16, float32, int8, uint8,
- * int16, uint16, int32, int64, complex128, bool. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator OnesLike.
- */
- REG_OP(OnesLike)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT8,
- DT_UINT8, DT_INT16, DI_UINT16, DT_INT32,
- DT_INT64, DT_COMPLEX128, DT_BOOL}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT8,
- DT_UINT8, DT_INT16, DI_UINT16, DT_INT32,
- DT_INT64, DT_COMPLEX128, DT_BOOL}))
- .OP_END_FACTORY_REG(OnesLike)
-
- /**
- *@brief Computes the gradient for the inverse of "x" with regard its input. \n
-
- *@par Inputs:
- *@li input_y: A Tensor. Must be one of the following types: float, double,
- * complex64, complex128, half.
- *@li input_dy: A Tensor. Must be one of the following types: float, double,
- * complex64, complex128, half. \n
-
- *@par Outputs:
- *output_data: A Tensor. Must be one of the following types: float, double,
- * complex64, complex128, half. \n
-
- *@attention Constraints:
- * "input_dy" has the same shape and type as "input_y". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator reciprocal_grad.
- */
- REG_OP(ReciprocalGrad)
- .INPUT(y, TensorType::UnaryDataType())
- .INPUT(dy, TensorType::UnaryDataType())
- .OUTPUT(z, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(ReciprocalGrad)
-
- /**
- *@brief Returns the truth value of (x1 > x2) element-wise. \n
-
- *@par Inputs:
- *@li x1: A Tensor of type float16, float32, double, int64, int32, int16, int8,
- * uint8, uint16, uint32, uint64.
- *@li x2: A Tensor of the same data type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor of type bool.
-
- *@attention Constraints:
- * Broadcasting is supported. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Greater. \n
-
- */
- REG_OP(Greater)
- .INPUT(x1, TensorType::RealNumberType())
- .INPUT(x2, TensorType::RealNumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(Greater)
-
- /**
- *@brief Returns a tensor of the same type and shape as the input tensor with all elements set to zero. \n
-
- *@par Inputs:
- *x: A Tensor. Must be one of the following types:
- * float32, float64, int32, uint8, int16, int8,
- * complex64, int64, qint8, quint8, qint32, qint16, quint16, uint16,
- * complex128, float16, uint32, uint64, complex64, complex128. \n
-
- *@par Outputs:
- *y: A Tensor of the same data type as "x". \n
-
- *@attention Constraints:
- * The output has the same shape and type as the input. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator zeros_like.
- */
- REG_OP(ZerosLike)
- .INPUT(x, TensorType::BasicType())
- .OUTPUT(y, TensorType::BasicType())
- .OP_END_FACTORY_REG(ZerosLike)
-
- /**
- *@brief Returns the truth value of NOT "x" element-wise. \n
-
- *@par Inputs:
- *x: A Tensor of type bool. \n
-
- *@par Outputs:
- *y: A Tensor of type bool. \n
-
- *@attention Constraints:
- * The input and output values are "1" or "0", corresponding to bool values "true" and "false". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator logical_not.
- */
- REG_OP(LogicalNot)
- .INPUT(x, TensorType({DT_BOOL}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(LogicalNot)
-
- /**
- *@brief Computes inverse hyperbolic sine of x element-wise.
- * Given an input tensor, this function computes inverse hyperbolic sine for every element in the tensor. \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, complex64, complex128.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Asinh.
- *
- */
- REG_OP(Asinh)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Asinh)
-
- /**
- *@brief Computes gradients for Asinh operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor. Must be one of the following types: float16, float32.
- *@li dy: A tensor of the same type as "y"
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AsinhGrad.
- *
- */
- REG_OP(AsinhGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(AsinhGrad)
-
- /**
- *@brief Computes inverse hyperbolic tangent of x element-wise.\n
- * Given an input tensor, this function computes inverse hyperbolic tangent for every element in the tensor. \n Input range is [-1,1] and output range is [-inf, inf]. If input is -1, \n output will be -inf and if the input is 1, output will be inf.\n Values outside the range will have nan as output. \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, complex64, complex128.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Atanh.
- *
- */
- REG_OP(Atanh)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Atanh)
-
- /**
- *@brief Computes the trignometric inverse tangent of x element-wise.
- * The atan operation returns the inverse of tan, such that if y = tan(x) then, x = atan(y). \n
-
- *
- *@par Inputs:
- * x: A tensor. Must be one of the following types: float16, float32, float64, complex64, complex128.
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x". The output of atan will lie within the invertible range of tan, i.e (-pi/2, pi/2).
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Atan.
- *
- */
- REG_OP(Atan)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Atan)
-
- /**
- *@brief Computes gradients for Atan operation. \n
-
- *
- *@par Inputs:
- *@li y: A tensor of type float16 or float32.
- *@li dy: A tensor of the same type as "y"
- *
- *@par Outputs:
- * z: A tensor. Has the same type as "y".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AtanGrad.
- *
- */
- REG_OP(AtanGrad)
- .INPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(dy, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(AtanGrad)
-
- /**
- *@brief Computes arctangent of x1/x2 element-wise, respecting signs of the arguments. \n
-
- *
- *@par Inputs:
- *@li x1: A tensor. Must be one of the following types: float16, float32, float64
- *@li x2: A tensor of the same type as "x1".
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x1".
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Atan2.
- *
- */
- REG_OP(Atan2)
- .INPUT(x1, TensorType::FloatingDataType())
- .INPUT(x2, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(Atan2)
-
- /**
- *@brief Returns the truth value of abs(x1-x2) < tolerance element-wise. \n
-
- *
- *@par Inputs:
- *@li x1: A tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, uint16, complex128, float16, uint32, uint64
- *@li x2: A tensor of the same type as "x1".
- *
- *@par Attributes:
- * tolerance: Defaults to "1e-05".
- *
- *@par Outputs:
- * y: A tensor of type bool.
- *
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator ApproximateEqual.
- *
- */
- REG_OP(ApproximateEqual)
- .INPUT(x1, TensorType::NumberType())
- .INPUT(x2, TensorType::NumberType())
- .OUTPUT(y, TensorType({DT_BOOL}))
- .ATTR(tolerance, Float, 1e-5)
- .OP_END_FACTORY_REG(ApproximateEqual)
-
- /**
- *@brief Returns the element-wise sum of a list of tensors.\n
- * AccumulateNV2 performs the same operation as AddN, but does not wait for all of its inputs
- to be ready before beginning to sum.\n This can save memory if inputs are ready at different times,
- since minimum temporary storage is proportional to the output size rather than the inputs size.
- Returns a Tensor of same shape and type as the elements of inputs. \n
-
- *
- *@par Inputs:
- *Dynamic inputs, including:
- * x: A tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64,
- qint8, quint8, qint32, uint16, complex128, float16, uint32, uint64. It's a dynamic input. \n
- *
- *@par Outputs:
- * y: A tensor. Has the same type as "x".
- *
- *@par Attributes:
- * N: the size of x.
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator AccumulateNV2.
- *
- */
- REG_OP(AccumulateNV2)
- .DYNAMIC_INPUT(x, TensorType::NumberType())
- .OUTPUT(y, TensorType::NumberType())
- .REQUIRED_ATTR(N, Int)
- .OP_END_FACTORY_REG(AccumulateNV2)
-
- /**
- *@brief Fake-quantizes the input Tensor, type float to output a Tensor of same type.
- * [min, max] define the clamping range for the "inputs" data.\n
- * the values of "x" are quantized into the quantization range ([0, 2^num_bits - 1] \n
- * when "narrow_range" is "false" or [1, 2^num_bits - 1] when it is "true") and \n
- * then de-quantized and output as float32 in [min; max] interval.\n
- * num_bits is the bit width of the quantization, between 2 and 16, inclusive. \n
- * Quantization is called fake since the output is still in floating point. \n
-
- *@par Inputs:
- *One input:
- *x: A Tensor of type float32. \n
-
- *@par Attributes:
- *@li min: An optional attribute. Defaults to "-6.0".
- *@li max: An optional attribute. Defaults to "6.0".
- *@li num_bits: An optional attribute. Defaults to "8".
- *@li narrow_range: An optional bool. Defaults to "false". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same shape and type of "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator FakeQuantWithMinMaxArgs.
- */
- REG_OP(FakeQuantWithMinMaxArgs)
- .INPUT(x, TensorType({DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .ATTR(min, Float, -6.0)
- .ATTR(max, Float, 6.0)
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxArgs)
-
- /**
- *@brief Computes gradients for a FakeQuantWithMinMaxArgs operation. \n
-
- *@par Inputs:
- *Two inputs, including: \n
- *@li gradients: A Tensor of type float32. Backpropagated gradients above the FakeQuantWithMinMaxArgs operation.
- *@li x: A Tensor of type float32. Has the same type and format as "gradients".\n
- * This is the input Tensor of the FakeQuantWithMinMaxArgs operator.\n
-
- *@par Attributes:
- *@li min: An optional attribute. Defaults to "-6.0".
- *@li max: An optional attribute. Defaults to "6.0".
- *@li num_bits: An optional attribute. Defaults to "8".
- *@li narrow_range: An optional bool. Defaults to "False". \n
-
- *@par Outputs:
- *y: A Tensor of type float32. \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator FakeQuantWithMinMaxArgsGradient.
- */
- REG_OP(FakeQuantWithMinMaxArgsGradient)
- .INPUT(gradients, TensorType({DT_FLOAT}))
- .INPUT(x, TensorType({DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .ATTR(min, Float, -6.0)
- .ATTR(max, Float, 6.0)
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxArgsGradient)
-
- /**
- *@brief Fake-quantize the 'inputs' tensor of type float via global float scalars. \n
-
- *@par Inputs:
- *Three inputs, including:
- *@li x: A Tensor of type float32.
- *@li min: A Tensor of type float32. Has the same type and format as "x".
- *@li max: A Tensor of type float32. Has the same type and format as "x".\n
- *[min; max] define the clamping range for the inputs data
-
- *@par Attributes:
- *@li num_bits: An optional attribute. Defaults to "8".
- *@li narrow_range: An optional bool. Defaults to "False". \n
-
- *@par Outputs:
- *y: A Tensor of type float32. \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator FakeQuantWithMinMaxVars.
- */
- REG_OP(FakeQuantWithMinMaxVars)
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(min, TensorType({DT_FLOAT}))
- .INPUT(max, TensorType({DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxVars)
-
- /**
- *@brief Computes gradients for a FakeQuantWithMinMaxVars operation. \n
-
- *@par Inputs:
- *Four inputs, including:
- *@li gradients: A Tensor of type float32.
- *@li x: A Tensor of type float32.
- *@li min: A Tensor of type float32.
- *@li max: A Tensor of type float32. \n
-
- *@par Attributes:
- *@li num_bits: An integer specifying the quantization bit width. Defaults to "8".
- *@li narrow_range: A Boolean specifying whether to use a narrow range for quantization. Defaults to "False". \n
-
- *@par Outputs:
- *@li backprops_wrt_x: A Tensor. Has the same type as input "x".
- *@li backprops_wrt_min: A Tensor. Has the same type as input "min".
- *@li backprops_wrt_max: A Tensor. Has the same type as input "max". \n
-
- *@attention Constraints:
- *@li "gradients" has the same shape as "x".
- *@li "min" and "max" are scalars.
- *@li "num_bits" is between 2 and 16
-
- *@see Region()
-
- *@par Third-party framework compatibility
- * Compatible with the operator FakeQuantWithMinMaxVarsGradient.
- */
- REG_OP(FakeQuantWithMinMaxVarsGradient)
- .INPUT(gradients, TensorType({DT_FLOAT}))
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(min, TensorType({DT_FLOAT}))
- .INPUT(max, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_x, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_min, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_max, TensorType({DT_FLOAT}))
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxVarsGradient)
-
- /**
- *@brief Fake-quantizes the "inputs" tensor of type float
- via per-channel floats min and max of shape [d] to "outputs" \n
- tensor of same shape as inputs
-
- *@par Inputs:
- *Three inputs, including:
- *@li x: A Tensor of type float32.
- *@li min: A Tensor of type float32.
- *@li max: A Tensor of type float32. \n
-
- *@par Attributes:
- *@li num_bits: An integer specifying the quantization bit width. Defaults to "8".
- *@li narrow_range: A Boolean specifying whether to use a narrow range for quantization. Defaults to "False". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as input "x".
-
-
- *@attention Constraints:
- *@li "min" and "max" have one-dimensional shapes.
- *@li "min" has the same last dimension size as "x". "max" has the same last dimension size as "x".
- *@li "num_bits" is between 2 and 16
-
- *@see Region()
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator FakeQuantWithMinMaxVarsPerChannel.
- */
- REG_OP(FakeQuantWithMinMaxVarsPerChannel)
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(min, TensorType({DT_FLOAT}))
- .INPUT(max, TensorType({DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxVarsPerChannel)
-
- /**
- *@brief Computes gradients for a FakeQuantWithMinMaxVarsPerChannel operation. \n
-
- *@par Inputs:
- *Four inputs, including:
- *@li gradients: A Tensor of type float32.
- *@li x: A Tensor of type float32.
- *@li min: A Tensor of type float32.
- *@li max: A Tensor of type float32. \n
-
- *@par Attributes:
- *@li num_bits: An integer specifying the quantization bit width. Defaults to "8".
- *@li narrow_range: A Boolean specifying whether to use a narrow range for quantization. Defaults to "False". \n
-
- *@par Outputs:
- *@li backprops_wrt_x: A Tensor. Has the same type as input "x".
- *@li backprops_wrt_min: A Tensor. Has the same type as input "min".
- *@li backprops_wrt_max: A Tensor. Has the same type as input "max". \n
-
- *@attention Constraints:
- *@li "gradients" has the same shape as "x".
- *@li "min" and "max" have one-dimensional shapes.
- *@li "min" has the same last dimension size as "x". "max" has the same last dimension size as "x". "gradients" has the same last dimension size as "x".
- *@li "num_bits" is between 2 and 16
-
- *@see Region()
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator FakeQuantWithMinMaxVarsPerChannelGradient.
- */
- REG_OP(FakeQuantWithMinMaxVarsPerChannelGradient)
- .INPUT(gradients, TensorType({DT_FLOAT}))
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(min, TensorType({DT_FLOAT}))
- .INPUT(max, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_x, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_min, TensorType({DT_FLOAT}))
- .OUTPUT(backprops_wrt_max, TensorType({DT_FLOAT}))
- .ATTR(num_bits, Int, 8)
- .ATTR(narrow_range, Bool, false)
- .OP_END_FACTORY_REG(FakeQuantWithMinMaxVarsPerChannelGradient)
-
- /**
- *@brief Element-wise computes the bitwise AND of "x1" and "x2". \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: int8, int16,
- * int32, int64, uint8, uint16, uint32, uint64. Broadcasting is supported.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator BitwiseAnd.
- */
- REG_OP(BitwiseAnd)
- .INPUT(x1, TensorType::IntegerDataType())
- .INPUT(x2, TensorType::IntegerDataType())
- .OUTPUT(y, TensorType::IntegerDataType())
- .OP_END_FACTORY_REG(BitwiseAnd)
-
- /**
- *@brief Element-wise computes the bitwise OR of "x1" and "x2". \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: int8, int16,
- * int32, int64, uint8, uint16, uint32, uint64. Broadcasting is supported.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator BitwiseOr.
- */
- REG_OP(BitwiseOr)
- .INPUT(x1, TensorType::IntegerDataType())
- .INPUT(x2, TensorType::IntegerDataType())
- .OUTPUT(y, TensorType::IntegerDataType())
- .OP_END_FACTORY_REG(BitwiseOr)
-
- /**
- *@brief Elementwise computes the bitwise XOR of "x1" and "x2". \n
-
- *@par Inputs:
- *Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types: int8, int16, int32, int64, uint8, uint16, uint32, uint64.
- * The format is NC1HWC0 or ND. Broadcasting is supported.
- *@li x2: A Tensor. Has the same type and format as "x1". \n
-
- *@par Outputs:
- *y: Output result. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator BitwiseXor.
- */
- REG_OP(BitwiseXor)
- .INPUT(x1, TensorType::IntegerDataType())
- .INPUT(x2, TensorType::IntegerDataType())
- .OUTPUT(y, TensorType::IntegerDataType())
- .OP_END_FACTORY_REG(BitwiseXor)
-
- /**
- *@brief Returns element-wise smallest integer not less than "x". \n
-
- *@par Inputs:
- * x: A Tensor of type float16 or float32 or float64. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x".
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Ceil.
- */
- REG_OP(Ceil)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(Ceil)
-
- /**
- *@brief Returns element-wise largest integer not greater than "x". \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32 or double. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Third-party framework compatibility:
- * Compatible with TensorFlow operator Floor.
- */
- REG_OP(Floor)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(Floor)
-
- /**
- *@brief Divides "x1/x2" element-wise, rounding toward the
- * most negative integer. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32, int32, int64, int8,
- * uint8, int16, uint16, double, complex64, complex128.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator FloorDiv.
- */
- REG_OP(FloorDiv)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT8,
- DT_INT64, DT_INT16, DT_UINT16, DT_DOUBLE,
- DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT8,
- DT_INT64, DT_INT16,DT_UINT16, DT_DOUBLE,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT8,
- DT_INT64, DT_INT16,DT_UINT16, DT_DOUBLE,
- DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(FloorDiv)
-
- /**
- *@brief Returns element-wise remainder of division. Consistent with: floor(x1/x2) * x2 + mod(x1, x2) = x1. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x1: A Tensor. Must be one of the following types:
- * int32, int64, float, float16, double
- *@li x2: A Tensor. Must have the same type as "x1".
- *
- *@par Outputs:
- *y: Result remainder.
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator FloorMod.
- */
- REG_OP(FloorMod)
- .INPUT(x1, TensorType({DT_INT32, DT_INT64, DT_FLOAT, DT_FLOAT16,
- DT_DOUBLE}))
- .INPUT(x2, TensorType({DT_INT32, DT_INT64, DT_FLOAT, DT_FLOAT16,
- DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_INT32, DT_INT64, DT_FLOAT, DT_FLOAT16,
- DT_DOUBLE}))
- .OP_END_FACTORY_REG(FloorMod)
-
- /**
- *@brief Computes the power of "x1" to "x2". \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types:
- * float16, float32, int32, int64, int8, uint8, double, complex64, complex128.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator Pow.
- */
- REG_OP(Pow)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64, DT_INT8,
- DT_UINT8, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64, DT_INT8,
- DT_UINT8, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64, DT_INT8,
- DT_UINT8, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Pow)
-
- /**
- *@brief Return element-wise integer closest to x. \n
-
- *@par Inputs:
- *One input, include:
- *x: A mutable Tensor. Must be one of the following types:
- * float16, float32, double. \n
-
- *@par Outputs:
- *y: A mutable Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Rint.
- */
- REG_OP(Rint)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(Rint)
-
- /**
- *@brief Rounds the values of a tensor to the nearest integer, element-wise.
- * Rounds half to even. \n
-
- *@par Inputs:
- *Inputs including:
- *x: A required ND Tensor of type float16, float, int64, double, complex64,
- * complex128 or int32.
- *@par Outputs:
- *y: A required ND Tensor. Has the same data type and shape as "x".
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Round.
- */
- REG_OP(Round)
- .INPUT(x, TensorType(DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64,
- DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128))
- .OUTPUT(y, TensorType(DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64,
- DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128))
- .OP_END_FACTORY_REG(Round)
-
- /**
- *@brief: Computes sine of "x" element-wise. \n
-
- *@par Inputs:
- *One input:
- *x: An ND Tensor. Must be one of the following types: float16, float32, double,
- * complex64, complex128, int32, int64
-
- *@par Outputs:
- *y: An ND Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Sin.
- */
- REG_OP(Sin)
- .INPUT(x, TensorType::UnaryDataType())
- .OUTPUT(y, TensorType::UnaryDataType())
- .OP_END_FACTORY_REG(Sin)
-
- /**
- *@brief: Computes tan of "x" element-wise. \n
-
- *@par Inputs:
- *One input:
- *x: A Tensor. Must be one of the following types: float16, float32, double, complex64, complex128, int32, int64
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator Tan.
- */
- REG_OP(Tan)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128, DT_INT32, DT_INT64}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_COMPLEX64,
- DT_COMPLEX128, DT_INT32, DT_INT64}))
- .OP_END_FACTORY_REG(Tan)
-
- /**
- *@brief Returns element-wise remainder of division. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32,
- * double, int32, int64.
- * @li x2: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x1". \n
-
- *@par Third-party framework compatibility
- *@li Compatible with the TensorFlow operator TruncateMod.
- */
- REG_OP(TruncateMod)
- .INPUT(x1, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT64,
- DT_INT32}))
- .INPUT(x2, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT64,
- DT_INT32}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT64,
- DT_INT32}))
- .OP_END_FACTORY_REG(TruncateMod)
-
- /**
- *@brief Adds 'bias' to 'x'. \n
-
- *@par Inputs:
- *Two inputs, including:
- * @li x: A Tensor of type NumberType. Must be one of the following types: float32, float64, int32, uint8, int16,
- *int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, float16, uint32, uint64.
- * @li bias: A 1D Tensor with size the C dimension of value. \n
-
- *@par Attributes:
- *data_format: An optional string. Defaults to "NHWC". \n
-
- *@par Outputs:
- *y: A Tensor with same type as "x". \n
-
- *@par Third-party framework compatibility
- *Compatible with the TensorFlow operator BiasAdd.
- */
- REG_OP(BiasAdd)
- .INPUT(x, TensorType::NumberType())
- .INPUT(bias, TensorType::NumberType())
- .OUTPUT(y, TensorType::NumberType())
- .ATTR(data_format, String, "NHWC")
- .OP_END_FACTORY_REG(BiasAdd)
-
- /**
- *@brief Returns the index with the smallest value across dimensions of a tensor. \n
-
- *@par Inputs:
- *Two inputs, including:
- *@li x: A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, float16, uint32, uint64.
- *format is ND.
- *@li dimension: A Tensor. Must be one of the following types: int32, int64. Must be in the range [-rank(input x), rank(input x)]. Describes which dimension of the input Tensor to reduce across.
- * The format is ND.
- *@par Attributes:
- *dtype: The output type, either "int32" or "int64". Defaults to "int64". \n
-
- *@par Outputs:
- *y: A Tensor of type "dtype". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator ArgMin.
- */
- REG_OP(ArgMin)
- .INPUT(x, TensorType::NumberType())
- .INPUT(dimension, TensorType::IndexNumberType())
- .OUTPUT(y, TensorType({DT_INT32, DT_INT64}))
- .ATTR(dtype, Type, DT_INT64)
- .OP_END_FACTORY_REG(ArgMin)
-
- /**
- *@brief Returns the index with the smallest value across dimensions of a tensor. \n
-
- *@par Inputs:
- *One input:
-
- *x: A Tensor of type float16 or float32 in ND format. \n
-
- *@par Attributes:
- *@li dimension: The dimension of the input Tensor to reduce across.
- *@li dtype: An optional attribute, specifying the output data type. Must be "int32". Defaults to "int64". \n
-
- *@par Outputs:
- *y: A Tensor of type dtype. \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator ArgMin.
- *
- * @par Restrictions:
- * Warning: THIS FUNCTION IS DEPRECATED. Please use ArgMin instead.
- */
- REG_OP(ArgMinD)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_INT32}))
- .REQUIRED_ATTR(dimension, Int)
- .ATTR(dtype, Type, DT_INT64)
- .OP_END_FACTORY_REG(ArgMinD)
-
- /**
- *@brief Returns the index with the largest value across axes of a tensor. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x: A multi-dimensional Tensor of type float16, float32, or int16.
- *@li dimension: A Scalar of type int32, specifying the index with the largest value. \n
-
- *@par Attributes:
- *dtype: The output type, either "int32" or "int64". Defaults to "int64". \n
-
- *@par Outputs:
- *y: A multi-dimensional Tensor of type int32 or int64, specifying the index with the largest value. The dimension is one less than that of "x". \n
-
- *@attention Constraints:
- *@li x: If there are multiple maximum values, the index of the first maximum value is used.
- *@li The value range of "dimension" is [-dims, dims - 1]. "dims" is the dimension length of "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator ArgMax.
- */
- REG_OP(ArgMaxV2)
- .INPUT(x, TensorType::NumberType())
- .INPUT(dimension, TensorType::IndexNumberType())
- .OUTPUT(y, TensorType({DT_INT32, DT_INT64}))
- .ATTR(dtype, Type, DT_INT64)
- .OP_END_FACTORY_REG(ArgMaxV2)
-
- /**
- *@brief Returns the index with the largest value across axes of a tensor. \n
-
- *@par Inputs:
- * One input, including:
- *x: A multi-dimensional Tensor of type float16, float32. \n
-
- *@par Attributes:
- *@li dimension: An integer of type int32, specifying the axis information of the index with the maximum value.
- *@li dtype: The output type, either "int32" or "int64". Defaults to "int64". \n
-
- *@par Outputs:
- *y: A multi-dimensional Tensor of type int32, specifying the index with the largest value. The dimension is one less than that of "x". \n
-
- *@attention Constraints:
- *@li x: If there are multiple maximum values, the index of the first maximum value is used.
- *@li The value range of "dimension" is [-dims, dims - 1]. "dims" is the dimension length of "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator ArgMax.
- *
- * @par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(ArgMaxD)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_INT32}))
- .REQUIRED_ATTR(dimension, Int)
- .ATTR(dtype, Type, DT_INT64)
- .OP_END_FACTORY_REG(ArgMaxD)
-
- /**
- *@brief Returns the maximum value of all elements in the input in the given
- * dimension. \n
-
- *@par Inputs:
- *One input: \n
- *x: A multi-dimensional Tensor of type float16 or float32. \n
-
- *@par Attributes:
- *@li dimension: An integer of type int32, specifying the axis information of
- * the index with the maximum value.
- *@li keep_dims: A bool, specifying whether to keep dimensions for the output
- * Tensor. Defaults to "false". \n
-
- *@par Outputs:
- *@li indice: A multi-dimensional Tensor of type int32, specifying the index.
- * (If "keep_dims" is set to "false", the output dimensions are reduced by
- * "dimension" compared with that of "x". Otherwise, the output has one fewer
- * dimension than "x".)
- *@li values: A Tensor, specifying the maximum value. Has the same dimensions
- * as "indice" and the same type as "x". \n
-
- *@attention Constraints:
- *@li If there are multiple maximum values, the index of the first maximum
- * value is used.
- *@li The value range of "dimension" is [-dims, dims - 1]. "dims" is the
- * dimension length of "x". \n
-
- *@par Third-party framework compatibility
- * Compatible with the two output scenarios of PyTorch operator Max (the output
- * sequence is opposite to that of PyTorch).
- */
- REG_OP(ArgMaxWithValue)
- .INPUT(x, TensorType({DT_FLOAT,DT_FLOAT16}))
- .OUTPUT(indice,TensorType({DT_INT32}))
- .OUTPUT(values, TensorType({DT_FLOAT,DT_FLOAT16}))
- .REQUIRED_ATTR(dimension, Int)
- .ATTR(keep_dims, Bool, false)
- .OP_END_FACTORY_REG(ArgMaxWithValue)
-
- /**
- *@par Inputs:
- *One input: \n
- *x: A multi-dimensional Tensor of type float16 or float32. \n
-
- *@par Attributes:
- *@li dimension: An integer of type int32, specifying the axis information of
- * the index with the maximum value.
- *@li keep_dims: A bool, specifying whether to keep dimensions for the output
- * Tensor. Defaults to "false". \n
-
- *@par Outputs:
- *@li indice: A multi-dimensional Tensor of type int32, specifying the index.
- * (If "keep_dims" is set to "false", the output dimensions are reduced by
- * "dimension" compared with that of "x". Otherwise, the output has one fewer
- * dimension than "x".)
- *@li values: A Tensor, specifying the minimum value. Has the same dimensions
- * as "indice" and the same type as "x". \n
-
- *@attention Constraints:
- *@li If there are multiple minimum values, the index of the first minimum
- * value is used.
- *@li The value range of "dimension" is [-dims, dims - 1]. "dims" is the
- * dimension length of "x".
- *@li Performing the ArgMinWithValue operation on the last axis of float32 data
- * is not supported on a mini platform. \n
-
- *@par Third-party framework compatibility
- * Compatible with the two output scenarios of PyTorch operator Min (the output
- * sequence is opposite to that of PyTorch).
- */
- REG_OP(ArgMinWithValue)
- .INPUT(x, TensorType({DT_FLOAT,DT_FLOAT16}))
- .OUTPUT(indice,TensorType({DT_INT32}))
- .OUTPUT(values, TensorType({DT_FLOAT,DT_FLOAT16}))
- .REQUIRED_ATTR(dimension, Int)
- .ATTR(keep_dims, Bool, false)
- .OP_END_FACTORY_REG(ArgMinWithValue)
-
- /**
- *@brief Compute elementwise modes, such as 0: PRODUCT, 1: SUM, 2: MAX
-
- *@par Inputs:
- *One input: \n
- *x: the list of input data, the type of element in Tensor should be same.
- * the max size of x is 32.
- * should met one of the following types: float16, float32. It's a dynamic input. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type and format as "x". \n
-
- *@par Attributes:
- *@li N: A required attribute. the number of input x, max size is 32. Type is int.
- *@li model: An optional attribute. Type is int. Defaults to "1".
- * "0": product, "1": sum, "2": max.
- *@li coeff: A required attribute. Must met all of following rules:
- * size of "coeff" must be equal to len("x") or is null.
- * the absolute value of "coeff" must less than or equal to 1.
- */
- REG_OP(Eltwise)
- .DYNAMIC_INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .REQUIRED_ATTR(N, Int)
- .ATTR(mode, Int, 1)
- .ATTR(coeff, ListFloat, {})
- .OP_END_FACTORY_REG(Eltwise)
-
- /**
- *@brief Computes element-wise population count. \n
-
- *@par Inputs:
- *x: A Tensor of type TensorType::IntegerDataType(). \n
-
- *@par Outputs:
- *y: A Tensor of type uint8. \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator PopulationCount.
- */
- REG_OP(PopulationCount)
- .INPUT(x, TensorType::IntegerDataType())
- .OUTPUT(y, TensorType({DT_UINT8}))
- .OP_END_FACTORY_REG(PopulationCount)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Thirteen inputs, including:
- * @li input_mul3: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul2: A Tensor. Must be one of the following types: float16, float32.
- * @li input_realdiv1: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul1: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul0: A Tensor. Must be one of the following types: float16, float32.
- * @li input_realdiv0: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_sub: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_sub1: A Tensor. Must be one of the following types: float16, float32.
- * @li mul4_x: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Four outputs, including:
- * @li y1: A Tensor. Must be one of the following types: float16, float32.
- * @li y2: A Tensor. Must be one of the following types: float16, float32.
- * @li y3: A Tensor. Must be one of the following types: float16, float32.
- * @li y4: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambNextMVWithDecay)
- .INPUT(input_mul3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_realdiv1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_realdiv0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_sub, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_sub1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul4_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambNextMVWithDecay)
-
- /**
- *@brief Confuse real_div, rsqrt, sqrt, maximum, minimum, sub and add. \n
-
- *@par Inputs:
- *Thirteen inputs, including:
- * @li input_mul3: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul2: A Tensor of the same type as "input1".
- * @li input_realdiv1: A Tensor of the same type as "input1".
- * @li input_mul1: A Tensor of the same type as "input1".
- * @li input_mul0: A Tensor of the same type as "input1".
- * @li input_realdiv0: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul4: A Tensor of the same type as "input1".
- * @li mul0_x: A Tensor of the same type as "input1".
- * @li mul1_sub: A Tensor of the same type as "input1".
- * @li mul2_x: A Tensor of the same type as "input1".
- * @li mul3_sub1: A Tensor. Must be one of the following types: float16, float32.
- * @li mul4_x: A Tensor of the same type as "input1".
- * @li add2_y: A Tensor of the same type as "input1". \n
-
- *@par Outputs:
- *Four outputs, including:
- *@li y1: A Tensor. Has the same type as "input_mul3".
- *@li y2: A Tensor. Has the same type as "input_mul3".
- *@li y3: A Tensor. Has the same type as "input_mul3".
- *@li y4: A Tensor. Has the same type as "input_mul3".
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambNextMV)
- .INPUT(input_mul3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_realdiv1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_realdiv0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_sub, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_sub1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul4_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambNextMV)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Six inputs, including:
- * @li input_square: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul2: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li truediv1_recip: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Two outputs, including:
- * @li y1: A Tensor of the same type as "input_square".
- * @li y2: A Tensor of the same type as "input_square". \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambNextRight)
- .INPUT(input_square, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(truediv1_recip, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambNextRight)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Six inputs, including:
- * @li input_greater1: A Tensor. Must be one of the following types: float16, float32.
- * @li input_greater_realdiv: A Tensor. Must be one of the following types: float16, float32.
- * @li input_realdiv: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul0: A Tensor. Must be one of the following types: float16, float32.
- * @li input_mul1: A Tensor. Must be one of the following types: float16, float32.
- * @li input_sub: A Tensor. Must be one of the following types: float16, float32.
- * @li greater_y: A Tensor. Must be one of the following types: float16, float32.
- * @li select_e: A Tensor. Must be one of the following types: float16, float32.
- * @li minimum_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "input_greater1". \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambUpdateWithLr)
- .INPUT(input_greater1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_greater_realdiv, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_realdiv, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_mul1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input_sub, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(greater_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(select_e, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(minimum_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambUpdateWithLr)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Seven inputs, including:
- * @li x1: A Tensor. Must be one of the following types: float16, float32.
- * @li x2: A Tensor. Must be one of the following types: float16, float32.
- * @li x3: A Tensor. Must be one of the following types: float16, float32.
- * @li x4: A Tensor. Must be one of the following types: float16, float32.
- * @li x5: A Tensor. Must be one of the following types: float16, float32.
- * @li greater_y: A Tensor. Must be one of the following types: float16, float32.
- * @li select_e: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as input. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambUpdateWithLrV2)
- .INPUT(x1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(x2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(x3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(x4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(x5, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(greater_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(select_e, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambUpdateWithLrV2)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Eleven inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul4_x: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Three outputs, including:
- * @li output0: A Tensor. Must be one of the following types: float16, float32.
- * @li output1: A Tensor. Must be one of the following types: float16, float32.
- * @li output2: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(AdamApplyOneWithDecay)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul4_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(AdamApplyOneWithDecay)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Ten inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Three outputs, including:
- * @li output0: A Tensor. Must be one of the following types: float16, float32.
- * @li output1: A Tensor. Must be one of the following types: float16, float32.
- * @li output2: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(AdamApplyOne)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(AdamApplyOne)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Eleven inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul4_x: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Three outputs, including:
- * @li output0: A Tensor. Must be one of the following types: float16, float32.
- * @li output1: A Tensor. Must be one of the following types: float16, float32.
- * @li output2: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(AdamApplyOneWithDecayAssign)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul4_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(AdamApplyOneWithDecayAssign)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Ten inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Three outputs, including:
- * @li output0: A Tensor. Must be one of the following types: float16, float32.
- * @li output1: A Tensor. Must be one of the following types: float16, float32.
- * @li output2: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(AdamApplyOneAssign)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(AdamApplyOneAssign)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Ten inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li steps: A Tensor. Must be one of the following types: float16, float32.
- * @li do_use_weight: A Tensor. Must be one of the following types: float16, float32.
- * @li weight_decay_rate: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *Three outputs, including:
- * @li output0: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambApplyOptimizerAssign)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul0_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul1_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul2_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(mul3_x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(add2_y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(steps, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(do_use_weight, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(weight_decay_rate, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambApplyOptimizerAssign)
-
- /**
- *@brief A fusion operator for bert lamb. \n
-
- *@par Inputs:
- *Ten inputs, including:
- * @li input0: A Tensor. Must be one of the following types: float16, float32.
- * @li input1: A Tensor. Must be one of the following types: float16, float32.
- * @li input2: A Tensor. Must be one of the following types: float16, float32.
- * @li input3: A Tensor. Must be one of the following types: float16, float32.
- * @li input4: A Tensor. Must be one of the following types: float16, float32.
- * @li mul0_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul1_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul2_x: A Tensor. Must be one of the following types: float16, float32.
- * @li mul3_x: A Tensor. Must be one of the following types: float16, float32.
- * @li steps: A Tensor. Must be one of the following types: float16, float32.
- * @li do_use_weight: A Tensor. Must be one of the following types: float16, float32.
- * @li weight_decay_rate: A Tensor. Must be one of the following types: float16, float32.
- * @li add2_y: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *No outputs
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(LambApplyWeightAssign)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input3, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input4, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(LambApplyWeightAssign)
-
- /**
- *@brief Confuse select, maximum, greater and sqrt. \n
-
- *@par Inputs:
- *Four inputs, including:
- * @li x: A Tensor. Must be one of the following types: float16, float32.
- * @li greater_zeros: A Tensor. Must be one of the following types: float16, float32.
- * @li select_ones: A Tensor. Must be one of the following types: float16, float32.
- * @li maximum_ones: A Tensor. Must be one of the following types: float16, float32. \n
-
- *@par Outputs:
- *y: A Tensor of the same type as "x". \n
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(ClipByNormNoDivSum)
- .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(greater_zeros, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(select_ones, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(maximum_ones, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OP_END_FACTORY_REG(ClipByNormNoDivSum)
-
- /**
- *@brief Confuse reducesumd and square. \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32. \n
-
- *@par Attributes:
- * Two attributes, including: \n
- *@li axis: A optional listint, specifies the dimensions to reduce.
- *@li keep_dims: A bool, specifying whether to keep dimensions for the output Tensor. Defaults to "false". \n
-
- *@par Outputs:
- *Two outputs, including: \n
- *@li y1: A Tensor. Has the same type as "x".
- *@li y2: A Tensor. Has the same type as "x".
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(SquareSumV2)
- .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .REQUIRED_ATTR(axis, ListInt)
- .ATTR(keep_dims, Bool, false)
- .OP_END_FACTORY_REG(SquareSumV2)
-
- /**
- *@brief Confuse reducesumd and square. \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32. \n
-
- *@par Attributes:
- * Two attributes, including: \n
- *@li axis: A optional listint, specifies the dimensions to reduce.
- *@li keep_dims: A bool, specifying whether to keep dimensions for the output Tensor. Defaults to "false". \n
-
- *@par Outputs:
- y: A Tensor. Has the same type as "x".
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(SquareSumV1)
- .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))
- .REQUIRED_ATTR(axis, ListInt)
- .ATTR(keep_dims, Bool, false)
- .OP_END_FACTORY_REG(SquareSumV1)
-
- /**
- *@brief Calculate square of Tensor and then reducesum
-
- *@par Inputs:
- *x1: A Tensor of type float32.
- *x2: A Tensor of type float32. \n
-
- *@par Outputs:
- y1: A Tensor. Has the same type as "x1".The result of "x1".
- y2: A Tensor. Has the same type as "x2".The result of "x2".
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(SquareSumAll)
- .INPUT(x1, TensorType({DT_FLOAT}))
- .INPUT(x2, TensorType({DT_FLOAT}))
- .OUTPUT(y1, TensorType({DT_FLOAT}))
- .OUTPUT(y2, TensorType({DT_FLOAT}))
- .OP_END_FACTORY_REG(SquareSumAll)
-
- /**
- *@brief Confuse broadcast, addn and mul. \n
-
- *@par Inputs:
- *Three inputs, including:
- * @li x1: A Tensor. Must be one of the following types:int32, int16, float16, float32.
- * @li x2: A Tensor of the same type as "x1".
- * @li x3: A Tensor of the same type as "x1". \n
-
- *@par Outputs:
- * y: A Tensor. Has the same type as "x1".
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(FusedMulAddN)
- .INPUT(x1, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT16}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT16}))
- .INPUT(x3, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT16}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT32, DT_INT16}))
- .OP_END_FACTORY_REG(FusedMulAddN)
-
- /**
- *@brief Add 'bias' to 'x'. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x: An ND tensor of type float16 or float32.
- *@li bias: An ND tensor of type float16 or float32. \n
-
- *@par Attributes:
- *@li axis: An optional int32 used to compute the shape of bias input from the online bottoms. Defaults to "1".
- *@li num_axes: An optional int32 used to compute the shape of bias input from a Caffe model trained offline. Defaults to "1".
- *@li bias_from_blob: An optional bool. If "true", bias is input from a Caffe model trained offline. If "false", bias is input from online bottoms. Defaults to "true". \n
-
- *@par Outputs:
- *y: An ND tensor of type float16 or float32. \n
-
- *@attention Constraints:\n
- * Assume that the shape length of "x" is "n" and that of "bias" is "m".
- *@li "axis" is within the range [-n, n-1]. num_axes >= -1.
- *@li If "bias_from_blob = true", "num_axes = -1", and "axis >= 0", the ith axis of "bias" and the (i+"axis")th axis of "x" must have the same size (0 <= i < n-axis).\n
- * If "axis < 0", the ith axis of "bias" and the (i+n+"axis")th axis of "x" must have the same size (0 <= i < -axis).
- *@li If "bias_from_blob = true" and "num_axes = 0", "bias" is a scalar with shape length 1 and dimension size 1.
- *@li If "bias_from_blob = true", "num_axes > 0, and "axis >= 0", "axis + num_axes" must be less than or equal to "n" and the ith axis of "bias" and the (i+"axis")th axis of "x" must have the same size (0 <= i < num_axes).\n
- * If "axis < 0", "n + axis + num_axes" must be less than or equal to "n" and the ith axis of "bias" and the (i+n+"axis")th axis of "x" must have the same size (0 <= i < num_axes).
- *@li If "bias_from_blob = false", "bias" is not a scalar, and "axis >= 0","axis + m" must be less than or equal to "n" and the ith axis of "bias" and the (i+"axis")th axis of "x" must have the same size (0 <= i < m).\n
- * If "axis < 0", "n + axis + m" must be less than or equal to "n" and the ith axis of "bias" and the (i+n+"axis")th axis of "x" must have the same size (0 <= i < m).
- *@par Third-party framework compatibility
- * Compatible with the Caffe operator Bias.
- */
-
- REG_OP(Bias)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16})) /* "First operand." */
- .INPUT(bias, TensorType({DT_FLOAT, DT_FLOAT16})) /* "Second operand." */
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16})) /* "Result, has same element type as x" */
- .ATTR(axis, Int, 1)
- .ATTR(num_axes, Int, 1)
- .ATTR(bias_from_blob, Bool, true)
- .OP_END_FACTORY_REG(Bias)
-
- /**
- *@brief Function multiply gradients calculation.
- output0 is the result of which input0 dot multily input1.
- output1 is the result of which input0 dot multily input1, then reducesum it. \n
-
- *@par Inputs:
- *@li input0: A Tensor of input of mul, and dtype supports float16, float32.
- *@li input1: A Tensor of input of mul and mul_1, and dtype supports float16, float32.
- *@li input2: A Tensor of input of mul_1, and dtype supports float16, float32. \n
-
- *@par Attributes:
- *@li axes: The dimensions to reduce. Default:(), reduce all dimensions. \n
- Only constant value is allowed.
- *@li keep_dims: If true, keep these reduced dimensions and the length is 1. \n
- If false, don’t keep these dimensions. Default:False. \n
-
- *@par Outputs:
- *@li output0: A Tensor result of which input0 dot multily input1.
- *@li output1: A Tensor result of which input0 dot multily input1, then reducesum it.
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(ConfusionMulGrad)
- .INPUT(input0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .INPUT(input2, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output0, TensorType({DT_FLOAT16,DT_FLOAT}))
- .OUTPUT(output1, TensorType({DT_FLOAT16,DT_FLOAT}))
- .ATTR(axes, ListInt, {})
- .ATTR(keep_dims, Bool, false)
- .OP_END_FACTORY_REG(ConfusionMulGrad)
-
- /**
- *@brief Function fused multiply l2 loss calculation. \n
-
- *@par Inputs:
- *@li x1: A Tensor of type float16, float32.
- *@li x2: A Tensor of type float16, float32.
- *@li x3: A Tensor of type float16, float32. \n
-
- *@par Outputs:
- *@li y1: A Tensor of shape and dtype of first output, which should have \n
- shape (1,) and dtype as input.
- *@li y2: A Tensor of shape and dtype of second output, should be same shape and type as input.
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(FusedMulAddNL2loss)
- .INPUT(x1, TensorType::NumberType())
- .INPUT(x2, TensorType::NumberType())
- .INPUT(x3, TensorType::NumberType())
- .OUTPUT(y1, TensorType::NumberType())
- .OUTPUT(y2, TensorType::NumberType())
- .OP_END_FACTORY_REG(FusedMulAddNL2loss)
-
- /**
- *@brief Tests whether the input exceeds a threshold. \n
-
- *@par Inputs:
- *@li x: A Tensor with any format. Must be one of the following types: float16, float32. \n
-
- *@par Attributes:
- *@li threshold: A required float32. Defaults to "0.0". "x" is compared with "threshold", outputs "1" for inputs above threshold; "0" otherwise. \n
-
- *@par Outputs:
- *@li y: A Tensor with any format. Has the same type as the input. Must be one of the following types: float16, float32.
- *@par Third-party framework compatibility
- * Compatible with the Caffe operator Threshold.
- */
-
- REG_OP(Threshold)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16}))
- .ATTR(threshold, Float, 0.0)
- .OP_END_FACTORY_REG(Threshold);
-
- /**
- *@brief Returns the index number corresponding to the maximum value entered. \n
-
- *@par Inputs:
- *@li x: A tensor. Must be one of the following types: float16, float32. \n
-
- *@par Attributes:
- *@li axis: An optional int. Specify the axis to be cut at the input tensor. If this parameter is not provided, find the topk for each batch. Defaults to 10000
- *@li out_max_val: An optional bool. Whether to output the maximum value. If it is True, the maximum value and index are output, otherwise only the index is output.
- * Defaults to False
- *@li topk: An optional int. It means the number of top tok in each axis (the value is greater than or equal to 1), and the value range must be in [1,x.shape(axis)].
- * Defaults to 1
-
- *@par Outputs:
- *@li indices: A tensor of type float16, float32, int32. The index of the maximum value of the output.
- *@li values: A tensor of type float16, float32.Output tensor, including maximum index or maximum value.
- *@par Third-party framework compatibility
- * Compatible with the Caffe operator ArgMax.
- */
- REG_OP(ArgMaxWithK)
- .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16}))
- .OUTPUT(indices, TensorType({DT_INT32, DT_FLOAT, DT_FLOAT16}))
- .OUTPUT(values, TensorType({DT_FLOAT, DT_FLOAT16}))
- .ATTR(axis, Int, 10000)
- .ATTR(out_max_val, Bool, false)
- .ATTR(topk, Int, 1)
- .OP_END_FACTORY_REG(ArgMaxWithK)
-
- /**
- *@brief Multiply tensor with scale. \n
-
- *@par Inputs:
- *Five inputs, including:
- * @li x1: A Tensor. Must be one of the following types:int32,int16, float16, float32.
- * @li x2: A scale. Must be float. \n
-
- *@par Outputs:
- *@li y: A Tensor. Has the same type and shape as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the Pytorch operator muls.
- */
- REG_OP(Muls)
- .INPUT(x, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .REQUIRED_ATTR(value, Float)
- .OP_END_FACTORY_REG(Muls)
-
- /**
- *@brief Fill tensor with scale. \n
-
- *@par Inputs:
- *Five inputs, including:
- * @li x1: A Tensor. Must be one of the following types:int32,int16, float16, float32.
- * @li x2: A scale. Must be float. \n
-
- *@par Outputs:
- *@li y: A Tensor. Has the same type and shape as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the Pytorch operator fills.
- */
- REG_OP(Fills)
- .INPUT(x, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .REQUIRED_ATTR(value,Float)
- .OP_END_FACTORY_REG(Fills)
-
- /**
- *@brief Add tensor with scale. \n
-
- *@par Inputs:
- *Five inputs, including:
- * @li x1: A Tensor. Must be one of the following types:int32,int16, float16, float32.
- * @li x2: A scale. Must be float. \n
-
- *@par Outputs:
- *@li y: A Tensor. Has the same type and shape as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the Pytorch operator adds.
- */
- REG_OP(Adds)
- .INPUT(x, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_FLOAT,DT_INT16,DT_INT32,DT_FLOAT16}))
- .REQUIRED_ATTR(value,Float)
- .OP_END_FACTORY_REG(Adds)
-
- /**
- *@brief Computes the product of x and y and returns 0 if the y is zero, even if x is NaN or infinite. \n
-
- *@par Inputs:
- * @li x1: A Tensor. Must be one of the following types:float16, float32, double, complex64, complex128.
- * @li x2: A Tensor. Has the same type and shape as "x1". \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type and shape as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the TensorFlow operator MulNoNan.
- */
- REG_OP(MulNoNan)
- .INPUT(x1, TensorType::NumberType()) /* "First operand." */
- .INPUT(x2, TensorType::NumberType()) /* "Second operand." */
- .OUTPUT(y, TensorType::NumberType()) /* "Result, has same element type as two inputs" */
- .OP_END_FACTORY_REG(MulNoNan)
-
- /**
- *@brief Add tensor with scale. \n
-
- *@par Inputs:
- * @li x1: A Tensor dtype of int32, float16, float32.
- * @li x2: A Tensor dtype of int32, float16, float32. \n
-
- *@par Attributes:
- *alpha: Float scalar apply to x2:x2*alpha
-
- *@par Outputs:
- *y: A Tensor. should be same shape and type as "x1". \n
-
- *@par Third-party framework compatibility:
- * Compatible with the Pytorch operator Axpy.
- */
- REG_OP(Axpy)
- .INPUT(x1, TensorType({DT_FLOAT, DT_INT32, DT_FLOAT16}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_INT32, DT_FLOAT16}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_INT32, DT_FLOAT16}))
- .REQUIRED_ATTR(alpha, Float)
- .OP_END_FACTORY_REG(Axpy)
-
- /**
- *@brief Creates a criterion that measures the loss given input tensors x1 x2 and a Tensor label y with values 1 or -1. \n
-
- *@par Inputs:
- *@li x1: A ND Tensor with one of the following types: int8, uint8, int32, float16, float32.
- *@li x2: A ND Tensor with one of the following types: int8, uint8, int32, float16, float32.
- *@li target: A ND Tensor with one of the following types: int8, int32, float16, float32. \n
-
- *@par Attributes:
- *@li margin: A optional float32. Defaults to "0.0".
- *@li reduction: A optional string. Defaults to "mean". \n
-
- *@par Outputs:
- *@li y: A ND Tensor with Must be float32.
- *@par Third-party framework compatibility
- * Compatible with the PyTorch operator CosineEmbeddingLoss.
- */
- REG_OP(CosineEmbeddingLoss)
- .INPUT(x1, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_INT32, DT_INT64, DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .INPUT(x2, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_INT32, DT_INT64, DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .INPUT(target, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_INT32, DT_INT64, DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .ATTR(margin, Float, 0)
- .ATTR(reduction, String, "mean")
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .OP_END_FACTORY_REG(CosineEmbeddingLoss)
-
- /**
- *@brief Kullback-Leibler divergence. \n
-
- *@par Inputs:
- * Two inputs, including:
- *@li x: Tensor of arbitrary shape.
- *@li target: Tensor of the same shape and dtype as x. \n
-
- *@par Attributes:
- *reduction: An required "string", Specifies the reduction to apply to the output;
- * Reduction only supports the two modes of "sum" and "batchmean". \n
-
- *@par Outputs:
- *y: A ND Tensor of the same dtype as x.
- *@par Third-party framework compatibility
- *Compatible with the PyTorch operator kl_div.
- */
- REG_OP(KLDiv)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .INPUT(target, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .REQUIRED_ATTR(reduction, String)
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(KLDiv)
-
- /**
- *@brief copy data from x to y.. \n
-
- *@par Inputs:
- *One inputs, including:
- * @li x: A Tensor. Must be one of the following types: float16, float32, int8, uint8, int32, bool. \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
-
- *@par Restrictions:
- *Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
- */
- REG_OP(TensorMove)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT8, DT_UINT8, DT_BOOL}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT8, DT_UINT8, DT_BOOL}))
- .OP_END_FACTORY_REG(TensorMove)
-
- /**
- *@brief copy data from x to x. \n
-
- *@par Inputs:
- *One inputs, including:
- * @li x: A Tensor. Must be one of the following types: float16, float32, int8, uint8, int16, uint16, int32, uint32, int64, uint64. \n
-
- *@par Outputs:
- *output_x: A Tensor. Has the same type as "x". \n
-
- *@par Third-party framework compatibility
- */
- REG_OP(TensorRedirect)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT8,
- DT_INT64, DT_INT16, DT_UINT16, DT_UINT64, DT_UINT32}))
- .OUTPUT(output_x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_INT32, DT_UINT8,
- DT_INT64, DT_INT16, DT_UINT16, DT_UINT64, DT_UINT32}))
- .OP_END_FACTORY_REG(TensorRedirect)
- } // namespace ge
-
-
-
- #endif // OPS_BUILT_IN_OP_PROTO_INC_ELEWISE_CALCULATION_OPS_H_
|