Skip to content
wangzhaode edited this page Feb 16, 2023 · 1 revision

numpy

module numpy

numpy模块提供了基础的数值计算函数,在expr模块基础上提供了兼容了numpy的API

numpy兼容参数是指为了兼容numpy的api,但是在MNN.numpy中无效的参数

用法注意:

  • 此numpy模块并非完整支持numpy的所有API,当遇到函数或用法不支持时可以尝试用其他函数拼凑;
  • 此numpy模块数值计算基于MNN.expr封装,计算过程会有创建Op的开销,对于较小规模的Var计算性能相比numpy会有比较明显的劣势,因此尽量避免使用此模块处理小规模数据;
  • Var的存取可以利用expr.saveexpr.load_as_list实现;

numpy Types


numpy.dtype

描述Var的数据类型,是expr.dtype的封装

  • 类型:Enum
  • 枚举值:
    • uint8
    • int32
    • int64
    • float32
    • float64

concatenate(args, axis=0, out=None, dtype=None, casting="same_kind")

作用等同与 numpy 中的 np.concatenate 函数,沿指定轴连接输入的Var

参数:

  • args:Var序列 被连接的变量
  • axis:int 指定连接的轴
  • out:numpy兼容参数 默认为None
  • dtype:numpy兼容参数 默认为None
  • casting:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]], dtype=int32)

pad(array, pad_width, mode='constant')

作用等同与 numpy 中的 np.pad 函数,对输入变量的边沿按照指定规则进行扩充。

参数:

  • array:Var 将要扩充的变量
  • pad_width:Var,扩充的数目,一共为维度的2倍 扩充的数目,一共为维度的2倍,分别对应一个维度前后
  • mode:{'constant', 'reflect', 'symmetric'} 填充的方式

返回:扩充后得到的变量

返回类型:Var

示例

a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'constant')
array([0, 0, 1, 2, 3, 4, 5, 0, 0, 0], dtype=int32)
>>> np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2], dtype=int32)
>>> np.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3], dtype=int32)

sign(x)

作用等同与 numpy 中的 np.sign 函数,按位获取符号,正数返回1负数返回-1。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.sign([1.,-2.])
array([ 1., -1.], dtype=float32)

asscalar(a)

作用等同与 numpy 中的 np.asscalar 函数,将数据转换为scalar。

参数:

  • a:Var 输出变量的数据来源

返回:创建的Var

返回类型:Var

示例

>>> np.asscalar(np.array([24]))
24

shape(a)

作用等同与 numpy 中的 np.shape 函数,获取输入Var的形状,类型为tuple

参数:

  • a:Var 将会输出该变量的形状

返回:Var的形状

返回类型:tuple

示例

>>> a = np.ones([[2],[2]])
>>> np.shape(a)
(2, 2)

mat(a, dtype=None)

作用等同与 numpy 中的 np.mat 函数,根据指定数据,将输入数据转换为ndim=2的Var。

参数:

  • a:Var|list|tuple 输出变量的数据来源
  • dtype:dtype 重新指定输出的类型; 默认为a的数据类型

返回:创建的Var

返回类型:Var

示例

>>> np.mat([1, 2, 3, 4])
array([[1, 2, 3]])

divmod(x1, x2)

作用等同与 numpy 中的 np.divmod 函数,返回2个输入的(floordiv, mod)值。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:tuple of Var

示例

>>> np.divmod(2, 3)
(array(0, dtype=int32), array(2, dtype=int32))

zeros(shape, dtype=None, order='C')

作用等同与 numpy 中的 np.zeros 函数,创建一个指定形状,类型的Var,其全部的值都为0,是full的特例。

参数:

  • shape:[int] 指定输出的形状
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.ones((2, 2))
array([[0., 0.],
       [0., 0.]])

matrix(a, dtype=None)

作用等同与 numpy 中的 np.matrix 根据指定数据,将输入数据转换为ndim=2的Var。

参数:

  • a:Var|list|tuple 输出变量的数据来源
  • dtype:dtype 重新指定输出的类型; 默认为a的数据类型

返回:创建的Var

返回类型:Var

示例

>>> np.matrix([1, 2, 3, 4])
array([[1, 2, 3]])

round_(x)

作用等同与 numpy 中的 np.round_ 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.round_([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

ones(shape, dtype=None, order='C')

作用等同与 numpy 中的 np.ones 函数,创建一个指定形状,类型的Var,其全部的值都为1,是full的特例。

参数:

  • shape:[int] 指定输出的形状
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.ones((2, 2))
array([[1., 1.],
     [1., 1.]])

expand_dims(x, axis)

作用等同与 numpy 中的 np.expand_dims 函数,扩展输入的形状,在指定位置插入一个新维度,是expr.unsqueeze的封装。

参数:

  • x:Var 需要扩展维度的变量
  • axis:int 插入新维度的位置

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([1, 2])
>>> b = np.expand_dims(a, axis=0)
>>> a.shape
[2]
>>> b.shape
[1,2]

rollaxis(a, axis, start=0)

作用等同与 numpy 中的 np.rollaxis 函数,将Var的指定维度滚动到目标位置。

参数:

  • a:Var 将会滚动该变量的维度
  • axis:int 指定要滚动的维度
  • start:int 滚动维度的目标位置

返回:滚动维度后的MNN.Var

返回类型:Var

示例

>>> a = np.ones((3,4,5,6))
>>> np.rollaxis(a, 3, 1).shape
(3, 6, 4, 5)

asarray(a, dtype=None, order=None)

作用等同与 numpy 中的 np.asarray 根据指定数据,将输入数据转换为一个Var。

参数:

  • a:ndarray 输出变量的数据来源
  • dtype:dtype 重新指定输出的类型; 默认为a的数据类型
  • order:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.asarray([1, 2, 3])
array([1, 2, 3])

repeat(a, repeats, axis=None)

作用等同与 numpy 中的 np.repeat 函数,将输入变量的元素重复指定次数。

参数:

  • A:Var 被复制的Var
  • repeats:int 复制的次数
  • axis:numpy兼容参数 默认为None

返回:复制得到的Var

返回类型:Var

示例

>>> a = np.array([0, 1, 2])
>>> np.repeat(a, 2)
array([0, 0, 1, 1, 2, 2], dtype=int32)

zeros_like(a, dtype=None, order='K', subok=True, shape=None)

作用等同与 numpy 中的 np.zeros_like 函数,创建一个与指定Var的形状类型相同的Var,其全部的值为0, 为full_like的特例。

参数:

  • a:Var 输出Var的形状和数据类型与该Var相同
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None
  • shape:[int] 重新指定输出的形状

返回:创建的Var

返回类型:Var

示例

>>> a = np.empty([2,2])
>>> np.ones_like(a)
array([[0., 0.],
     [0., 0.]])

clip(x, a_min, a_max)

作用等同与 numpy 中的 np.clip 函数, 对元素按照最小最大的范围进行约束。

参数:

  • x:Var 参与计算的变量
  • a_min:scalar 约束的最小值
  • a_max:scalar 约束的最大值

返回:计算得到的变量

返回类型:tuple of Var

示例

>>> np.clip(np.array([-3., -1., 3.]), -2., 2.)
array([-2., -1.,  2.], dtype=float32)

sin(x)

作用等同与 numpy 中的 np.sin 函数,按元素计算正弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.sin([1.,2.])
array([0.84147096, 0.9092974 ], dtype=float32)

cos(x)

作用等同与 numpy 中的 np.cos 函数,按元素计算余弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.cos([1.,2.])
array([ 0.5403023 , -0.41614684], dtype=float32)

count_nonzero(a, axis=None, keepdims=False)

作用等同与 numpy 中的 np.count_nonzero 函数,计算非0元素的数目。

参数:

  • a:Var 将要计数的变量
  • axis:int 计数的轴
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> np.count_nonzero(np.eye(4))
4

cbrt(x)

作用等同与 numpy 中的 np.cbrt 函数,按元素计算立方根。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.cbrt([1.,2.])
array([1., 1.2599211], dtype=float32)

ptp(a, axis=None)

作用等同与 numpy 中的 np.ptp 函数,返回沿axis轴的数值范围(最大值减去最小值)。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.ptp(a) 
3
>>> np.ptp(a, axis=0) 
array([2, 2], dtype=int32)

where(indices, shape, order='C')

作用等同与 numpy 中的 np.unravel_index 函数,将平面索引转换为坐标索引; 比如在形状为[3,4]的坐标中,平面索引6代表拉平后的第六个元素,对应的坐标索引为第2行第3列,所以坐标索引为(2,3)

参数:

  • indices:Var 平面索引值
  • shape:Var 坐标索引对应的形状
  • order:numpy兼容参数 默认为None

返回:计算得到的坐标索引各轴的坐标值

返回类型:Var数组

示例

>>> np.unravel_index([22, 41, 37], (7,6))
[array([3, 6, 6], dtype=int32), array([4, 5, 1], dtype=int32)]

empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

作用等同与 numpy 中的 np.empty_like 函数,创建一个与指定Var相同的未初始化Var变量,是expr.placeholder的封装。

参数:

  • prototype:Var 输出Var的形状和数据类型与该Var相同
  • dtype:dtype 重新指定输出的数据类型
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None
  • shape:[int] 重新指定输出的形状

返回:创建的空Var

返回类型:Var

示例

a = ([1,2,3], [4,5,6])
>>> x = np.empty_like(a)

arccos(x)

作用等同与 numpy 中的 np.arccos 函数,按元素计算反余弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arccos([0.5, 1.0])
array([1.0471975, 0.       ], dtype=float32)

fabs(x)

作用等同与 numpy 中的 np.fabs 函数,求输入的绝对值, 是expr.fabs的封装。

参数:

  • x:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.fabs([-1., 2.])
array([1., 2.], dtype=float32)

equal(a1, a2)

作用等同与 numpy 中的 np.equal 函数,判断一个变量是否等于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.equal([2, 2], [1, 2])
array([0, 1], dtype=int32)

float_power(x1, x2)

作用等同与 numpy 中的 np.float_power 函数,对输入的2个变量求指数, 是expr.power的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.float_power(2., 3.)
array(8., dtype=float32)

arctanh(x)

作用等同与 numpy 中的 np.arctanh 函数,按元素计算双曲反正切值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arctanh([0.5, 0.8])
array([0.54930615, 1.0986123 ], dtype=float32)

arcsin(x)

作用等同与 numpy 中的 np.arcsin 函数,按元素计算反正弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arcsin([0.5, 1.0])
array([0.5235988, 1.5707963], dtype=float32)

abs(x)

作用等同与 numpy 中的 np.abs 函数,求输入的绝对值, 是expr.abs的封装。

参数:

  • x:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.abs([-1, 2])
array([1, 2], dtype=int32)

var(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.var 函数,返回沿axis轴的方差。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.var(a)
1.25
>>> np.var(a, axis=0) 
array([1., 1.], dtype=float32)

multiply(x1, x2)

作用等同与 numpy 中的 np.multiply 函数,对输入的2个变量相乘, 是expr.multiply的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.multiply(13, 17)
array(221, dtype=int32)

arcsinh(x)

作用等同与 numpy 中的 np.arcsinh 函数,按元素计算双曲反正弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arcsinh([0.5, 1.0])
array([0.4812118, 0.8813736], dtype=float32)

array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, like=None)

作用等同与 numpy 中的 np.array 根据指定数据,类型创建一个Var。

参数:

  • object:ndarray 输出变量的数据来源
  • dtype:dtype 指定输出的类型; 默认为object的类型
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.array([1, 2, 3])
array([1, 2, 3])

vdot(a, b)

作用等同与 numpy 中的 np.vdot 函数,对输入的2个变量做点乘。 根据ab的维度进行如下计算:

  • 如果都是0维,等价于乘法
  • 如果都是1维,等价于秋内积,即按位乘之后求和
  • 如果都是2维,等价于矩阵乘法
  • 如果a是N维,b是1维,则对最后一维度求内积
  • 如果a是N维,b是M维(M>=2),则对a最后一维和b的倒数第二维度求内积

参数:

  • a:Var 参与计算的变量
  • b:Var 参与计算的变量
  • out:numpy兼容参数 默认为None

返回:计算得到的变量

返回类型:Var

示例

>>> np.vdot(3, 4)
12
>>> np.vdot([[1, 0], [0, 1]], [[4, 1], [2, 2]])
array([[4, 1],
     [2, 2]], dtype=int32)

asfarray(a, dtype=np.float32)

作用等同与 numpy 中的 np.asfarray 根据指定数据,将输入数据转换为一个类型为float的Var。

参数:

  • a:ndarray 输出变量的数据来源
  • dtype:dtype 重新指定输出的类型; 默认为np.float32

返回:创建的Var

返回类型:Var

示例

>>> np.asfarray([1, 2, 3])
array([1., 2., 3.])

remainder(x1, x2)

作用等同与 numpy 中的 np.remainder 函数,对输入的2个变量求模, 是expr.mod的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.remainder(13, 5)
array(3, dtype=int32)

amax(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.amax 函数,返回沿axis轴的最大值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.amax(a) 
3
>>> np.amin(a, axis=0) 
array([2, 3], dtype=int32)

power(x1, x2)

作用等同与 numpy 中的 np.power 函数,对输入的2个变量求指数, 是expr.power的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.power(2., 3.)
array(8., dtype=float32)

nanmax(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanmax 函数,返回沿axis轴的最大值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.nanmax(a) 
3
>>> np.nanmax(a, axis=0) 
array([2, 3], dtype=int32)

empty(shape, dtype=float32, order='C')

作用等同与 numpy 中的 np.empty 函数,创建一个指定形状未初始化的Var变量,是expr.placeholder的封装。

参数:

  • shape:tuple 指定输出的形状
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None

返回:创建的空Var

返回类型:Var

示例

>>> x = np.empty([2, 2])
x.write([1.,2.,3.,4.])

arange([start, ]stop, [step, ], dtype=None)

作用等同与 numpy 中的 np.arange 根据指定数据,类型创建一个指定范围和步长的Var。

参数:

  • start:int|float 输出变量的范围起点
  • stop:int|float 输出变量的范围终点
  • step:int|float 输出变量的范围步长
  • dtype:dtype 指定输出的类型; 默认为stop的类型

返回:创建的Var

返回类型:Var

示例

>>> np.arange(0, 5, 1)
array([0, 1, 2, 3, 4])

log2(x)

作用等同与 numpy 中的 np.log2 函数,按元素计算log2(x)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.log2([1.,2.])
array([0., 1.], dtype=float32)

where(condition, x=None, y=None)

作用等同与 numpy 中的 np.where 函数,根据给定条件返回两个输入的元素。

参数:

  • condition:Var 条件变量
  • x:Var 参与取值的变量
  • y:Var 参与取值的变量

返回:计算得到的变量

返回类型:Var

示例

>>> a = np.arange(10)
>>> np.where(a < 5, a, a*10)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90], dtype=int32)

all(a, axis=None, out=None, keepdims=None)

作用等同与 numpy 中的 np.all 函数,判断是否所有元素都为真(不为0)。

参数:

  • a:Var 输入的变量
  • axis:list 判断的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.all([1, 0, 1])
False
>>> np.all([1, -1, 1])
True

round(x)

作用等同与 numpy 中的 np.round 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.round([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

divide(x1, x2)

作用等同与 numpy 中的 np.divide 函数,对输入的2个变量相除, 是expr.divide的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.divide(13., 17.)
array(0.7647059, dtype=float32)

average(a, axis=None, weights=None, returned=False)

作用等同与 numpy 中的 np.average 函数,返回沿axis轴的平均值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.average(a)
1.5
>>> np.average(a, axis=0) 
array([1., 2.], dtype=float32)

trunc(x)

作用等同与 numpy 中的 np.trunc 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.trunc([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

nanprod(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanprod 函数,沿着指定维度,对数据求乘积。

参数:

  • x:Var 输入的变量
  • axis:list 计算的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.nanprod([1,2,3,4])
24

std(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.std 函数,返回沿axis轴的标准差。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.std(a)
1.1180340051651
>>> np.std(a, axis=0) 
array([0.99999994, 0.99999994], dtype=float32)

bitwise_xor(x1, x2)

作用等同与 numpy 中的 np.bitwise_xor 函数,对输入的2个变量按位与, 是expr.bitwise_xor的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.bitwise_xor(13, 17)
array(28, dtype=int32)

dot(a, b, out=None)

作用等同与 numpy 中的 np.dot 函数,对输入的2个变量做点乘。 根据ab的维度进行如下计算:

  • 如果都是0维,等价于乘法
  • 如果都是1维,等价于秋内积,即按位乘之后求和
  • 如果都是2维,等价于矩阵乘法
  • 如果a是N维,b是1维,则对最后一维度求内积
  • 如果a是N维,b是M维(M>=2),则对a最后一维和b的倒数第二维度求内积

参数:

  • a:Var 参与计算的变量
  • b:Var 参与计算的变量
  • out:numpy兼容参数 默认为None

返回:计算得到的变量

返回类型:Var

示例

>>> np.dot(3, 4)
12
>>> np.dot([[1, 0], [0, 1]], [[4, 1], [2, 2]])
array([[4, 1],
     [2, 2]], dtype=int32)

moveaxis(a, source, destination)

作用等同与 numpy 中的 np.moveaxis 函数,移动Var的指定维度到指定位置。

参数:

  • a:Var 将会移动该变量的维度
  • source:int 需要移动的维度
  • destination:int 移动的目标位置

返回:形状为newshape的MNN.Var

返回类型:Var

示例

>>> a = np.ones((3, 4, 5))
>>> np.moveaxis(a, 0, -1).shape
(4, 5, 3)

flatnonzero(a)

作用等同与 numpy 中的 np.flatnonzero 函数,平铺之后输出非零元素的索引。

参数:

  • a:Var 将要搜索的变量

返回:搜索得到的变量

返回类型:tuple of Var

示例

>>> x = np.arange(6).reshape(2,3)
>>> np.flatnonzero(x>1)
array([2, 3, 4, 5], dtype=int32)

copysign(x1, x2)

作用等同与 numpy 中的 np.copysign 函数,将第二个输入的符号作用到第一个输入上并返回。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.copysign(13, -1)
array(-13, dtype=int32)

atleast_3d(*arys)

作用等同与 numpy 中的 np.atleast_2d 函数,将输入Var的维度变为至少为3,如果输入为标量或1/2维变量则输出为3维变量,否则保持维度不变。

参数:

  • *arys:Var 多个需要转换的变量

返回:转置后的 MNN.Var

返回类型:Var

示例

>>> np.atleast_1d(3, [2,3])
[array([[[3]]], dtype=int32), array([[[2],[3]]], dtype=int32)]

sinc(x)

作用等同与 numpy 中的 np.sinc 函数,对于输入x进行如下计算sin(x*PI)/(x*PI)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.sinc([1.,2.])
array([-2.7827534e-08,  2.7827534e-08], dtype=float32)

modf(x)

作用等同与 numpy 中的 np.modf 函数, 按元素返回输入的整数部分和小数部分。

参数:

  • x:Var 参与计算的变量

返回:计算得到的变量

返回类型:tuple of Var

示例

>>> np.modf([2.1, -1.2])
(array([ 0.0999999 , -0.20000005], dtype=float32), array([ 2., -2.], dtype=float32))

nanmean(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanmean 函数,返回沿axis轴的平均值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.nanmean(a)
1.5
>>> np.nanmean(a, axis=0) 
array([1., 2.], dtype=float32)

cosh(x)

作用等同与 numpy 中的 np.cosh 函数,按元素计算双曲余弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.cosh([1.,2.])
array([1.5430807, 3.7621956], dtype=float32)

log1p(x)

作用等同与 numpy 中的 np.log1p 函数,按元素计算log(x+1)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.log1p([1.,2.])
array([0.6931472, 1.0986123], dtype=float32)

maximum(x1, x2)

作用等同与 numpy 中的 np.maximum 函数,输入2个变量中的最大值, 是expr.maximum的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.maximum(13, 17)
array(17, dtype=int32)

ceil(x)

作用等同与 numpy 中的 np.ceil 函数,按位对小数部分进位。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.ceil([1.2, 3.5, 4.7])
array([2., 4., 5.], dtype=float32)

log10(x)

作用等同与 numpy 中的 np.log10 函数,按元素计算log10(x)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.log10([1.,2.])
array([0., 0.30102998], dtype=float32)

inner(a, b)

作用等同与 numpy 中的 np.inner 函数,对输入的2个变量做内积,即按位乘后求和。

参数:

  • a:Var 参与计算的变量
  • b:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.inner([1,2,3], [0,1,0])
2

array_split(ary, indices_or_sections, axis=0)

作用等同与 numpy 中的 np.array_split 函数,将一个Var拆分成为多个子变量。 该实现与split等价;与numpy的区别是当分块数目无法整除时不会保留余数部分。

参数:

  • ary:Var 被拆分的Var
  • indices_or_sections:list 拆分的块数或者块大小
  • axis:int 拆分的维度

返回:拆分得到的Var

返回类型:Var 数组

示例

>>> x = np.arange(9.0)
>>> np.array_split(x, 3)
[array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]

greater(a1, a2)

作用等同与 numpy 中的 np.greater 函数,判断一个变量是否大于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.greater([2, 1], [1, 2])
array([1, 0], dtype=int32)

tile(A, reps)

作用等同与 numpy 中的 np.tile 函数,将输入变量复制指定次数构造一个新变量。

参数:

  • A:Var 被复制的Var
  • reps:int 复制的次数

返回:复制得到的Var

返回类型:Var

示例

>>> a = np.array([0, 1, 2])
>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2], dtype=int32)

argwhere(a)

作用等同与 numpy 中的 np.argwhere 函数,输出非零元素的索引。

参数:

  • a:Var 将要搜索的变量

返回:搜索得到的变量

返回类型:Var

示例

>>> x = np.arange(6).reshape(2,3)
>>> np.argwhere(x>1)
array([[0, 2],
     [1, 0],
     [1, 1],
     [1, 2]], dtype=int32)

ones_like(a, dtype=None, order='K', subok=True, shape=None)

作用等同与 numpy 中的 np.ones_like 函数,创建一个与指定Var的形状类型相同的Var,其全部的值为1, 为full_like的特例。

参数:

  • a:Var 输出Var的形状和数据类型与该Var相同
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None
  • shape:[int] 重新指定输出的形状

返回:创建的Var

返回类型:Var

示例

>>> a = np.empty([2,2])
>>> np.ones_like(a)
array([[1., 1.],
     [1., 1.]])

bitwise_and(x1, x2)

作用等同与 numpy 中的 np.bitwise_and 函数,对输入的2个变量按位与, 是expr.bitwise_and的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.bitwise_and(13, 17)
array(1, dtype=int32)

lexsort(a, axis=-1)

作用等同与 numpy 中的 np.lexsort 函数,对输入变量排序。

参数:

  • a:Var 将要排序的变量
  • axis:int 排序的维度

返回:排序后得到的变量

返回类型:Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.lexsort(a)  
array([[1, 4],
     [1, 3]], dtype=int32)

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

作用等同与 numpy 中的 np.linspace 根据指定数据,类型创建一个指定范围(等差)和数目的Var。

参数:

  • start:int|float 输出变量的范围起点
  • stop:int|float 输出变量的范围终点
  • num:int 输出数据总数
  • endpoint:bool 目前仅支持endpoint=False
  • retstep:,返回值是否包含步长;如果包含则返回(Var 返回值是否包含步长;如果包含则返回(Var, step)
  • dtype:dtype 指定输出的类型; 默认为stop的类型
  • axis:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.linspace(0, 10, 2, False, True)
(array([0, 5], dtype=int32), 5.0)

nansum(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.nansum 函数,沿着指定维度,对数据求和。

参数:

  • x:Var 输入的变量
  • axis:list 计算的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.nansum([1,2,3,4])
10

expm1(x)

作用等同与 numpy 中的 np.expm1 函数,按元素计算exp(x)-1

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.expm1([1.,2.])
array([1.7182794, 6.388731 ], dtype=float32)

atleast_2d(*arys)

作用等同与 numpy 中的 np.atleast_2d 函数,将输入Var的维度变为至少为2,如果输入为标量或1维变量则输出为2维变量,否则保持维度不变。

参数:

  • *arys:Var 多个需要转换的变量

返回:转置后的 MNN.Var

返回类型:Var

示例

>>> np.atleast_1d(3, [2,3])
[array([[3]], dtype=int32), array([[2, 3]], dtype=int32)]

broadcast_to(array, shape)

作用等同与 numpy 中的 np.broadcast_to 函数,将输入广播到指定形状。

参数:

  • array:Var 需要广播的变量
  • shape:[int] 广播的形状

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([1, 2, 3])
>>> np.broadcast_to(a, (3,3))
array([[1, 2, 3],
     [1, 2, 3],
     [1, 2, 3]], dtype=int32)

fmin(x1, x2)

作用等同与 numpy 中的 np.fmin 函数,输入2个变量中的最小值, 是expr.minimum的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.fmin(13., 17.)
array(13., dtype=float32)

min(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.min 函数,返回沿axis轴的最小值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.min(a) 
0
>>> np.min(a, axis=0) 
array([0, 1], dtype=int32)

geomspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

作用等同与 numpy 中的 np.geomspace 根据指定数据,类型创建一个指定范围(指数等差)和数目的Var。

参数:

  • start:int|float 输出变量的范围起点
  • stop:int|float 输出变量的范围终点
  • num:int 输出数据总数
  • endpoint:bool 是否包含终点元素,目前仅支持endpoint=False
  • retstep:(Var, step) 返回值是否包含步长;如果包含则返回(Var, step)
  • dtype:dtype 指定输出的类型; 默认为stop的类型
  • axis:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.geomspace(1., 10., 4, False)
array([1.       , 1.7782794, 3.1622777, 5.6234136], dtype=float32)

add(x1, x2)

作用等同与 numpy 中的 np.add 函数,对输入的2个变量相加, 是expr.add的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.add(13, 17)
array(30, dtype=int32)

nonzero(a)

作用等同与 numpy 中的 np.nonzero 函数,输出非零元素的索引。

参数:

  • a:Var 将要搜索的变量

返回:搜索得到的变量

返回类型:tuple of Var

示例

>>> x = np.arange(6).reshape(2,3)
>>> np.nonzero(x>1)
(array([0, 1, 1, 1], dtype=int32), array([2, 0, 1, 2], dtype=int32))

full(shape, fill_value, dtype=None, order='C')

作用等同与 numpy 中的 np.full 函数,创建一个指定形状,类型的Var,其全部的值为指定数据。

参数:

  • shape:[int] 指定输出的形状
  • fill_value:scalar 指定输出的填充值
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.full((2, 2), 10)
array([[10, 10],
     [10, 10]])

copy(a, order='K', subok=False)

作用等同与 numpy 中的 np.copy 函数,创建一个输入Var的拷贝。

参数:

  • a:Var 输出Var的与该Var相同
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> a = np.ones([2,2])
>>> np.copy(a)
array([[1., 1.],
     [1., 1.]])

subtract(x1, x2)

作用等同与 numpy 中的 np.subtract 函数,对输入的2个变量相减, 是expr.subtract的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.subtract(2., 3.)
array(-1., dtype=float32)

atleast_1d(*arys)

作用等同与 numpy 中的 np.atleast_1d 函数,将输入Var的维度变为至少为1,如果输入为标量则输出为1维变量,否则保持维度不变。

参数:

  • *arys:Var 多个需要转换的变量

返回:转置后的 MNN.Var

返回类型:Var

示例

>>> np.atleast_1d(3, [2,3])
[array([3], dtype=int32), array([2, 3], dtype=int32)]

nanstd(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanstd 函数,返回沿axis轴的标准差。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.nanstd(a)
1.1180340051651
>>> np.nanstd(a, axis=0) 
array([0.99999994, 0.99999994], dtype=float32)

hsplit(ary, indices_or_sections)

作用等同与 numpy 中的 np.vsplit 函数,沿着axis=0, 将一个Var拆分成为多个子变量。

参数:

  • ary:Var 被拆分的Var
  • indices_or_sections:list 拆分的块数或者块大小

返回:拆分得到的Var

返回类型:Var 数组

示例

>>> x = np.arange(16.0).reshape(2, 2, 4)
>>> np.vsplit(x, 2)
[array([[[0., 1., 2., 3.],
       [4., 5., 6., 7.]]], dtype=float32),
 array([[[ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]]], dtype=float32)]

column_stack(tup)

作用等同与 numpy 中的 np.column_stack 函数,把1维Var作为列stack成2位变量。

参数:

  • tup:Var序列 被连接的变量

返回:创建的Var

返回类型:Var

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
     [2, 3],
     [3, 4]])

dstack(tup)

作用等同与 numpy 中的 np.dstack 函数,深度顺序连接Var序列。

参数:

  • tup:Var序列 被连接的变量

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.dstack((a, b))
array([[[1, 2]],
      [[2, 3]],
      [[3, 4]]])

reciprocal(x)

作用等同与 numpy 中的 np.reciprocal 函数,按位取倒数。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.reciprocal([1.,2.])
array([1. , 0.5], dtype=float32)

positive(x)

作用等同与 numpy 中的 np.positive 函数,按位取正,相当于拷贝。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.positive([1.,-2.])
array([1., -2.], dtype=float32)

array_equal(a1, a2)

作用等同与 numpy 中的 np.array_equiv 函数,判断2个变量是否完全相等。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:bool

示例

>>> np.array_equiv([1, 2], [1, 2])
True

square(x)

作用等同与 numpy 中的 np.square 函数,求输入的平方, 是expr.square的封装。

参数:

  • x:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.square(13)
array(160, dtype=int32)

sinh(x)

作用等同与 numpy 中的 np.sinh 函数,按元素计算双曲正弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.sinh([1.,2.])
array([1.1752012, 3.6268604], dtype=float32)

greater_equal(a1, a2)

作用等同与 numpy 中的 np.greater_equal 函数,判断一个变量是否大于等于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.greater_equal([2, 2], [1, 2])
array([1, 1], dtype=int32)

tanh(x)

作用等同与 numpy 中的 np.tanh 函数,按元素计算双曲正切值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.tanh([1.,2.])
array([0.7616205, 0.9640294], dtype=float32)

floor_divide(x1, x2)

作用等同与 numpy 中的 np.floor_divide 函数,对输入的2个变量相除并舍去小数部分, 是expr.floordiv的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.floor_divide(13., 17.)
array(0., dtype=float32)

matmul(a, b)

作用等同与 numpy 中的 np.matmul 函数,对输入的2个变量做矩阵乘。

参数:

  • a:Var 参与计算的变量
  • b:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.matmul([[1, 0], [0, 1]], [[4, 1], [2, 2]])
array([[4, 1],
     [2, 2]], dtype=int32)

split(ary, indices_or_sections, axis=0)

作用等同与 numpy 中的 np.split 函数,将一个Var拆分成为多个子变量。

参数:

  • ary:Var 被拆分的Var
  • indices_or_sections:list 拆分的块数或者块大小
  • axis:int 拆分的维度

返回:拆分得到的Var

返回类型:Var 数组

示例

>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]

argsort(a, axis=-1, kind=None, order=None)

作用等同与 numpy 中的 np.argsort 函数,对输入变量排序,输出排序后的下标索引。

参数:

  • a:Var 将要排序的变量
  • axis:int 排序的维度
  • kind:numpy兼容参数 默认为None
  • order:numpy兼容参数 默认为None

返回:排序后得到的变量

返回类型:Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.argsort(a)  
array([[0, 1],
     [1, 0]], dtype=int32)

not_equal(a1, a2)

作用等同与 numpy 中的 np.not_equal 函数,判断一个变量是否不等于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.not_equal([2, 2], [1, 2])
array([1, 0], dtype=int32)

broadcast_arrays(*args)

作用等同与 numpy 中的 np.broadcast_arrays 函数,将输入的变量相互广播。

参数:

  • *args:Var 需要广播的变量

返回:创建的Var

返回类型:Var

示例

>>> x = np.array([[1,2,3]])
>>> y = np.array([[4],[5]])
>>> np.broadcast_arrays(x, y)
[array([[1, 2, 3],
        [1, 2, 3]], dtype=int32),
 array([[4, 4, 4],
        [5, 5, 5]], dtype=int32)]

squeeze(a, axis=None)

作用等同与 numpy 中的 np.squeeze 函数,在指定位置移除一个维度,是expr.squeeze的封装。

参数:

  • x:Var 需要移除维度的变量
  • axis:int 移除维度的位置

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[[0], [1], [2]]])
>>> b = np.squeeze(a, axis=0)
>>> a.shape
[1,3,1]
>>> b.shape
[3,1]

argmax(a, axis=None, out=None)

作用等同与 numpy 中的 np.argmax 函数,输出沿axis最大值的下标。

参数:

  • a:Var 将要搜索的变量
  • axis:int 搜索的维度
  • out:numpy兼容参数 默认为None

返回:搜索得到的变量

返回类型:int or Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.argmax(a)  
1
>>> np.argmax(a, 0)  
array([1, 0], dtype=int32)

minimum(x1, x2)

作用等同与 numpy 中的 np.minimum 函数,输入2个变量中的最小值, 是expr.minimum的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.minimum(13, 17)
array(13, dtype=int32)

signbit(x)

作用等同与 numpy 中的 np.signbit 函数,输入是否有负符号(小于0)。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.signbit([1.,-2.])
array([0, 1], dtype=int32)

around(x)

作用等同与 numpy 中的 np.around 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.around([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

meshgrid(*xi, copy=True, sparse=False, indexing='xy')

作用等同与 numpy 中的 np.meshgrid 根据坐标值返回坐标矩阵。

参数:

  • *xi:Var 一维坐标值
  • copy:bool 是否拷贝所有的值到输出
  • sparse:bool 是否返回全部坐标矩阵
  • indexing:{‘xy’, ‘ij’} ‘ij’}`,'xy'会翻转坐标轴

返回:创建的Var

返回类型:Var

示例

nx, ny = (3, 2)
>>> x = np.linspace(0., 1., nx, False)
>>> y = np.linspace(0., 1., ny, False)
>>> xv, yv = np.meshgrid(x, y)
xv
array([[0.        , 0.33333334, 0.6666667 ],
     [0.        , 0.33333334, 0.6666667 ]], dtype=float32)
yv
array([[0. , 0. , 0. ],
     [0.5, 0.5, 0.5]], dtype=float32)

nanmin(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanmin 函数,返回沿axis轴的最小值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.nanmin(a) 
0
>>> np.nanmin(a, axis=0) 
array([0, 1], dtype=int32)

amin(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.amin 函数,返回沿axis轴的最小值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.amin(a) 
0
>>> np.amin(a, axis=0) 
array([0, 1], dtype=int32)

sqrt(x)

作用等同与 numpy 中的 np.sin 函数,按元素计算平方根。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.sqrt([1.,2.])
array([0.99999994, 1.4142134 ], dtype=float32)

sum(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.sum 函数,沿着指定维度,对数据求和。

参数:

  • x:Var 输入的变量
  • axis:[int] 计算的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.sum([1,2,3,4])
10

nanargmax(a, axis=None, out=None)

作用等同与 numpy 中的 np.nanargmax 函数,输出沿axis最大值的下标。

参数:

  • a:Var 将要搜索的变量
  • axis:int 搜索的维度
  • out:numpy兼容参数 默认为None

返回:搜索得到的变量

返回类型:int or Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.nanargmax(a)  
1
>>> np.nanargmax(a, 0)  
array([1, 0], dtype=int32)

log(x)

作用等同与 numpy 中的 np.log 函数,按元素计算log(x)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.log([1.,2.])
array([0. , 0.6931472], dtype=float32)

floor(x)

作用等同与 numpy 中的 np.floor 函数,按位舍去小数部分。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.floor([1.2, 3.5, 4.7])
array([1., 3., 4.], dtype=float32)

hypot(x1, x2)

作用等同与 numpy 中的 np.hypot 函数,输入2个变量x1x2执行计算sqrt(x1*x1+x2*x2)

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.hypot(13., 17.)
array(21.400934, dtype=float32)

vstack(tup)

作用等同与 numpy 中的 np.vstack 函数,垂直顺序连接Var序列。

参数:

  • tup:Var序列 被连接的变量

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a, b))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

bitwise_or(x1, x2)

作用等同与 numpy 中的 np.bitwise_or 函数,对输入的2个变量按位或, 是expr.bitwise_or的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.bitwise_or(13, 17)
array(29, dtype=int32)

dsplit(ary, indices_or_sections)

作用等同与 numpy 中的 np.dsplit 函数,沿着axis=2, 将一个Var拆分成为多个子变量。

参数:

  • ary:Var 被拆分的Var
  • indices_or_sections:list 拆分的块数或者块大小

返回:拆分得到的Var

返回类型:Var 数组

示例

>>> x = np.arange(16.0).reshape(2, 2, 4)
>>> np.dsplit(x, 2)
[array([[[ 0.,  1.],
         [ 4.,  5.]],
        [[ 8.,  9.],
         [12., 13.]]], dtype=float32),
 array([[[ 2.,  3.],
         [ 6.,  7.]],
        [[10., 11.],
         [14., 15.]]], dtype=float32)]

full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)

作用等同与 numpy 中的 np.full_like 函数,创建一个与指定Var的形状类型相同的Var,其全部的值为指定数据。

参数:

  • a:Var 输出Var的形状和数据类型与该Var相同
  • fill_value:scalar 指定输出的填充值
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None
  • subok:numpy兼容参数 默认为None
  • shape:[int] 重新指定输出的形状

返回:创建的Var

返回类型:Var

示例

>>> a = np.empty([2,2])
>>> np.full_like(a, 10)
array([[10, 10],
       [10, 10]])

identity(n, dtype=float32)

作用等同与 numpy 中的 np.identity 函数,创建一个二维Var, 对角线的值为1,是eye的特殊情况。

参数:

  • n:int 指定输出的行和列
  • dtype:dtype 指定输出的形状类型; 默认为np.float32

返回:创建的Var

返回类型:Var

示例

>>> np.identity(3)
array([[1.,  0.,  0.],
     [0.,  1.,  0.],
     [0.,  0.,  1.]])

eye(N, M=None, k=0, dtype=float32, order='C')

作用等同与 numpy 中的 np.eye 函数,创建一个二维Var, 对角线的值为1。

参数:

  • N:int 指定输出的行
  • M:int 指定输出的列
  • k:int 指定输出对角线位置
  • dtype:dtype 指定输出的形状类型; 默认为np.float32
  • order:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.eye(3, k=1)
array([[0.,  1.,  0.],
     [0.,  0.,  1.],
     [0.,  0.,  0.]])

absolute(x)

作用等同与 numpy 中的 np.absolute 函数,求输入的绝对值, 是expr.abs的封装。

参数:

  • x:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.absolute([-1, 2])
array([1, 2], dtype=int32)

less(a1, a2)

作用等同与 numpy 中的 np.less 函数,判断一个变量是否小于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.less([2, 2], [1, 2])
array([0, 0], dtype=int32)

repmat(a, m, n)

作用等同与 numpy 中的 np.repmat 根据指定数据,将0维数据复制成为2维(MxN)的Var。

参数:

  • a:ndarray 被复制的数据
  • m:int 复制的行数
  • n:int 复制的列数

返回:创建的Var

返回类型:Var

示例

>>> a = np.arange(3)
>>> np.repmat(a, 2, 3)
array([[0, 1, 2, 0, 1, 2, 0, 1, 2],
     [0, 1, 2, 0, 1, 2, 0, 1, 2]], dtype=int32)

arctan(x)

作用等同与 numpy 中的 np.arctan 函数,按元素计算反正切值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arctan([0.5, 1.0])
array([0.4636476, 0.7853982], dtype=float32)

stack(arrays, axis=0, out=None)

作用等同与 numpy 中的 np.stack 函数,沿指定轴连接输入的Var连接轴会创建一个新的维度。

参数:

  • args:Var序列 被连接的变量
  • axis:int 指定连接的轴
  • out:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
     [4, 5, 6]])

rint(x)

作用等同与 numpy 中的 np.rint 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.rint([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

sort(a, axis=-1, kind=None, order=None)

作用等同与 numpy 中的 np.sort 函数,对输入变量排序。

参数:

  • a:Var 将要排序的变量
  • axis:int 排序的维度
  • kind:numpy兼容参数 默认为None
  • order:numpy兼容参数 默认为None

返回:排序后得到的变量

返回类型:Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a)  
array([[1, 4],
       [1, 3]], dtype=int32)

arctan2(x1, x2)

作用等同与 numpy 中的 np.arctan2 函数,按元素计算输入比值的反正切值。

参数:

  • x1:Var 输入的变量
  • x2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arctan2(2., 3.)
array(0.5880026, dtype=float32)

logaddexp(x1, x2)

作用等同与 numpy 中的 np.logaddexp 函数,输入2个变量x1x2执行计算log(exp(x1) + exp(x2))

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.logaddexp(2, 3)
array(3.3132498, dtype=float32)

swapaxes(a, axis1, axis2)

作用等同与 numpy 中的 np.swapaxes 函数,交换Var的两个指定维度。

参数:

  • a:Var 将会交换该变量的维度
  • axis1:int 交换的维度1
  • axis2:int 交换的维度2

返回:交换维度后的 MNN.Var

返回类型:Var

示例

>>> a = np.ones((3, 4, 5))
>>> np.swapaxes(a, 0, 2).shape
[5, 4, 3]

less_equal(a1, a2)

作用等同与 numpy 中的 np.less_equal 函数,判断一个变量是否小于等于另一个变量。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.less_equal([2, 2], [1, 2])
array([0, 1], dtype=int32)

msort(a)

作用等同与 numpy 中的 np.msort 函数,沿axis=0对输入变量排序。

参数:

  • a:Var 将要排序的变量

返回:排序后得到的变量

返回类型:Var

示例

>>> a = np.array([[1,4],[3,1]])
>>> np.msort(a)  
array([[1, 1],
       [3, 4]], dtype=int32)

logspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

作用等同与 numpy 中的 np.logspace 根据指定数据,类型创建一个指定范围(对数等差)和数目的Var。

参数:

  • start:int|float 输出变量的范围起点
  • stop:int|float 输出变量的范围终点
  • num:int 输出数据总数
  • endpoint:bool 是否包含终点元素,目前仅支持endpoint=False
  • retstep:(Var, step) 返回值是否包含步长;如果包含则返回(Var, step)
  • dtype:dtype 指定输出的类型; 默认为stop的类型
  • axis:numpy兼容参数 默认为None

返回:创建的Var

返回类型:Var

示例

>>> np.logspace(0., 10., 5, False)
array([1.e+00, 1.e+02, 1.e+04, 1.e+06, 1.e+08], dtype=float32)

array_equal(a1, a2, equal_nan=False)

作用等同与 numpy 中的 np.array_equal 函数,判断2个变量是否完全相等。

参数:

  • a1:Var 输入的变量
  • a2:Var 输入的变量
  • equal_nan:numpy兼容参数 默认为None

返回:计算得到的变量

返回类型:bool

示例

>>> np.array_equal([1, 2], [1, 2])
True

nanvar(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.nanvar 函数,返回沿axis轴的方差。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.nanvar(a)
1.25
>>> np.nanvar(a, axis=0) 
array([1., 1.], dtype=float32)

row_stack(tup)

作用等同与 numpy 中的 np.row_stack 函数,垂直顺序连接Var序列,与vstack相同。

参数:

  • tup:Var序列 被连接的变量

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.row_stack((a, b))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

negative(x)

作用等同与 numpy 中的 np.negative 函数,按位取负。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.negative([1.,-2.])
array([-1., 2.], dtype=float32)

tan(x)

作用等同与 numpy 中的 np.tan 函数,按元素计算正切值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.tan([1.,2.])
array([ 1.5574077, -2.1850398], dtype=float32)

any(a, axis=None, out=None, keepdims=None)

作用等同与 numpy 中的 np.any 函数,判断是否所有元素存在真(不为0)。

参数:

  • a:Var 输入的变量
  • axis:list 判断的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.any([1, 0, 1])
True
>>> np.all([0, 0, 0])
False

arccosh(x)

作用等同与 numpy 中的 np.arccosh 函数,按元素计算双曲反余弦值。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.arccosh([2.0, 3.0])
array([1.316958 , 1.7627472], dtype=float32)

exp(x)

作用等同与 numpy 中的 np.exp 函数,按元素计算exp(x)

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.exp([1.,2.])
array([2.7182794, 7.388731 ], dtype=float32)

ldexp(x1, x2)

作用等同与 numpy 中的 np.ldexp 函数,输入2个变量x1x2执行计算x1 * exp2(x2)

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.ldexp(2., 3.)
array(16., dtype=float32)

prod(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.prod 函数,沿着指定维度,对数据求乘积。

参数:

  • x:Var 输入的变量
  • axis:list 计算的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留指定轴的维度

返回:计算得到的变量

返回类型:Varorscalar

示例

>>> np.prod([1,2,3,4])
24

ravel(a, order='C')

作用等同与 numpy 中的 np.ravel 函数,改变输入Var的形状为一维。

参数:

  • a:Var 将会改变该变量的形状
  • order:numpy兼容参数 默认为None

返回:形状为1维的MNN.Var

返回类型:Var

示例

>>> a = np.ones([[2],[2]])
>>> np.ravel(a)
array([1, 1, 1, 1], dtype=int32)

true_divide(x1, x2)

作用等同与 numpy 中的 np.true_divide 函数,对输入的2个变量相除, 是expr.divide的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.true_divide(13., 17.)
array(0.7647059, dtype=float32)

exp2(x)

作用等同与 numpy 中的 np.exp2 函数,按元素计算2**x

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.exp2([1.,2.])
array([2., 4.], dtype=float32)

fmax(x1, x2)

作用等同与 numpy 中的 np.fmax 函数,输入2个变量中的最大值, 是expr.maximum的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.fmax(13., 17.)
array(17., dtype=float32)

fmod(x1, x2)

作用等同与 numpy 中的 np.fmod 函数,对输入的2个变量求模, 是expr.mod的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.fmod(13., 5.)
array(3., dtype=float32)

mean(a, axis=None, dtype=float32, out=None, keepdims=False)

作用等同与 numpy 中的 np.mean 函数,返回沿axis轴的平均值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:float of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.mean(a)
1.5
>>> np.mean(a, axis=0) 
array([1., 2.], dtype=float32)

max(a, axis=None, out=None, keepdims=False)

作用等同与 numpy 中的 np.max 函数,返回沿axis轴的最大值。

参数:

  • a:Var 将要统计的变量
  • axis:int 统计的轴
  • out:numpy兼容参数 默认为None
  • keepdims:bool 是否保留计数维度

返回:计数得到的变量

返回类型:int of Var

示例

>>> a = np.arange(4).reshape((2,2))
>>> np.max(a) 
3
>>> np.max(a, axis=0) 
array([2, 3], dtype=int32)

mod(x1, x2)

作用等同与 numpy 中的 np.mod 函数,对输入的2个变量求模, 是expr.mod的封装。

参数:

  • x1:Var 参与计算的变量
  • x2:Var 参与计算的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.mod(13, 5)
array(3, dtype=int32)

asmatrix(a, dtype=None)

作用等同与 numpy 中的 np.asmatrix 根据指定数据,将输入数据转换为ndim=2的Var。

参数:

  • a:ndarray 输出变量的数据来源
  • dtype:dtype 重新指定输出的类型; 默认为a的数据类型

返回:创建的Var

返回类型:Var

示例

>>> np.asmatrix([1, 2, 3, 4])
array([[1, 2, 3]])

fix(x)

作用等同与 numpy 中的 np.fix 函数,按位进行四舍五入。

参数:

  • x:Var 输入的变量

返回:计算得到的变量

返回类型:Var

示例

>>> np.fix([1.2, 3.5, 4.7])
array([1., 4., 5.], dtype=float32)

hstack(tup)

作用等同与 numpy 中的 np.hstack 函数,水平顺序连接Var序列。

参数:

  • tup:Var序列 被连接的变量

返回:创建的Var

返回类型:Var

示例

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.hstack((a, b))
array([[1, 4],
     [2, 5],
     [3, 6]])

transpose(a, axes=None)

作用等同与 numpy 中的 np.transpose 函数,按照指定维度转置Var

参数:

  • a:Var 将转置该变量的维度
  • axes:tuple|list 转置的维度顺序

返回:转置后的 MNN.Var

返回类型:Var

示例

>>> a = np.ones((3, 4, 5))
>>> np.transpose(a).shape
[5, 4, 3]
Clone this wiki locally