m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '22db649a79'
${ noResults }
graphengine/third_party/fwkacllib/inc/ops/math_ops.h

698 lines
21 KiB
Raw Blame History

/**
* 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)
} // namespace ge
#endif // OPS_BUILT_IN_OP_PROTO_INC_MATH_OPS_H_
Reference in new issue View Git Blame Copy Permalink