Skip to content

MathOp

Jump to bottom
wangzhaode edited this page Feb 16, 2023 · 1 revision

MathOp

class MathOp

成员函数

_Add

MNN_PUBLIC VARP _Add(VARP x, VARP y);

返回x + y的值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一

返回：x相同的类型变量

_Subtract

MNN_PUBLIC VARP _Subtract(VARP x, VARP y);

计算x-y的值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一

返回：x相同的类型变量

_Multiply

MNN_PUBLIC VARP _Multiply(VARP x, VARP y);

计算x*y的值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一

返回：x相同的类型变量

_Divide

MNN_PUBLIC VARP _Divide(VARP x, VARP y);

计算x/y的值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一

返回：x相同的类型变量

_Pow

MNN_PUBLIC VARP _Pow(VARP x, VARP y);

计算x的y的幂次方的值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一

返回：x相同的类型变量

_Minimum

MNN_PUBLIC VARP _Minimum(VARP x, VARP y);

返回x和y的最小值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一

返回：x相同的类型变量

_Maximum

MNN_PUBLIC VARP _Maximum(VARP x, VARP y);

返回x和y的最大值

参数：

  • x 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一
  • y 一个变量，Halide_Type_Int or Halide_Type_Float, Halide_Type_Int64类型之一

返回：x相同的类型变量

_BiasAdd

MNN_PUBLIC VARP _BiasAdd(VARP value, VARP bias);

增加value的偏差。这(主要)是加法的一个特殊情况，其中偏差限制在1-D。支持广播，因此value可以有任意数量的维度。与加法不同，在量子化的情况下，偏差的类型允许与值不同

参数：

  • value 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • bias 一个一维变量，其大小与值的通道维度相匹配，必须与值的类型相同，除非值是量化类型，在这种情况下可以使用不同的量化类型

返回：value相同的类型变量

_Greater

MNN_PUBLIC VARP _Greater(VARP x, VARP y);

比较x和y的大小，如果x > y为true，否者为false

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：true或者false

_GreaterEqual

MNN_PUBLIC VARP _GreaterEqual(VARP x, VARP y);

比较x和y的大小，如果x >= y为true，否者为false

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：true或者false

_Less

MNN_PUBLIC VARP _Less(VARP x, VARP y);

比较x和y的大小，如果x < y为true，否者为false

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：true或者false

_FloorDiv

MNN_PUBLIC VARP _FloorDiv(VARP x, VARP y);

返回x // y的值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：x相同的类型变量

_SquaredDifference

MNN_PUBLIC VARP _SquaredDifference(VARP x, VARP y);

返回(x - y)(x - y)的值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：x相同的类型变量

_Equal

MNN_PUBLIC VARP _Equal(VARP x, VARP y);

判断x和y是否相等，如果x = y为true，否者为false

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：true或者false

_LessEqual

MNN_PUBLIC VARP _LessEqual(VARP x, VARP y);

判断x和y的大小，如果x <= y则返回true，否则返回false

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：true或者false

_FloorMod

MNN_PUBLIC VARP _FloorMod(VARP x, VARP y);

返回x % y的值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：x相同的类型变量

_Atan2

MNN_PUBLIC VARP _Atan2(VARP x, VARP y);

计算y / x的元素反正切的值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：x相同的类型变量

_LogicalOr

MNN_PUBLIC VARP _LogicalOr(VARP x, VARP y);

返回x和y的逻辑或的值

参数：

  • x Halide_Type_Int类型的变量
  • y Halide_Type_Int类型的变量

返回：true/false

_NotEqual

MNN_PUBLIC VARP _NotEqual(VARP x, VARP y);

判断x和y是否相等，如果x != y则返回true，否者返回false

参数：

  • x Halide_Type_Int类型的变量
  • y Halide_Type_Int类型的变量

返回：true/false

_BitwiseAnd

MNN_PUBLIC VARP _BitwiseAnd(VARP x, VARP y);

返回x和y的按位逻辑与的值(x & y)

参数：

  • x Halide_Type_Int类型的变量
  • y Halide_Type_Int类型的变量

返回：x相同的类型变量

_BitwiseOr

MNN_PUBLIC VARP _BitwiseOr(VARP x, VARP y);

返回x和y的按位逻辑或的值(x | y)

参数：

  • x Halide_Type_Int类型的变量
  • y Halide_Type_Int类型的变量

返回：x相同的类型变量

_BitwiseXor

MNN_PUBLIC VARP _BitwiseXor(VARP x, VARP y);

返回x和y的按位异或的值(x ^ y)

参数：

  • x Halide_Type_Int类型的变量
  • y Halide_Type_Int类型的变量

返回：x相同的类型变量

_Sign

MNN_PUBLIC VARP _Sign(VARP a);

去掉x元素的符号 sign(x) = 0 if x=0 sign(x) =-1 if x<0 sign(x) = 1 if x>0

参数：

  • a 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：-1、0或者1

_Abs

MNN_PUBLIC VARP _Abs(VARP x);

计算变量的绝对值，给定一个整型或浮点型变量，该操作将返回一个相同类型的变量，其中每个元素都包含输入中对应元素的绝对值 x = MNN.const((-1.0， -2.0, 3.0)， (3，)) x = MNN.abs(x) # (1.0, 2.0, 3.0)

参数：

  • x Halide_Type_Int或Halide_Type_Float类型的变量

返回：一个大小相同的变量，类型与x的绝对值相同

_Negative

MNN_PUBLIC VARP _Negative(VARP x);

计算元素数值负值 x = MNN.const((-1.0， -2.0, 3.0)， (3，)) x = MNN.negative(x) #(1.0, 2.0， -3.0)

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：和x相同类型的变量

_Floor

MNN_PUBLIC VARP _Floor(VARP x);

返回不大于x的最大整数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：和x相同类型的变量

_Round

MNN_PUBLIC VARP _Round(VARP x);

返回元素四舍五入的整数

参数：

  • x Halide_Type_Float类型的变量

返回：Halide_Type_Float类型的变量

_Ceil

MNN_PUBLIC VARP _Ceil(VARP x);

返回不小于x的最小整数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：和x相同类型的变量

_Square

MNN_PUBLIC VARP _Square(VARP x);

计算x元素的平方值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Sqrt

MNN_PUBLIC VARP _Sqrt(VARP x);

计算x的平方根

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Rsqrt

MNN_PUBLIC VARP _Rsqrt(VARP x);

计算x根号的倒数

参数：一个变量，Halide_Type_Int或Halide_Type_Float类型之一

  • x

返回：x相同类型的变量

_Exp

MNN_PUBLIC VARP _Exp(VARP x);

计算x的指数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Log

MNN_PUBLIC VARP _Log(VARP x);

计算x的对数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Sin

MNN_PUBLIC VARP _Sin(VARP x);

计算x的正弦值

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Sinh

MNN_PUBLIC VARP _Sinh(VARP x);

计算x的双曲正弦值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Cos

MNN_PUBLIC VARP _Cos(VARP x);

计算x的余弦值

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Cosh

MNN_PUBLIC VARP _Cosh(VARP x);

计算x的双曲余弦的值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Tan

MNN_PUBLIC VARP _Tan(VARP x);

计算x的正切值

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Asin

MNN_PUBLIC VARP _Asin(VARP x);

计算x的反正弦值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Asinh

MNN_PUBLIC VARP _Asinh(VARP x);

计算x的反双曲正弦的值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Acos

MNN_PUBLIC VARP _Acos(VARP x);

计算x的反余弦值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Acosh

MNN_PUBLIC VARP _Acosh(VARP x);

计算x的反双曲余弦的值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Atan

MNN_PUBLIC VARP _Atan(VARP x);

计算x的反正切函数

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Atanh

MNN_PUBLIC VARP _Atanh(VARP x);

计算x的双曲反正切的值

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Reciprocal

MNN_PUBLIC VARP _Reciprocal(VARP x);

计算x的倒数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Log1p

MNN_PUBLIC VARP _Log1p(VARP x);

计算(1 + x)的自然对数

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Gelu

MNN_PUBLIC VARP _Gelu(VARP x);

计算x的高斯误差线性单元激活函数

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Tanh

MNN_PUBLIC VARP _Tanh(VARP x);

计算x的双曲正切函数

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Sigmoid

MNN_PUBLIC VARP _Sigmoid(VARP x);

计算x的神经元的非线性作用函数

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Erf

MNN_PUBLIC VARP _Erf(VARP x);

计算x的高斯误差值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Erfc

MNN_PUBLIC VARP _Erfc(VARP x);

计算x的互补误差函数的值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Erfinv

MNN_PUBLIC VARP _Erfinv(VARP x);

x的逆函数的值

参数：

  • x 一个变量，Halide_Type_Int或Halide_Type_Float类型之一

返回：x相同类型的变量

_Expm1

MNN_PUBLIC VARP _Expm1(VARP x);

计算((x指数)- 1)的值

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_Hardswish

MNN_PUBLIC VARP _Hardswish(VARP x);

元素x的Hardswish神经网络激活函数

参数：

  • x Halide_Type_Float类型的变量

返回：x相同类型的变量

_ReduceSum

MNN_PUBLIC VARP _ReduceSum(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度上元素的和，沿轴中给定的维度减少input_variable。除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMean

MNN_PUBLIC VARP _ReduceMean(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度元素的平均值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMax

MNN_PUBLIC VARP _ReduceMax(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量跨维元素的最大值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMin

MNN_PUBLIC VARP _ReduceMin(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量跨维元素的最小值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceProd

MNN_PUBLIC VARP _ReduceProd(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度上元素的乘积，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceAny

MNN_PUBLIC VARP _ReduceAny(VARP input_variable, INTS axis = {}, bool keepDims = false);

跨变量的维度计算元素的“逻辑或”的值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceAll

MNN_PUBLIC VARP _ReduceAll(VARP input_variable, INTS axis = {}, bool keepDims = false);

跨变量的维度计算元素的“逻辑和”的值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceSumMutable

MNN_PUBLIC VARP _ReduceSumMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度上元素的和，沿轴中给定的维度减少input_variable。除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量，是可变的

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMeanMutable

MNN_PUBLIC VARP _ReduceMeanMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度元素的平均值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMaxMutable

MNN_PUBLIC VARP _ReduceMaxMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量跨维元素的最大值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceMinMutable

MNN_PUBLIC VARP _ReduceMinMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量跨维元素的最大值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceProdMutable

MNN_PUBLIC VARP _ReduceProdMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

计算变量各维度上元素的乘积，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceAnyMutable

MNN_PUBLIC VARP _ReduceAnyMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

跨变量的维度计算元素的“逻辑或”的值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_ReduceAllMutable

MNN_PUBLIC VARP _ReduceAllMutable(VARP input_variable, INTS axis = {}, bool keepDims = false);

跨变量的维度计算元素的“逻辑和”的值，沿轴中给定的维度减少input_variable，除非keepdim为真，否则变量在轴上的每一项的排名都会减少1。如果keepdim为true，则缩减后的维度保留长度为1；如果axis为空，则减少所有维度，并返回具有单个元素的变量

参数：

  • input_variable 要减少的变量，应该是数值类型
  • axis 要减少的尺寸。如果为空(默认值)，则减少所有维度。必须在范围内[-rank(input_variable)， rank(input_variable))
  • keepDims 如果为true，则保留长度为1的缩减维度

返回：简化后的变量，与input_variable具有相同的类型

_Prod

MNN_PUBLIC VARP _Prod(VARP a, VARP b, std::vector<float> coeff);

计算元素积

参数：

  • a Halide_Type_Float类型的变量
  • b Halide_Type_Float类型的变量
  • coeff blob-wise系数

返回：元素积变量

_Sum

MNN_PUBLIC VARP _Sum(VARP a, VARP b, std::vector<float> coeff);

计算元素和

参数：

  • a Halide_Type_Float类型的变量
  • b Halide_Type_Float类型的变量
  • coeff blob-wise系数

返回：元素和

_Max

MNN_PUBLIC VARP _Max(VARP a, VARP b, std::vector<float> coeff);

计算元素最大值

参数：

  • a Halide_Type_Float类型的变量
  • b Halide_Type_Float类型的变量
  • coeff blob-wise系数

返回：最大值

_Sub

MNN_PUBLIC VARP _Sub(VARP a, VARP b, std::vector<float> coeff);

计算元素下标

参数：

  • a Halide_Type_Float类型的变量
  • b Halide_Type_Float类型的变量
  • coeff blob-wise系数

返回：下标元素

_EltwiseProdInt8

MNN_PUBLIC VARP _EltwiseProdInt8(VARP x, VARP y, 
                    std::vector<int8_t> x_weight, std::vector<int32_t> x_bias, std::vector<float> x_scale, std::vector<float> x_tensorScale,
                    std::vector<int8_t> y_weight, std::vector<int32_t> y_bias, std::vector<float> y_scale, std::vector<float> y_tensorScale,
                    std::vector<int8_t> output_weight, std::vector<int32_t> output_bias, std::vector<float> output_scale, std::vector<float> output_tensorScale);

在Eltwise层对x和y进行累计乘积

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • x_weight 变量x的权值
  • x_bias 变量x的偏差
  • x_scale 变量x的比例因子
  • x_tensorScale 变量x的张量比例因子
  • y_weight 变量y的权值
  • y_bias 变量y的偏差
  • y_scale 变量y的比例因子
  • y_tensorScale 变量y的张量比例因子
  • output_weight 输出数据的权值
  • output_bias 输出数据的偏差
  • output_scale 输出数据的比例因子
  • output_tensorScale 输出数据的张量比例因子

返回：VARP类型变量

_EltwiseSumInt8

MNN_PUBLIC VARP _EltwiseSumInt8(VARP x, VARP y, 
                    std::vector<int8_t> x_weight, std::vector<int32_t> x_bias, std::vector<float> x_scale, std::vector<float> x_tensorScale,
                    std::vector<int8_t> y_weight, std::vector<int32_t> y_bias, std::vector<float> y_scale, std::vector<float> y_tensorScale,
                    std::vector<int8_t> output_weight, std::vector<int32_t> output_bias, std::vector<float> output_scale, std::vector<float> output_tensorScale);

在Eltwise层对x和y进行累计求和

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • x_weight 变量x的权值
  • x_bias 变量x的偏差
  • x_scale 变量x的比例因子
  • x_tensorScale 变量x的张量比例因子
  • y_weight 变量y的权值
  • y_bias 变量y的偏差
  • y_scale 变量y的比例因子
  • y_tensorScale 变量y的张量比例因子
  • output_weight 输出数据的权值
  • output_bias 输出数据的偏差
  • output_scale 输出数据的比例因子
  • output_tensorScale 输出数据的张量比例因子

返回：VARP类型变量

_EltwiseSubInt8

MNN_PUBLIC VARP _EltwiseSubInt8(VARP x, VARP y, 
                    std::vector<int8_t> x_weight, std::vector<int32_t> x_bias, std::vector<float> x_scale, std::vector<float> x_tensorScale,
                    std::vector<int8_t> y_weight, std::vector<int32_t> y_bias, std::vector<float> y_scale, std::vector<float> y_tensorScale,
                    std::vector<int8_t> output_weight, std::vector<int32_t> output_bias, std::vector<float> output_scale, std::vector<float> output_tensorScale);

在Eltwise层对x和y进行累计求差值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • x_weight 变量x的权值
  • x_bias 变量x的偏差
  • x_scale 变量x的比例因子
  • x_tensorScale 变量x的张量比例因子
  • y_weight 变量y的权值
  • y_bias 变量y的偏差
  • y_scale 变量y的比例因子
  • y_tensorScale 变量y的张量比例因子
  • output_weight 输出数据的权值
  • output_bias 输出数据的偏差
  • output_scale 输出数据的比例因子
  • output_tensorScale 输出数据的张量比例因子

返回：VARP类型变量

_EltwiseMaxInt8

MNN_PUBLIC VARP _EltwiseMaxInt8(VARP x, VARP y, 
                    std::vector<int8_t> x_weight, std::vector<int32_t> x_bias, std::vector<float> x_scale, std::vector<float> x_tensorScale,
                    std::vector<int8_t> y_weight, std::vector<int32_t> y_bias, std::vector<float> y_scale, std::vector<float> y_tensorScale,
                    std::vector<int8_t> output_weight, std::vector<int32_t> output_bias, std::vector<float> output_scale, std::vector<float> output_tensorScale);

在Eltwise层对x和y进行累计求最大值

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • y 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • x_weight 变量x的权值
  • x_bias 变量x的偏差
  • x_scale 变量x的比例因子
  • x_tensorScale 变量x的张量比例因子
  • y_weight 变量y的权值
  • y_bias 变量y的偏差
  • y_scale 变量y的比例因子
  • y_tensorScale 变量y的张量比例因子
  • output_weight 输出数据的权值
  • output_bias 输出数据的偏差
  • output_scale 输出数据的比例因子
  • output_tensorScale 输出数据的张量比例因子

返回：VARP类型变量

_Mod

MNN_PUBLIC VARP _Mod(VARP x, VARP y);

求余函数，即x和y作除法运算后的余数

参数：

  • x 一个变量，Halide_Type_Int, Halide_Type_Float类型之一
  • y 一个变量，Halide_Type_Int, Halide_Type_Float类型之一

返回：和x类型相同的变量

_Cast

VARP _Cast(VARP x) {
    return _Cast(x, halide_type_of<T>());
};

将变量强制转换为新类型

参数：

  • x 一个变量，Halide_Type_Int, Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一

返回：与x形状相同，与dtype类型相同的变量

_Cast

MNN_PUBLIC VARP _Cast(VARP x, halide_type_t dtype);

将变量强制转换为新类型

参数：

  • x 一个变量，Halide_Type_Int, Halide_Type_Float, Halide_Type_Int64, Halide_Type_Uint8类型之一
  • dtype 目标类型，支持的dtypes列表与x相同

返回：与x形状相同，与dtype类型相同的变量

_MatMul

MNN_PUBLIC VARP _MatMul(VARP a, VARP b, bool tranposeA = false, bool tranposeB = false);

矩阵a * 矩阵b，输入必须是二维矩阵和“a”的内部维数(如果转置se_a为真，则转置后)，必须匹配"b"的外部尺寸(如果transposed_b为true则被转置)

参数：

  • a 一个表示矩阵A的变量
  • b 一个表示矩阵B的变量
  • tranposeA 如果为true，则a在乘法之前被转置，默认为false
  • tranposeB 如果为true，则b在乘法之前被转置，默认为false

返回：矩阵a * 矩阵b

_Normalize

MNN_PUBLIC VARP _Normalize(VARP x, int32_t acrossSpatial, int32_t channelShared, float eps, std::vector<float> scale);

返回x数据转换成指定的标准化的格式

参数：

  • x 输入变量
  • acrossSpatial 输入变量
  • channelShared 输入变量
  • eps 输入变量，data_format
  • scale 缩放因子

返回：x数据转换成指定的标准化的格式

_ArgMax

MNN_PUBLIC VARP _ArgMax(VARP input, int axis = 0);

返回张量坐标轴上最大值的索引

参数：

  • input 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • axis 坐标轴

返回：索引值

_ArgMin

MNN_PUBLIC VARP _ArgMin(VARP input, int axis = 0);

返回张量坐标轴上最小值的索引

参数：

  • input 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • axis 坐标轴

返回：索引值

_BatchMatMul

MNN_PUBLIC VARP _BatchMatMul(VARP x, VARP y, bool adj_x = false, bool adj_y = false);

批量相乘两个变量的切片，乘以变量x和y的所有切片(每个切片可以看作是一个批处理的一个元素)，并将单个结果安排在同一个批处理大小的单个输出变量中。每一个单独的切片都可以有选择地被伴随(伴随一个矩阵意味着转置和共轭它)将adj_x或adj_y标志设置为True，默认为False。输入变量x和y是二维或更高的形状[…]， r_x, c_x]和[…]、r_y提出)。输出变量为二维或更高的形状[…]， r_o, c_o]，其中: R_o = c_x if adj_x else r_x C_o = r_y if adj_y else c_y 计算公式为: 输出[…，:，:] =矩阵(x[…，:，:]) *矩阵(y[…]、::])

参数：

  • x 二维或更高形状[..., r_x, c_x]
  • y 二维或更高形状[..., r_x, c_x]
  • adj_x 如果为True，则连接x的切片，默认为False
  • adj_y 如果为True，则连接y的切片，默认为False

返回：3-D或更高形状[…], r_o, c_o]

_UnravelIndex

MNN_PUBLIC VARP _UnravelIndex(VARP indices, VARP dims);

返回indices中的元素在维度为dims的数组中的索引值，默认按元组的形式返回

参数：

  • indices 指定的张量保存指向输出张量的索引
  • dims 操作的维度

返回：索引

_ScatterNd

MNN_PUBLIC VARP _ScatterNd(VARP indices, VARP updates, VARP shape);

根据声明的索引，通过对声明的形状张量的零张量内的单个切片或值进行分散更新，来形成不同的张量

参数：

  • indices 指定的张量保存指向输出张量的索引
  • updates 它是声明的张量，用于保存索引的值
  • shape 它是输出张量的规定形状

返回：张量

_ScatterNd

MNN_PUBLIC VARP _ScatterNd(VARP indices, VARP updates, VARP shape, VARP input);

根据声明的索引，通过对声明的形状张量的零张量内的单个切片或值进行分散更新，来形成不同的张量

参数：

  • indices 指定的张量保存指向输出张量的索引
  • updates 它是声明的张量，用于保存索引的值
  • shape 它是输出张量的规定形状
  • input 输入的张量数据

返回：张量

_ScatterNd

MNN_PUBLIC VARP _ScatterNd(VARP indices, VARP updates, VARP shape, int reduction);

根据声明的索引，通过对声明的形状张量的零张量内的单个切片或值进行分散更新，来形成不同的张量

参数：

  • indices 指定的张量保存指向输出张量的索引
  • updates 它是声明的张量，用于保存索引的值
  • shape 它是输出张量的规定形状
  • reduction 减少数值，默认为-1

返回：张量

_ScatterNd

MNN_PUBLIC VARP _ScatterNd(VARP indices, VARP updates, VARP shape, VARP input, int reduction);

根据声明的索引，通过对声明的形状张量的零张量内的单个切片或值进行分散更新，来形成不同的张量

参数：

  • indices 指定的张量保存指向输出张量的索引
  • updates 它是声明的张量，用于保存索引的值
  • shape 它是输出张量的规定形状
  • input 输入的张量数据
  • reduction 减少数值，默认为-1

返回：张量

_ScatterElements

MNN_PUBLIC VARP _ScatterElements(VARP data, VARP indices, VARP updates, int reduction = -1);

根据updates和indices来更新data的值，并把结果返回

参数：

  • data 一个张量
  • indices 一个张量
  • updates 一个张量
  • reduction 减少数值，默认为-1

返回：更新后的data

_ScatterElements

MNN_PUBLIC VARP _ScatterElements(VARP data, VARP indices, VARP updates, VARP axis, int reduction = -1);

根据updates和indices来更新data的值，并把结果返回

参数：

  • data 一个张量
  • indices 一个张量
  • updates 一个张量
  • axis 数轴，表示在行还是列进行操作
  • reduction 减少数值，默认为-1

返回：更新后的data

_OneHot

MNN_PUBLIC VARP _OneHot(VARP indices, VARP depth, VARP onValue, VARP offValue, int axis = -1);

独热编码，一般是在有监督学习中对数据集进行标注时候使用的，指的是在分类问题中，将存在数据类别的那一类用X表示，不存在的用Y表示，这里的X常常是1，Y常常是0

参数：

  • indices 输入的张量
  • depth 一个标量，用于定位维度的深度
  • onValue 定义在indices[j] = i 时填充输出值的标量
  • offValue 定义在indices[j] != i 时填充输出值的标量
  • axis 要填充的轴，默认为-1

返回：编码数据

_BroadcastTo

MNN_PUBLIC VARP _BroadcastTo(VARP a, VARP shape);

利用广播将原始矩阵成倍增加

参数：

  • a 广播的张量
  • shape 期望输出的形状

返回：矩阵

_LinSpace

MNN_PUBLIC VARP _LinSpace(VARP start, VARP stop, VARP num);

创建一个等差数列

参数：

  • start 数据的起始点，即区间的最小值
  • stop 数据的结束点，即区间的最大值
  • num 数据量，可以理解成分割了多少份

返回：等差数列

_RandomUnifom

MNN_PUBLIC VARP _RandomUnifom(VARP shape, halide_type_t dtype, float low = 0.0f, float high = 1.0f, int seed0 = 0, int seed1 = 0);

获取随机数

参数：

  • shape 输入数据的形状
  • dtype 目标类型
  • low 随机数的最小区间值
  • high 随机数的最大区间值
  • seed0 随机因子
  • seed1 随机因子

返回：dtype类型的随机数

_CumSum

MNN_PUBLIC VARP _CumSum(VARP x, int axis, bool exclusive = false, bool reverse = false);

计算元素x在axis坐标轴的累加值

参数：

  • x 输入参数
  • axis 坐标轴
  • exclusive 默认为false
  • reverse 是否逆向，默认为false

返回：和x相同类型的变量

_CumProd

MNN_PUBLIC VARP _CumProd(VARP x, int axis);

计算x在axis坐标轴的累计乘积

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一
  • axis 坐标轴

返回：和x相同类型的变量

_Svd

MNN_PUBLIC VARPS _Svd(VARP x);

奇异值分解，降维算法中的特征分解

参数：

  • x 一个变量，Halide_Type_Float, Halide_Type_Int类型之一

返回：和x相同类型的变量

_Histogram

MNN_PUBLIC VARP _Histogram(VARP x, int bin, int min, int max, int channel = -1);

直方图函数

参数：

  • x 待统计的数据
  • bin 指定统计的区间个数
  • min 统计范围最小值
  • max 统计范围最大值
  • channel通道，默认为-1

返回：和x相同类型的变量

Clone this wiki locally