|
- /**
- * 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 math_ops.h
- * \brief
- */
- #ifndef OPS_BUILT_IN_OP_PROTO_INC_MATH_OPS_H_
- #define OPS_BUILT_IN_OP_PROTO_INC_MATH_OPS_H_
-
- #include "graph/operator_reg.h"
- #include "graph/operator.h"
-
- namespace ge {
-
- /**
- *@brief Computes the output as (shift + scale * x) ^ power . \n
-
- *@par Inputs:
- * x: A Tensor of type float16 or float32 . \n
-
- *@par Attributes:
- *@li power: Optional. Must be one of the following types: float32. Defaults to 1.0.
- *@li scale: Optional. Must be one of the following types: float32. Defaults to 1.0.
- *@li shift: Optional. Must be one of the following types: float32. Defaults to 0.0 . \n
-
- *@par Outputs:
- * y: A Tensor. Has the same type and shape as "x".
- *@par Third-party framework compatibility
- * Compatible with the Caffe operator Power.
- */
-
- REG_OP(Power)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .ATTR(power, Float, 1.0)
- .ATTR(scale, Float, 1.0)
- .ATTR(shift, Float, 0.0)
- .OP_END_FACTORY_REG(Power);
-
- /**
- *@brief Compute the lower regularized incomplete Gamma function P(a, x) . \n
-
- *@par Inputs:
- *The input a and x must have the same type. Inputs include:
- *@li a:A Tensor. Must be one of the following types: float, double.
- *@li x:A Tensor. Must have the same type as a . \n
-
- *@par Outputs:
- *z:A Tensor. Has the same type as a . \n
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Igamma operator.
- */
-
- REG_OP(Igamma)
- .INPUT(a, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(z, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(Igamma)
-
- /**
- *@brief Compute the upper regularized incomplete Gamma function Q(a, x) . \n
-
- *@par Inputs:
- *The input a and x must have the same type. Inputs include:
- *@li a:A Tensor. Must be one of the following types: float, float64.
- *@li x:A Tensor. Must have the same type as a . \n
-
- *@par Outputs:
- *z:A Tensor. Has the same type as a . \n
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Igammac operator.
- */
-
- REG_OP(Igammac)
- .INPUT(a, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(z, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(Igammac)
-
- /**
- *@brief Compare values of input to threshold and pack resulting bits into
- a uint8 . \n
-
- *@par Inputs:
- *The input size must be a non-negative int32 scalar Tensor. Inputs include:
- *@li input:Values to compare against threshold and bitpack.
- *@li threshold:Threshold to compare against . \n
-
- *@par Outputs:
- *y:The bitpacked comparisons . \n
-
- *@attention Constraints:
- *Currently, the innermost dimension of the tensor must be divisible by 8. \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow CompareAndBitpack operator
- */
-
- REG_OP(CompareAndBitpack)
- .INPUT(x, TensorType({ DT_FLOAT, DT_FLOAT16, DT_DOUBLE, DT_INT8, \
- DT_INT16, DT_INT32, DT_INT64, DT_BOOL }))
- .INPUT(threshold, TensorType({ DT_FLOAT, DT_FLOAT16, DT_DOUBLE, \
- DT_INT8, DT_INT16, DT_INT32, DT_INT64, DT_BOOL }))
- .OUTPUT(y, TensorType(DT_UINT8))
- .OP_END_FACTORY_REG(CompareAndBitpack)
-
- /**
- *@brief Counts the number of occurrences of each value in an integer array.
- Outputs a vector with length size and the same dtype as weights. If weights
- are empty, then index i stores the number of times the value i is counted in
- arr. If weights are non-empty, then index i stores the sum of the value in
- weights at each index . \n
-
- *@par Inputs:
- *The input size must be a non-negative int32 scalar Tensor. Inputs include:
- *@li array:int32 Tensor.
- *@li size:non-negative int32 scalar Tensor.
- *@li weights: is an int32, int64, float32, or double Tensor with the same
- shape as arr, or a length-0 Tensor, in which case it acts as all weights
- equal to 1 . \n
-
- *@par Outputs:
- *bins:1D Tensor with length equal to size. The counts or summed weights for
- each value in the range [0, size) . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow Bincount operator
- */
-
- REG_OP(Bincount)
- .INPUT(array, TensorType(DT_INT32))
- .INPUT(size, TensorType(DT_INT32))
- .INPUT(weights, TensorType({ DT_FLOAT, DT_INT32, DT_INT64, DT_DOUBLE }))
- .OUTPUT(bins, TensorType({ DT_FLOAT, DT_INT32, DT_INT64, DT_DOUBLE }))
- .OP_END_FACTORY_REG(Bincount)
-
- /**
- *@brief Compute the regularized incomplete beta integral . \n
-
- *@par Inputs:
- *The input b and x must have the same types as a. Inputs include:
- *@li a:A Tensor. Must be one of the following types: float32, double.
- *@li b:A Tensor. Must have the same type as a.
- *@li x:A Tensor. Must have the same type as a . \n
-
- *@par Outputs:
- *z:A Tensor. Has the same type as a . \n
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Betainc operator.
- */
-
- REG_OP(Betainc)
- .INPUT(a, TensorType({DT_DOUBLE, DT_FLOAT}))
- .INPUT(b, TensorType({DT_DOUBLE, DT_FLOAT}))
- .INPUT(x, TensorType({DT_DOUBLE, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_DOUBLE, DT_FLOAT}))
- .OP_END_FACTORY_REG(Betainc)
-
- /**
- *@brief Compute the Hurwitz zeta function
-
- *@par Inputs:
- *The input q must be the same type as x. Inputs include:
- *@li x:A Tensor. Must be one of the following types: float32, double.
- *@li q:A Tensor. Must have the same type as x . \n
-
- *@par Outputs:
- *z:A Tensor. Has the same type as x . \n
-
- *@attention Constraints:
- *The implementation for Zeta on Ascend uses ai cpu, with bad performance.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Zeta operator.
- */
-
- REG_OP(Zeta)
- .INPUT(x, TensorType({DT_DOUBLE, DT_FLOAT}))
- .INPUT(q, TensorType({DT_DOUBLE, DT_FLOAT}))
- .OUTPUT(z, TensorType({DT_DOUBLE, DT_FLOAT}))
- .OP_END_FACTORY_REG(Zeta)
-
- /**
- *@brief Bucketize 'input' based on 'boundaries'. For example, if the inputs
- are boundaries = [0, 10, 100] input = [[-5, 10000] [150, 10] [5, 100]] then
- the output will be output = [[0, 3] [3, 2] [1, 3]]
-
- *@par Inputs:
- *The dtype of input x int float double. Inputs include:
- *x:Any shape of Tensor contains with int or float type . \n
-
- *@par Attributes:
- *boundaries:A sorted list of floats gives the boundary of the buckets . \n
-
- *@par Outputs:
- *y:Same shape with 'input', each value of input replaced with bucket index . \n
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Bucketize operator.
- */
-
- REG_OP(Bucketize)
- .INPUT(x, TensorType({DT_INT32, DT_INT64, DT_DOUBLE, DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_INT32}))
- .REQUIRED_ATTR(boundaries, ListFloat)
- .OP_END_FACTORY_REG(Bucketize)
-
- /**
- *@brief Computes the sum along sparse segments of a tensor . \n
-
- *@par Inputs:
- *The input indices and segment_ids must have same rank. Inputs include:
- *@li x:A Tensor. Must be one of the following types: float, double, int32,
- uint8, int16, int8, int64, uint16, uint32, uint64.
- *@li indices: A Tensor. Must be one of the following types: int32, int64.
- A 1-D tensor. Has same rank as segment_ids.
- *@li segment_ids: A Tensor of type int32. A 1-D tensor. Values should be
- sorted and can be repeated . \n
-
- *@par Outputs:
- *y:A Tensor. Has the same type as x . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow SparseSegmentSum operator
- */
-
- REG_OP(SparseSegmentSum)
- .INPUT(x, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_UINT16,
- DT_INT32, DT_INT64, DT_DOUBLE, DT_FLOAT, DT_FLOAT16}))
- .INPUT(indices, TensorType({DT_INT32}))
- .INPUT(segment_ids, TensorType({DT_INT32}))
- .OUTPUT(y, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_UINT16,
- DT_INT32, DT_INT64, DT_DOUBLE, DT_FLOAT, DT_FLOAT16}))
- .OP_END_FACTORY_REG(SparseSegmentSum)
-
- /**
- *@brief Computes the mean along sparse segments of a tensor . \n
-
- *@par Inputs:
- *The input indices and segment_ids must have same rank. Inputs include:
- *@li x: A Tensor. Must be one of the following types: float, double.
- *@li indices: A Tensor. Must be one of the following types: int32, int64.
- A 1-D tensor. Has same rank as segment_ids.
- *@li segment_ids: A Tensor of type int32. A 1-D tensor. Values should be
- sorted and can be repeated . \n
-
- *@par Outputs:
- *y:A Tensor. Has the same type as x . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow SparseSegmentMean operator
- */
-
- REG_OP(SparseSegmentMean)
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(indices, TensorType({DT_INT32}))
- .INPUT(segment_ids, TensorType({DT_INT32}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(SparseSegmentMean)
-
- /**
- *@brief Computes gradients for SparseSegmentMean . \n
-
- *@par Inputs:
- *The input grad must have be type float or double. Inputs include:
- *@li grad: A Tensor. Must be one of the following types: float, double.
- gradient propagated to the SparseSegmentMean op.
- *@li indices: A Tensor. Must be one of the following types: int32, int64.
- indices passed to the corresponding SparseSegmentMean op.
- *@li segment_ids: A Tensor of type int32. segment_ids passed to the
- corresponding SparseSegmentMean op.
- *@li output_dim0: A Tensor of type int32. dimension 0 of "x" passed to
- SparseSegmentMean op . \n
-
- *@par Outputs:
- *y:A Tensor. Has the same type as grad . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow SparseSegmentMeanGrad operator
- */
-
- REG_OP(SparseSegmentMeanGrad)
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(indices, TensorType({DT_INT32}))
- .INPUT(segment_ids, TensorType({DT_INT32}))
- .INPUT(output_dim0, TensorType({DT_INT32}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(SparseSegmentMeanGrad)
-
- /**
- *@brief Computes the gradient of igamma(a, x) wrt a
-
- *@par Inputs:
- *The input a and x must have the same type. Inputs include:
- *@li a:A Tensor. Must be one of the following types: float32, double.
- *@li x:A Tensor. Must have the same type as a . \n
-
- *@par Outputs:
- *y:A Tensor. Has the same type as a . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow IgammaGradA operator
- */
-
- REG_OP(IgammaGradA)
- .INPUT(a, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(x, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(z, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(IgammaGradA)
-
- /**
- *@brief Initialize data process channel . \n
-
- *@par Attributes:
- *channel_name: A string. Default "" . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow InitData operator
- */
-
- REG_OP(InitData)
- .ATTR(channel_name, String, "")
- .OP_END_FACTORY_REG(InitData)
-
- /**
- *@brief Get the next batch of data in data processing . \n
-
- *@par Attributes:
- *@li output_types: A nested structure of DType objects corresponding to each
- component of an element of this dataset.
- *@li output_shapes: A nested structure of TensorShape objects corresponding
- to each component of an element of this dataset.
- *@li channel_name: A string. Default "" . \n
-
- *@par Outputs:
- *y:A nested structure of Tensor objects . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow GetNext operator
- */
-
- REG_OP(GetNext)
- .DYNAMIC_OUTPUT(y, TensorType({DT_INT8, DT_UINT8, DT_INT16, DT_UINT16, DT_INT32, DT_INT64, DT_UINT32, DT_UINT64,
- DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_BOOL}))
- .ATTR(output_types, ListInt, {})
- .ATTR(output_shapes, ListListInt, {})
- .ATTR(output_num, Int, 1)
- .ATTR(channel_name, String, "")
- .OP_END_FACTORY_REG(GetNext)
-
- /**
- *@brief End of sequence . \n
-
- *@par Inputs:
- *x: A Tensor of type uint8 . \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x".
- */
-
- REG_OP(EndOfSequence)
- .INPUT(x, TensorType({DT_UINT8}))
- .OUTPUT(y, TensorType({DT_UINT8}))
- .OP_END_FACTORY_REG(EndOfSequence)
-
- /**
- *@brief: Computes the Gauss error function of `x` element-wise . \n
-
- *@par Inputs:
- *x: A Tensor of type float16, float32 or double. the format can be
- * [NCHW,NC1HWC0,NHWC,ND]
-
- *@par Outputs:
- *y: A Tensor. Has the same type and format as "x" . \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Erf.
- */
- REG_OP(Erf)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(Erf)
-
- /**
- *@brief: Computes the Gauss complementary error function of "x" element-wise . \n
-
- *@par Inputs:
- *x: A Tensor of type float16 ,float32, double . \n
-
- *@par Outputs:
- *y: A Tensor. Has the same type as "x" . \n
-
- *@par Third-party framework compatibility
- * Compatible with the TensorFlow operator Erfc.
- */
- REG_OP(Erfc)
- .INPUT(x, TensorType::FloatingDataType())
- .OUTPUT(y, TensorType::FloatingDataType())
- .OP_END_FACTORY_REG(Erfc)
-
- /**
- *@brief This operation returns a rank 1 histogram counting the number of entries in `values`
- * that fell into every bin.The bins are equal width and determined by the arguments
- * 'value_range' and 'nbins' . \n
-
- *@par Inputs:
- *Three inputs, including:
- *@li x: A Tensor of type float32, float16, int32, int64.
- *@li range: A Tensor of type float32,float16,int32, int64.
- *@li nbins: A Tensor of type int32 . \n
-
- *@par Attributes:
- * dtype: An optional attribute. Defaults to "int32" . \n
-
- *@par Outputs:
- *y: A Tensor. A Tensor of type int32 or int64 . \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator HistogramFixedWidth.
- */
- REG_OP(HistogramFixedWidth)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64}))
- .INPUT(range, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64}))
- .INPUT(nbins, TensorType({DT_INT32}))
- .OUTPUT(y, TensorType({DT_INT32}))
- .ATTR(dtype, String, "int32")
- .OP_END_FACTORY_REG(HistogramFixedWidth)
-
- /**
- *@brief This operation returns a rank 1 histogram counting the number of entries in `values`
- * that fell into every bin.The bins are equal width and determined by the arguments
- * 'value_range' and 'nbins' . \n
-
- *@par Inputs:
- *Two inputs, including:
- *@li x: A Tensor of type float32,float16,int32, int64.
- *@li range: A Tensor of type float32,float16,int32, int64 . \n
-
- *@par Attributes:
- *@li dtype: An optional attribute. Defaults to "int32".
- *@li nbins: A required attribute,the type is int32 . \n
-
- *@par Outputs:
- *y: A Tensor. A Tensor of type int32 . \n
-
- *@par Third-party framework compatibility
- * Compatible with TensorFlow operator HistogramFixedWidth.
- *
- * @par Restrictions:
- * Warning: THIS FUNCTION IS DEPRECATED. Please use HistogramFixedWidth instead.
- */
- REG_OP(HistogramFixedWidthD)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64}))
- .INPUT(range, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32, DT_INT64}))
- .OUTPUT(y, TensorType({DT_INT32}))
- .REQUIRED_ATTR(nbins, Int)
- .ATTR(dtype, String, "int32")
- .OP_END_FACTORY_REG(HistogramFixedWidthD)
-
- /**
- *@brief Returns the next representable value of x1 in the direction of x2, element-wise . \n
-
- *@par Inputs:
- *The input X1 and x2 must have the same type. Inputs include:
- *@li x1:A Tensor. Must be one of the following types: float32, double.
- *@li x2:A Tensor. Must have the same type as x1 . \n
-
- *@par Outputs:
- *output:A Tensor. Has the same type as x1 . \n
-
- *@par Third-party framework compatibility
- *Compatible with tensorflow NextAfter operator
- */
- REG_OP(NextAfter)
- .INPUT(x1, TensorType({DT_FLOAT, DT_DOUBLE}))
- .INPUT(x2, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(output, TensorType({DT_FLOAT, DT_DOUBLE}))
- .OP_END_FACTORY_REG(NextAfter)
-
- /**
- *@brief Compute element-wise finiteness, return a boolean tensor.
-
- *@par Inputs:
- *x:A Tensor.
-
- *@par Outputs:
- *y:A Tensor. Has the same shape as x.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow IsFinite operator.
- */
- REG_OP(IsFinite)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(IsFinite)
-
- /**
- *@brief Compute element-wise infiniteness, return a boolean tensor.
-
- *@par Inputs:
- *x:A Tensor.
-
- *@par Outputs:
- *y:A Tensor. Has the same shape as x.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow IsInf operator.
- */
- REG_OP(IsInf)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(IsInf)
-
- /**
- *@brief Computes the complex absolute value of a tensor.
-
- *@par Inputs:
- *x:A Tensor.
-
- *@par Outputs:
- *y:A tensor of type `float` or `double` that is the absolute value of each element in `x`.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow ComplexAbs operator.
- */
- REG_OP(ComplexAbs)
- .INPUT(x, TensorType({DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(y, TensorType({DT_FLOAT, DT_DOUBLE}))
- .ATTR(Tout, Type, DT_FLOAT)
- .OP_END_FACTORY_REG(ComplexAbs)
-
- /**
- *@brief Returns which elements of x are NaN.
-
- *@par Inputs:
- *x:A Tensor.
-
- *@par Outputs:
- *y:A Tensor. Has the same shape as x.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow IsNan operator.
- */
- REG_OP(IsNan)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE}))
- .OUTPUT(y, TensorType({DT_BOOL}))
- .OP_END_FACTORY_REG(IsNan)
-
- /**
- *@brief Returns the real part of a complex number.
-
- *@par Inputs:
- *input:A Tensor.
-
- *@par Outputs:
- *output:A Tensor. Has the same shape as input.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow Real operator.
- */
- REG_OP(Real)
- .INPUT(input, TensorType({DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(output, TensorType({DT_FLOAT, DT_DOUBLE}))
- .ATTR(Tout, Type, DT_FLOAT)
- .OP_END_FACTORY_REG(Real)
-
- /**
- *@brief Returns the complex conjugate of a complex number.
-
- *@par Inputs:
- *input:A Tensor.
-
- *@par Outputs:
- *output:A Tensor. Has the same shape as input.
-
- *@par Third-party framework compatibility.
- *Compatible with tensorflow output operator.
- */
- REG_OP(Conj)
- .INPUT(input, TensorType({DT_COMPLEX64, DT_COMPLEX128}))
- .OUTPUT(output, TensorType({DT_COMPLEX64, DT_COMPLEX128}))
- .OP_END_FACTORY_REG(Conj)
-
- /**
- *@brief The negative log likelihood loss . \n
-
- *@par Inputs:
- *The input x and weight must have the same type. Inputs include:
- *@li x: A Tensor dtype of float32.
- *@li target: A Tensor dtype of int32.
- *@li weight: A Tensor dtype of float32 . \n
-
- *@par Attributes:
- *reduction: An optional attribute. Defaults to "mean" . \n
-
- *@par Outputs:
- *@li y: A Tensor dtype of float32.
- *@li total_weight: A Tensor dtype of float32 . \n
-
- *@par Third-party framework compatibility
- *Compatible with pytorch NLLLoss operator
- */
- REG_OP(NLLLoss)
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(target, TensorType({DT_INT32}))
- .INPUT(weight, TensorType({DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT}))
- .OUTPUT(total_weight, TensorType({DT_FLOAT}))
- .ATTR(reduction, String, "mean")
- .OP_END_FACTORY_REG(NLLLoss)
-
- /**
- *@brief The negative log likelihood loss grad . \n
-
- *@par Inputs:
- *@li x:A Tensor dtype of float32.
- *@li y_grad:A Tensor dtype of float32.
- *@li target:A Tensor dtype of int32.
- *@li weight:A Tensor dtype of float32.
- *@li total_weight:A Tensor dtype of float32 . \n
-
- *@par Attributes:
- *reduction: An optional attribute. Defaults to "mean" . \n
-
- *@par Outputs:
- *x_grad: A Tensor. Must be the following type: float32 . \n
-
- *@par Third-party framework compatibility
- *Compatible with pytorch NLLLossGrad operator
- */
- REG_OP(NLLLossGrad)
- .INPUT(x, TensorType({DT_FLOAT}))
- .INPUT(y_grad, TensorType({DT_FLOAT}))
- .INPUT(target, TensorType({DT_INT32}))
- .INPUT(weight, TensorType({DT_FLOAT}))
- .INPUT(total_weight, TensorType({DT_FLOAT}))
- .OUTPUT(x_grad, TensorType({DT_FLOAT}))
- .ATTR(reduction, String, "mean")
- .OP_END_FACTORY_REG(NLLLossGrad)
-
- /**
- *@brief The ifmr . \n
-
- *@par Inputs:
- *@li data:A Tensor of feature map
- *@li data_min:A Tensor of min value of feature map.
- *@li data_max:A Tensor of max value of feature map.
- *@li cumsum:A Tensor of cumsum bin of data . \n
-
- *@par Attributes:
- *min_percentile: min init percentile.
- *max_percentile: max init percentile.
- *search_range: search range.
- *search_step: step size of searching.
- *with_offset: whether using offset . \n
-
- *@par Outputs:
- *scale: optimal scale.
- *offset: optimal offset . \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(IFMR)
- .INPUT(data, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(data_min, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(data_max, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(cumsum, TensorType({DT_INT32}))
- .OUTPUT(scale, TensorType({DT_FLOAT}))
- .OUTPUT(offset, TensorType({DT_FLOAT}))
- .REQUIRED_ATTR(min_percentile, Float)
- .REQUIRED_ATTR(max_percentile, Float)
- .REQUIRED_ATTR(search_range, ListFloat)
- .REQUIRED_ATTR(search_step, Float)
- .REQUIRED_ATTR(with_offset, Bool)
- .OP_END_FACTORY_REG(IFMR)
-
- /**
- *@brief weights adaptive range quantization. \n
-
- *@par Inputs:
- *@li w:A Tensor of weights. \n
- *@li w_min:A Tensor of weights reduce_min. \n
- *@li w_max:A Tensor of weights reduce_max. \n
-
- *@par Attributes:
- *num_bits: the bits num used for quantize.
- *offset_flag: whether using offset. \n
-
- *@par Outputs:
- *y: fake quantized weights. \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(WtsARQ)
- .INPUT(w, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(w_min, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(w_max, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .ATTR(num_bits, Int, 8)
- .ATTR(offset_flag, Bool, false)
- .OP_END_FACTORY_REG(WtsARQ)
-
- /**
- *@brief The acts_ulq. \n
-
- *@par Inputs:
- *@li x:A Tensor of feature map
- *@li clamp _min:A Tensor of min clamp value of feature map.
- *@li clamp _max:A Tensor of max clamp value of feature map.
-
- *@par Attributes:
- *fixed_min: fix min to zero.
- *num_bits: quant bits. \n
-
- *@par Outputs:
- *y: output fake quant feature map.
- *clamp_min_mask: where x > clamp_min
- *clamp_min_mask: where x < clamp_max
- *x_clamped_loss: clamp loss. \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(ActsULQ)
- .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(clamp_min, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(clamp_max, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(clamp_min_mask, TensorType({DT_BOOL}))
- .OUTPUT(clamp_max_mask, TensorType({DT_BOOL}))
- .OUTPUT(x_clamped_loss, TensorType({DT_FLOAT16, DT_FLOAT}))
- .ATTR(fixed_min, Bool, false)
- .ATTR(num_bits, Int, 8)
- .OP_END_FACTORY_REG(ActsULQ)
-
- /**
- *@brief The acts_ulq_input_grad. \n
-
- *@par Inputs:
- *@li y_grad: A Tensor of gradient
- *@li clamp_min_mask: A Tensor of boolean mask indicating whether an additional one is needed'
- *@li clamp_max_mask: A Tensor of boolean mask indicating whether an additional one is needed'
-
- *@par Outputs:
- *x_grapd: The gradient of inpust. \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(ActsULQInputGrad)
- .INPUT(y_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(clamp_min_mask, TensorType({DT_BOOL}))
- .INPUT(clamp_max_mask, TensorType({DT_BOOL}))
- .OUTPUT(x_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(ActsULQInputGrad)
-
- /**
- *@brief The act_ulq_clamp_max_grad. \n
-
- *@par Inputs:
- *@li y_grad: A Tensor of gradient
- *@li clamp_max_mask: A Tensor of boolean mask indicating whether an additional one is needed.
- *@li x_clamped_loss: A Tensor of gradient. \n
-
- *@par Outputs:
- *clamp_max_grad: The gradient of clamp max. \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(ActULQClampMaxGrad)
- .INPUT(y_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(clamp_max_mask, TensorType({DT_BOOL}))
- .INPUT(x_clamped_loss, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(clamp_max_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(ActULQClampMaxGrad)
-
- /**
- *@brief The act_ulq_clamp_min_grad. \n
-
- *@par Inputs:
- *@li y_grad: A Tensor of gradient
- *@li clamp_min_mask: A Tensor of boolean mask indicating whether an additional one is needed.
- *@li x_clamped_loss: A Tensor of gradient. \n
-
- *@par Outputs:
- *clamp_min_grad: The gradient of clamp min. \n
-
- *@par Third-party framework compatibility
- *Compatible with mindspore
- */
-
- REG_OP(ActULQClampMinGrad)
- .INPUT(y_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .INPUT(clamp_min_mask, TensorType({DT_BOOL}))
- .INPUT(x_clamped_loss, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OUTPUT(clamp_min_grad, TensorType({DT_FLOAT16, DT_FLOAT}))
- .OP_END_FACTORY_REG(ActULQClampMinGrad)
-
- } // namespace ge
-
- #endif // OPS_BUILT_IN_OP_PROTO_INC_MATH_OPS_H_
|