megengine.functional package

megengine.functional.debug_param

megengine.functional.debug_param.get_conv_execution_strategy()[源代码]

返回 Conv2d 的执行策略。

参考 set_conv_execution_strategy() 的相关说明了解可能返回的值

返回类型

str

megengine.functional.debug_param.set_conv_execution_strategy(option)[源代码]

设置 Conv2d 的执行策略。

参数

option (str) –

决定 Conv2d 算法的选择方式。 可能的取值有:

  • ’HEURISTIC’ 使用启发式方法以选择速度最快的算法。

  • ’PROFILE’ 在真实的设备上运行可能的所有算法以找出最佳算法。

  • ’PROFILE_HEURISTIC’ 使用真实设备上的运行速度结果和启发式的方法以选择速度最快的算法。

  • ’PROFILE_REPRODUCIBLE’ 使用在真实设备上运行速度最快并可以复现的算法。

  • ’HEURISTIC_REPRODUCIBLE’ 使用启发式方法选择速度最快并且可以复现的算法。

默认的策略是 ‘HEURISTIC’。

它也可以通过环境变量 “MEGENGINE_CONV_EXECUTION_STRATEGY” 进行设置。

megengine.functional.distributed

megengine.functional.elemwise

megengine.functional.elemwise.abs(x)[源代码]

逐元素取绝对值。

megengine.functional.elemwise.acos(x)[源代码]

逐元素计算反余弦函数。

megengine.functional.elemwise.acosh(x)[源代码]

逐元素计算反双曲余弦函数。

megengine.functional.elemwise.add(x, y)[源代码]

逐元素加。至少一个操作数需要是张量。

sub/mul/div/floor_div/pow/mod/atan2/equal/not_equal/less/less_equal/greater/greater_equal/maximum/minmium 同理。

参数

x – 输入张量。

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
y = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.add(x, y)
print(out.numpy())

输出:

[[ 0.  2.  4.]
 [ 6.  8. 10.]]
megengine.functional.elemwise.asin(x)[源代码]

逐元素计算反正弦函数。

megengine.functional.elemwise.asinh(x)[源代码]

逐元素计算反双曲正弦函数。

megengine.functional.elemwise.atan(x)[源代码]

逐元素计算反正切函数。

megengine.functional.elemwise.atan2(y, x)[源代码]

逐元素计算两个参数的反正切函数。

megengine.functional.elemwise.atanh(x)[源代码]

逐元素计算反双曲正切函数。

megengine.functional.elemwise.ceil(x)[源代码]

逐元素上取整。

megengine.functional.elemwise.clip(x, lower=None, upper=None)[源代码]

把每个元素的值限定在范围 [ lower, upper ] 然后返回该张量:

\[\begin{split}y_i = \begin{cases} \text{lower} & \text{if } x_i < \text{lower} \\ x_i & \text{if } \text{lower} \leq x_i \leq \text{upper} \\ \text{upper} & \text{if } x_i > \text{upper} \end{cases}\end{split}\]
参数
  • x (Tensor) – 输入张量。

  • lower – 限定区间的下界

  • upper – 限定区间的上界

返回类型

Tensor

返回

输出经过区间限定的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

a = tensor(np.arange(5).astype(np.int32))
print(F.clip(a, 2, 4).numpy())
print(F.clip(a, lower=3).numpy())
print(F.clip(a, upper=3).numpy())

输出:

[2 2 2 3 4]
[3 3 3 3 4]
[0 1 2 3 3]
megengine.functional.elemwise.cos(x)[源代码]

逐元素计算余弦函数。

参数

x – 输入张量。

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.cos(x)
print(out.numpy())

输出:

[[ 1.      0.5403 -0.4161]
 [-0.99   -0.6536  0.2837]]
megengine.functional.elemwise.cosh(x)[源代码]

逐元素计算双曲余弦函数。

megengine.functional.elemwise.div(x, y)[源代码]

逐元素相除。

megengine.functional.elemwise.equal(x, y)[源代码]

逐元素判断是否相等。

参数
  • x – 输入张量1。

  • y – 输入张量2。

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
y = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.equal(x, y)
print(out.numpy())

输出:

[[1. 1. 1.]
 [1. 1. 1.]]
megengine.functional.elemwise.exp(x)[源代码]

逐元素计算 ex 次方。

megengine.functional.elemwise.expm1(x)[源代码]

逐元素计算expm1函数。

megengine.functional.elemwise.floor(x)[源代码]

逐元素计算下取整函数。

megengine.functional.elemwise.floor_div(x, y)[源代码]

逐元素相除并下取整。

megengine.functional.elemwise.greater(x, y)[源代码]

逐元素计算 x 大于 y。

megengine.functional.elemwise.greater_equal(x, y)[源代码]

逐元素判断 x 大于或者等于 y。

megengine.functional.elemwise.hsigmoid(x)[源代码]

逐元素计算 relu6(x + 3) / 6。

megengine.functional.elemwise.hswish(x)[源代码]

逐元素计算 x * relu6(x + 3) / 6。

参数

x – 输入张量。

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(5).astype(np.float32))
out = F.hswish(x)
print(out.numpy())
[0.     0.6667 1.6667 3.     4.    ]
megengine.functional.elemwise.left_shift(x, y)[源代码]

逐元素计算 x << y。

参数
  • x – 输入张量。应该是整数类型。

  • y – 需要左移的位数。

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.int32).reshape(2, 3))
out = F.left_shift(x, 2)
print(out.numpy())

输出:

[[ 0  4  8]
 [12 16 20]]
megengine.functional.elemwise.less(x, y)[源代码]

逐元素的计算 x 小于 y。

megengine.functional.elemwise.less_equal(x, y)[源代码]

逐元素计算 x 小于或等于 y。

megengine.functional.elemwise.log(x)[源代码]

逐元素计算以 e 为底的对数。

megengine.functional.elemwise.log1p(x)[源代码]

逐元素计算 (x+1)e 为底的对数。

megengine.functional.elemwise.logical_and(x, y)[源代码]

逐元素进行逻辑与运算。

megengine.functional.elemwise.logical_not(x)[源代码]

逐元素进行逻辑非运算。

megengine.functional.elemwise.logical_or(x, y)[源代码]

逐元素进行逻辑或运算。

megengine.functional.elemwise.logical_xor(x, y)[源代码]

逐元素进行逻辑异或运算。

megengine.functional.elemwise.maximum(x, y)[源代码]

逐元素的最大数组元素。

megengine.functional.elemwise.minimum(x, y)[源代码]

逐元素的最小数组元素。

megengine.functional.elemwise.mod(x, y)[源代码]

返回逐元素相除所得的余数。

megengine.functional.elemwise.mul(x, y)[源代码]

逐元素相乘。

megengine.functional.elemwise.neg(x)[源代码]

逐元素取相反数。

megengine.functional.elemwise.not_equal(x, y)[源代码]

逐元素计算 x 不等于 y。

megengine.functional.elemwise.pow(x, y)[源代码]

逐元素进行指数运算。

megengine.functional.elemwise.relu(x)[源代码]

逐元素计算 max(x, 0).

megengine.functional.elemwise.relu6(x)[源代码]

逐元素计算 min(max(x, 0), 6).

megengine.functional.elemwise.right_shift(x, y)[源代码]

逐元素计算 x >> y。

megengine.functional.elemwise.round(x)[源代码]

逐元素四舍五入到整数。

megengine.functional.elemwise.sigmoid(x)[源代码]

逐元素计算 1 / ( 1 + exp( -x ) ) 的值,并返回。

megengine.functional.elemwise.sin(x)[源代码]

逐元素计算正弦函数。

megengine.functional.elemwise.sinh(x)[源代码]

逐元素计算双曲正弦函数。

megengine.functional.elemwise.sqrt(x)[源代码]

逐元素计算平方根。对于负数输入,返回 NaN.

参数

x (Tensor) – 输入张量。

返回类型

Tensor

返回

计算得到的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.sqrt(x)
print(out.numpy())

输出:

[[0.     1.     1.4142]
 [1.7321 2.     2.2361]]
megengine.functional.elemwise.square(x)[源代码]

返回一个包含输入张量中各元素平方的新的张量

参数

inp – 输入张量。

返回类型

Tensor

返回

计算得到的张量。

例如:

import numpy as np
import megengine as mge
import megengine.functional as F

data = mge.tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.square(data)
print(out.numpy())

输出:

[[ 0.  1.  4.]
 [ 9. 16. 25.]]
megengine.functional.elemwise.sub(x, y)[源代码]

逐元素相减。

megengine.functional.elemwise.tan(x)[源代码]

逐元素计算正切函数。

megengine.functional.elemwise.tanh(x)[源代码]

逐元素计算双曲正切值。

megengine.functional.loss

megengine.functional.loss.binary_cross_entropy(pred, label, with_logits=True)[源代码]

Compute the binary cross entropy loss (using logits by default).

By default, prediction is assumed to be logits, whose sigmoid gives probabilities.

参数
  • pred (Tensor) – (N,*),其中 * 指任何附加的维度。

  • label (Tensor) – (N,*),与输入的形状相同。

  • with_logits (bool) – 布尔值,是否先应用 sigmoid。默认:True

返回类型

Tensor

返回

损失值。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

pred = tensor(np.array([0, 0], dtype=np.float32).reshape(1, 2))
label = tensor(np.ones((1, 2), dtype=np.float32))
loss = F.nn.binary_cross_entropy(pred, label)
print(loss.numpy())

输出:

[0.6931]
megengine.functional.loss.cross_entropy(pred, label, axis=1, with_logits=True, label_smooth=0)[源代码]

Compute the multi-class cross entropy loss (using logits by default).

By default, prediction is assumed to be logits, whose softmax gives probabilities.

与顺序调用 softmax()cross_entropy() 相比,具有更好的数值稳定性。

当使用标签平滑 (label smoothing) 时,标签的分布情况如下:

\[y^{LS}_{k}=y_{k}\left(1-\alpha\right)+\alpha/K\]

其中 \(y^{LS}\)\(y\) 分别是新的标签分布和原始的标签分布。 k是标签分布的索引。\(\alpha\) 是 label_smooth, \(K\) 是类的数量。

参数
  • pred (Tensor) – 表示预测概率的输入张量。

  • label (Tensor) – 表示分类标签的输入张量。

  • axis (int) – 沿着该维度应用 softmax 函数。默认:1。

  • with_logits (bool) – 是否先应用 sigmoid。默认:True

  • label_smooth (float) – 用于对原始标签分布进行标签平滑的参数。默认:0。

返回类型

Tensor

返回

损失值。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data_shape = (1, 2)
label_shape = (1, )
pred = tensor(np.array([0, 0], dtype=np.float32).reshape(data_shape))
label = tensor(np.ones(label_shape, dtype=np.int32))
loss = F.nn.cross_entropy(pred, label)
print(loss.numpy())

输出:

[0.6931]
megengine.functional.loss.hinge_loss(pred, label, norm='L1')[源代码]

计算支持向量机 SVM 中经常使用的 hinge loss。

hinge loss 可以表示为:

\[loss(x, y) = \frac{1}{N}\sum_i\sum_j(max(0, 1 - x_{ij}*y_{ij}))\]
参数
  • pred (Tensor) – 表示预测概率的输入张量,形为 (N,C)

  • label (Tensor) – 表示二分类标签的输入张量,形为 (N,C)

  • norm (str) – 指定计算损失时采用的范数,应为 “L1” 或 “L2” 。

返回类型

Tensor

返回

损失值。

例如:

from megengine import tensor
import megengine.functional as F

pred = tensor([[0.5, -0.5, 0.1], [-0.6, 0.7, 0.8]], dtype="float32")
label = tensor([[1, -1, -1], [-1, 1, 1]], dtype="float32")
loss = F.nn.hinge_loss(pred, label)
print(loss.numpy())

输出:

[1.5]
megengine.functional.loss.l1_loss(pred, label)[源代码]

计算预测值 \(x\) 和标签值 \(y\) 的每个元素之间的平均绝对误差(MAE)。

平均绝对误差可以表示为:

\[\ell(x,y) = mean\left(L \right)\]

式中,

\[L = \{l_1,\dots,l_N\}, \quad l_n = \left| x_n - y_n \right|,\]

\(x\)\(y\) 是任意形状的张量,各张量包含 \(N\) 个元素。 \(N\) 是批(batch)大小。

参数
  • pred (Tensor) – 从模型中预测的结果。

  • label (Tensor) – 用于比较的真实值。

返回类型

Tensor

返回

损失值。

例如:

import numpy as np
import megengine as mge
import megengine.functional as F

ipt = mge.tensor(np.array([3, 3, 3, 3]).astype(np.float32))
tgt = mge.tensor(np.array([2, 8, 6, 1]).astype(np.float32))
loss = F.nn.l1_loss(ipt, tgt)
print(loss.numpy())

输出:

[2.75]
megengine.functional.loss.square_loss(pred, label)[源代码]

计算预测值 \(x\) 和标签值 \(y\) 之间的均方误差(平方L2范数)。

均方误差可以表示为:

\[\ell(x, y) = mean\left( L \right)\]

式中,

\[L = \{l_1,\dots,l_N\}, \quad l_n = \left( x_n - y_n \right)^2,\]

\(x\)\(y\) 是任意形状的张量,各张量包含 \(N\) 个元素。 \(N\) 是批(batch)大小。

参数
  • pred (Tensor) – 从模型中预测的结果。

  • label (Tensor) – 用于比较的真实值。

返回类型

Tensor

返回

损失值。

形状:
  • pred : \((N, *)\) ,这里的 \(*\) 指任何附加的维度。

  • label: \((N, *)\). 与 pred 的形状相同

例如:

import numpy as np
import megengine as mge
import megengine.functional as F

ipt = mge.tensor(np.array([3, 3, 3, 3]).astype(np.float32))
tgt = mge.tensor(np.array([2, 8, 6, 1]).astype(np.float32))
loss = F.nn.square_loss(ipt, tgt)
print(loss.numpy())

输出:

[9.75]

megengine.functional.math

megengine.functional.math.argmax(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的最大值的下标。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2,3))
out = F.argmax(x)
print(out.numpy())

输出:

[5]
megengine.functional.math.argmin(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的最小值的下标。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2,3))
out = F.argmin(x)
print(out.numpy())

输出:

[0]
megengine.functional.math.argsort(inp, descending=False)[源代码]

返回一个与输入张量形状相同的全1张量。

参数
  • inp (Tensor) – 输入张量。如果是2维,返回结果为如何为输入张量按行排序的一组下标。

  • descending (bool) – 降序排列,即最大值位于第一位置。 默认:False

返回类型

Tensor

返回

类型为 int32 的下标,展示如何为输入排序。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.array([1,2], dtype=np.float32))
indices = F.argsort(x)
print(indices.numpy())

输出:

[0 1]
megengine.functional.math.isinf(inp)[源代码]

返回一个张量,它表示每个元素是否是无穷大值(Inf)。

参数

inp (Tensor) – 输入张量。

返回类型

Tensor

返回

分隔的张量。

例如:

from megengine import tensor
import megengine.functional as F

x = tensor([1, float("inf"), 0])
print(F.isinf(x).numpy())

输出:

[False  True False]
megengine.functional.math.isnan(inp)[源代码]

返回一个新的张量,该张量表明每个元素是否为非数值类型(NaN)。

参数

inp (Tensor) – 输入张量。

返回类型

Tensor

返回

分隔的张量。

例如:

from megengine import tensor
import megengine.functional as F

x = tensor([1, float("nan"), 0])
print(F.isnan(x).numpy())

输出:

[False  True False]
megengine.functional.math.max(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的最大值。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2,3))
out = F.max(x)
print(out.numpy())

输出:

[6]
megengine.functional.math.mean(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的平均值。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2, 3))
out = F.mean(x)
print(out.numpy())

输出:

[3.5]
megengine.functional.math.min(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的最小值。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2,3))
out = F.min(x)
print(out.numpy())

输出:

[1]
megengine.functional.math.norm(inp, ord=None, axis=None, keepdims=False)[源代码]

计算在给定轴 axisinp 张量每一行的 p-范数。

参数
  • inp (Tensor) – 输入张量。

  • ord (Optional[float]) – 对 inp 进行 p 次幂计算. 默认:2

  • axis (Optional[int]) – 要进行规约的维度。如果设置为 None,则所有的维度都将被规约。默认:None

  • keepdims – 输出张量是否保留了轴 axis 。默认:False

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-3, 3, dtype=np.float32))
out = F.norm(x)
print(out.numpy())

输出:

[4.3589]
megengine.functional.math.normalize(inp, ord=None, axis=None, eps=1e-12)[源代码]

返回在给定轴 axisinp 张量每一行进行 \(L_p\) 归一化后的结果。

对于一个形如 \((n_0, ..., n_{dim}, ..., n_k)\) 的张量 inp , 其每个 \(n_{dim}\) - axis 维度上的元素向量 \(v\) 将转化为:

\[v = \frac{v}{\max(\lVert v \rVert_p, \epsilon)}.\]
参数
  • inp (Tensor) – 输入张量。

  • ord (Optional[float]) – 对 inp 进行 p 次幂计算. 默认:2

  • axis (Optional[int]) – 要进行规约的维度。如果设置为 None,则所有的维度都将被规约。默认:None

  • eps (float) – 为防止0做除数而设的较小值。 默认: 1e-12

返回类型

Tensor

返回

归一化的输出张量。

megengine.functional.math.prod(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的乘积。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2, 3))
out = F.prod(x)
print(out.numpy())

输出:

[720]
megengine.functional.math.sign(inp)[源代码]

返回一个新的张量,该张量表明每个元素的符号。

参数

输入张量。

返回

输入张量的符号。

例如:

from megengine import tensor
import megengine.functional as F

x = tensor([1, -1, 0])
print(F.sign(x).numpy())

输出:

[ 1 -1  0]
megengine.functional.math.sort(inp, descending=False)[源代码]

返回一个与输入张量形状相同的全1张量。

参数
  • inp (Tensor) – 输入张量,如果是二维的,则该张量的每行将进行排序。

  • descending (bool) – 降序排列,即最大值位于第一位置。 默认:False

返回类型

Tuple[Tensor, Tensor]

返回

由两个张量组成的元组 (sorted_tensor, indices_of_int32)

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.array([1,2], dtype=np.float32))
out, indices = F.sort(x)
print(out.numpy())

输出:

[1. 2.]
megengine.functional.math.std(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的标准差。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data = tensor(np.arange(1, 7, dtype=np.float32).reshape(2, 3))
out = F.std(data, axis=1)
print(out.numpy())

输出:

[0.8165 0.8165]
megengine.functional.math.sum(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的和。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 7, dtype=np.int32).reshape(2, 3))
out = F.sum(x)
print(out.numpy())

输出:

[21]
megengine.functional.math.topk(inp, k, descending=False, kth_only=False, no_sort=False)[源代码]

按行排序,选出二维矩阵中 Top-K (默认情况下)个最小元素。

参数
  • inp (Tensor) – 输入张量,如果是二维的,则该张量的每行将进行排序。

  • k (int) – 所需元素的个数。

  • descending (bool) – 该值如果为true,则返回最大元素。 默认:False

  • kth_only (bool) – 该值如果为 True,则只返回第k个元素。 默认:False

  • no_sort (bool) – 该值如果为 True,则返回值可能是无序的。 默认:False

返回类型

Tuple[Tensor, Tensor]

返回

由两个张量组成的元组 (topk_tensor, indices_of_int32)

例如:

import numpy as np
from megengine import tensor
import  megengine.functional as F

x = tensor(np.array([2, 4, 6, 8, 7, 5, 3, 1], dtype=np.float32))
top, indices = F.topk(x, 5)
print(top.numpy(), indices.numpy())

输出:

[1. 2. 3. 4. 5.] [7 0 6 1 5]
megengine.functional.math.var(inp, axis=None, keepdims=False)[源代码]

返回在给定轴 axisinp 张量每一行的方差。如果给定的轴是一个维度列表,则规约所有维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 要进行规约的维度。如果设置为 None,则所有的维度都将规约。默认:None

  • keepdims (bool) – 输出张量是否保留了轴 axis 。默认:False

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data = tensor(np.arange(1, 7, dtype=np.float32).reshape(2, 3))
out = F.var(data)
print(out.numpy())

输出:

[2.9167]

megengine.functional.nn

megengine.functional.nn.conv_bias_activation(inp, weight, bias, dtype=None, stride=1, padding=0, dilation=1, groups=1, nonlinear_mode='IDENTITY', conv_mode='CROSS_CORRELATION', compute_mode='DEFAULT')[源代码]

带有激活操作的卷积偏置,仅用于推断。

参数
  • inp (Tensor) – 卷积运算的特征图。

  • weight (Tensor) – 卷积核。

  • bias (Tensor) – 添加到卷积结果中的偏置量

  • stride (Union[int, Tuple[int, int]]) – 二维卷积运算中的步长。 默认: 1

  • padding (Union[int, Tuple[int, int]]) – 在输入值的空间维度上每一侧填充的尺寸。 仅支持用零值填充。 默认: 0

  • dilation (Union[int, Tuple[int, int]]) – 二维卷积运算的扩张值(dilation)。 默认: 1

  • groups (int) – 将输入和输出通道划分成的组数, 以便执行分组卷积 “grouped convolution” 。 当组数 groups 不为1时,输入通道 in_channels 和输出通道 out_channels 必须能被 groups 整除, 权值矩阵的形状应为 (groups, out_channel // groups, in_channels // groups, height, width)

  • conv_mode (string or P.Convolution.Mode.) – 支持 ‘CROSS_CORRELATION’ 或者 ‘CONVOLUTION’. 默认: ‘CROSS_CORRELATION’

  • dtype – 支持np.dtype, 默认:np.int8

  • scale – 使用量化操作后进行的缩放, 默认: 0.0

  • zero_point – 使用 quint8 量化操作后进行的缩放, 默认: 0.0

  • compute_mode (string or P.Convolution.ComputeMode.) – 当该值设置为 ‘DEFAULT’ 时,对中间结果的精度不做特殊要求。当设置为 ‘FLOAT32’ 时,累加器和中间结果将使用 Float32 类型,但该设置仅当输入和输出为 Float16 类型时有效。

返回类型

Tensor

megengine.functional.nn.embedding(inp, weight, padding_idx=None, max_norm=None, norm_type=None)[源代码]

应用查找表进行 embedding。

参数
  • inp (Tensor) – 带有索引的张量。

  • weight (Tensor) – 嵌入的可学习的词向量矩阵。

  • padding_idx (Optional[int]) – 应设置为None,当前尚不支持。

  • max_norm (Optional[float]) – 应设置为None,当前尚不支持。

  • norm_type (Optional[float]) – 应设置为None,当前尚不支持。

返回

输出张量。

更多信息参见 Embedding

megengine.functional.nn.interpolate(inp, size=None, scale_factor=None, mode='BILINEAR', align_corners=None)[源代码]

按照给定的 sizescale_factor 对输入张量进行向下/向上采样。size 不可以与 scale_factor 共存。

参数
  • inp (Tensor) – 输入张量。

  • size (Union[int, Tuple[int, int], None]) – 输出张量的形状。 默认:None

  • scale_factor (Union[float, Tuple[float, float], None]) – 输出张量的放缩参数。默认:None

  • mode (str) – 插值方法,可接受的值有:”BILINEAR”, “LINEAR”。默认:”BILINEAR”

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 5, dtype=np.float32).reshape(1, 1, 2, 2))
out = F.nn.interpolate(x, [4, 4], align_corners=False)
print(out.numpy())
out2 = F.nn.interpolate(x, scale_factor=2.)
np.testing.assert_allclose(out.numpy(), out2.numpy())

输出:

[[[[1.   1.25 1.75 2.  ]
   [1.5  1.75 2.25 2.5 ]
   [2.5  2.75 3.25 3.5 ]
   [3.   3.25 3.75 4.  ]]]]
megengine.functional.nn.linear(inp, weight, bias=None)[源代码]

对输入张量进行线性变换。

更多信息参见 Linear

参数
  • inp (Tensor) – 形状为 (N, in_features) 的输入张量。

  • weight (Tensor) – 形状为 (out_features, in_features) 的权重张量。

  • bias (Optional[Tensor]) – 形状为 (out_features,) 的偏置张量。默认:None

返回类型

Tensor

megengine.functional.nn.nms(boxes, scores, iou_thresh, max_output=None)[源代码]

根据小方框的 IoU 值进行 非最大值抑制(NMS)。

参数
  • boxes (Tensor) – 形状为 (N, 4) 的张量;表示所有会被进行 nms 的小方框;每个小方框期望的格式为 (x1, y1, x2, y2)

  • iou_thresh (float) – IoU 重叠的阈值。

  • scores (Tensor) – 形状为 (N,) 的张量,表示小方块的分值。

  • max_output (Optional[int]) – 将要保留的小方框的最大数目;如果这个算子未被追溯则此参数是可选的,否则必须指定;如果未被指定,所有的小方框都会被保留。

返回类型

Tensor

返回

NMS 保留的元素的索引。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = np.zeros((100,4))
np.random.seed(42)
x[:,:2] = np.random.rand(100,2)*20
x[:,2:] = np.random.rand(100,2)*20 + 100
scores = tensor(np.random.rand(100))
inp = tensor(x)
result = F.nn.nms(inp, scores, iou_thresh=0.7)
print(result.numpy())

输出:

[75 69]
megengine.functional.nn.roi_align(inp, rois, output_shape, mode='average', spatial_scale=1.0, sample_points=2, aligned=True)[源代码]

对输入进行 roi align。

参数
  • inp (Tensor) – 表示输入特征的张量,形状为 (N, C, H, W)

  • rois (Tensor) – (N, 5) 的小方框。第一列为方框的索引,其余四列的格式是 xyxy

  • output_shape (Union[int, tuple, list]) – 输出的 rois 特征的形状 (height, width)

  • mode (str) – “max” 或者 “average”,如同最大值/平均池化一样使用最大值/平均 align。默认:”average”

  • spatial_scale (float) – 使用这个数值放缩输入框。默认:1.0

  • sample_points (Union[int, tuple, list]) – 每个输出样本要采取的输入样本数。0 表示密集采样。默认:2

  • aligned (bool) – 是否对齐输入特征,如果 aligned=True,首先选取合适的参数放缩 ROI 然后以 -0.5 的偏移量进行偏移。默认:True

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

np.random.seed(42)
inp = tensor(np.random.randn(1, 1, 128, 128))
rois = tensor(np.random.random((4, 5)))
y = F.nn.roi_align(inp, rois, (2, 2))
print(y.numpy()[0])

输出:

[[[0.175  0.175 ]
  [0.1359 0.1359]]]
megengine.functional.nn.roi_pooling(inp, rois, output_shape, mode='max', scale=1.0)[源代码]

对输入进行 roi pooling。

参数
  • inp (Tensor) – 表示输入特征的张量,形为 (N, C, H, W) 的图片。

  • rois (Tensor) – 形为(K,5)的box。第一列是N的索引,其它4列分别是xyxy。

  • output_shape (Union[int, tuple, list]) – 输出 rois 特征的形状, (height, width)

  • mode (str) – “max” 或者 “average”, 像使用最大/平均池化一样使用 max/average pooling。 默认: “max”

  • scale (float) – 使用这个数值放缩输入框。默认:1.0

返回类型

Tensor

返回

rois 的特征,形为 (K, C, output_shape[0], output_shape[1])

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

np.random.seed(42)
inp = tensor(np.random.randn(1, 1, 128, 128))
rois = tensor(np.random.random((4, 5)))
y = F.nn.roi_pooling(inp, rois, (2, 2))
print(y.numpy()[0])

输出:

[[[-0.1383 -0.1383]
  [-0.5035 -0.5035]]]
megengine.functional.nn.sync_batch_norm(inp, running_mean, running_var, weight=None, bias=None, training=False, momentum=0.9, eps=1e-05, eps_mode='ADDITIVE', group=<megengine.distributed.group.Group object>)[源代码]

对输入进同步批标准化。

更多信息参见 BatchNorm2dBatchNorm1d

参数
  • inp (Tensor) – 输入张量。

  • running_mean (Tensor) – 存储运行中的均值的张量。

  • running_var (Tensor) – 存储运行中的方差的张量。

  • weight (Optional[Tensor]) – 可学习仿射参数中的放缩张量。可参阅 BatchNorm2d 中的 \(\gamma\)

  • bias (Optional[Tensor]) – 可学习仿射参数中的偏置张量。可参阅 BatchNorm2d 中的 \(eta\)

  • training (bool) – 一个布尔值,它表示是否执行训练模式下的批归一化,即对当前批数据进行统计并更新统计量。 默认: False

  • momentum (Union[float, Tensor]) – 用于计算 running_meanrunning_var 的值。 默认: 0.9

  • eps (float) – 为提高数值稳定性而添加到分母中的值。 默认: 1e-5

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.adaptive_avg_pool2d(inp, oshp)[源代码]

对输入进行二维平均池化。

更多信息参见 AvgPool2d

参数
  • inp (Tensor) – The input tensor.

  • oshp (Union[Tuple[int, int], int, Tensor]) – (OH, OW) size of the output shape.

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.adaptive_max_pool2d(inp, oshp)[源代码]

对输入张量进行二维最大池化。

更多信息参见 MaxPool2d

参数
  • inp (Tensor) – The input tensor.

  • oshp (Union[Tuple[int, int], int, Tensor]) – (OH, OW) size of the output shape.

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.avg_pool2d(inp, kernel_size, stride=None, padding=0, mode='AVERAGE_COUNT_EXCLUDE_PADDING')[源代码]

对输入进行二维平均池化。

更多信息参见 AvgPool2d

参数
  • inp (Tensor) – 输入张量。

  • kernel_size (Union[int, Tuple[int, int]]) – 窗口的尺寸。

  • stride (Union[int, Tuple[int, int], None]) – 窗口的步长。 如果该值没有给出,则将值设置为 kernel_size 。默认: None

  • padding (Union[int, Tuple[int, int]]) – 添加在每一侧的隐含零值填充。 默认:0

  • mode (str) – 是否把填充值计算在内。默认:”AVERAGE_COUNT_EXCLUDE_PADDING”

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.batch_norm(inp, running_mean=None, running_var=None, weight=None, bias=None, *, training=False, momentum=0.9, eps=1e-05, inplace=True)[源代码]

对输入进行批标准化。

更多信息参见 BatchNorm2dBatchNorm1d

参数
  • inp (Tensor) – 输入张量。

  • running_mean (Optional[Tensor]) – 存储运行中的均值的张量。

  • running_var (Optional[Tensor]) – 存储运行中的方差的张量。

  • weight (Optional[Tensor]) – 可学习仿射参数中的放缩张量。可参阅 BatchNorm2d 中的 \(\gamma\)

  • bias (Optional[Tensor]) – 可学习仿射参数中的偏置张量。可参阅 BatchNorm2d 中的 \(eta\)

  • training (bool) – 一个布尔值,它表示是否执行训练模式下的批归一化,即对当前批数据进行统计并更新统计量。 默认: False

  • momentum (float) – 用于计算 running_meanrunning_var 的值。 默认: 0.9

  • eps (float) – 为提高数值稳定性而添加到分母中的值。 默认: 1e-5

  • inplace (bool) – 是否要原地更新 running_meanrunning_var,否则返回一个新张量。默认:True

返回

输出张量。

megengine.functional.nn.conv2d(inp, weight, bias=None, stride=1, padding=0, dilation=1, groups=1, conv_mode='CROSS_CORRELATION', compute_mode='DEFAULT')[源代码]

二维卷积运算。

更多信息参见 Conv2d

参数
  • inp (Tensor) – 卷积运算的特征图。

  • weight (Tensor) – 卷积核。

  • bias (Optional[Tensor]) – 添加到卷积结果中的偏置量(如果给定该值)

  • stride (Union[int, Tuple[int, int]]) – 二维卷积运算中的步长。 默认: 1

  • padding (Union[int, Tuple[int, int]]) – 在输入值的空间维度上每一侧填充的尺寸。 仅支持用零值填充。 默认: 0

  • dilation (Union[int, Tuple[int, int]]) – 二维卷积运算的扩张值(dilation)。 默认: 1

  • groups (int) – 将输入和输出通道划分成的组数, 以便执行分组卷积 “grouped convolution” 。 当组数 groups 不为1时,输入通道 in_channels 和输出通道 out_channels 必须能被 groups 整除, 权值矩阵的形状应为 (groups, out_channel // groups, in_channels // groups, height, width)

  • conv_mode (string or P.Convolution.Mode) – “CROSS_CORRELATION” or “CONVOLUTION”. 默认值:”CROSS_CORRELATION”

  • compute_mode (string or P.Convolution.ComputeMode) – 当该值设置为 ‘DEFAULT’ 时,对中间结果的精度不做特殊要求。当设置为 ‘FLOAT32’ 时,累加器和中间结果将使用 Float32 类型,但该设置仅当输入和输出为 Float16 类型时有效。

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.conv_transpose2d(inp, weight, bias=None, stride=1, padding=0, dilation=1, groups=1, conv_mode='CROSS_CORRELATION', compute_mode='DEFAULT')[源代码]

二维转置卷积运算。

更多信息参见 ConvTranspose2d

参数
  • inp (Tensor) – 卷积运算的特征图。

  • weight (Tensor) – 卷积核。

  • bias (Optional[Tensor]) – 添加到卷积结果中的偏置量(如果给定该值)

  • stride (Union[int, Tuple[int, int]]) – 二维卷积运算中的步长。 默认: 1

  • padding (Union[int, Tuple[int, int]]) – 在输入值的空间维度上每一侧填充的尺寸。 仅支持用零值填充。 默认: 0

  • dilation (Union[int, Tuple[int, int]]) – 二维卷积运算的扩张值(dilation)。 默认: 1

  • groups (int) – 将输入和输出通道划分成的组数, 以便执行分组卷积 “grouped convolution” 。 当组数 groups 不为1时,输入通道 in_channels 和输出通道 out_channels 必须能被 groups 整除, 权值矩阵的形状应为 (groups, out_channel // groups, in_channels // groups, height, width) 。默认:1

  • conv_mode (string or P.Convolution.Mode) – “CROSS_CORRELATION” or “CONVOLUTION”. 默认值:”CROSS_CORRELATION”

  • compute_mode (string or P.Convolution.ComputeMode) – 当该值设置为 ‘DEFAULT’ 时,对中间结果的精度不做特殊要求。当设置为 ‘FLOAT32’ 时,累加器和中间结果将使用 Float32 类型,但该设置仅当输入和输出为 Float16 类型时有效。

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.dot(inp1, inp2)[源代码]

计算两个向量 inp1inp2 的点积。输入必须是1维的,标量会被自动广播。

参数
  • inp1 (Tensor) – 第一个向量

  • inp2 (Tensor) – 第二个向量

返回类型

Tensor

返回

输出值

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data1 = tensor(np.arange(0, 6, dtype=np.float32))
data2 = tensor(np.arange(0, 6, dtype=np.float32))
out = F.dot(data1, data2)
print(out.numpy())

输出:

[55.]
megengine.functional.nn.dropout(inp, drop_prob, training=True)[源代码]

返回一个新张量,其中每个元素按概率 P = drop_prob =``drop_prob`` 随机被设置为零。可以选择是否重新缩放输出张量。

参数
  • inp (Tensor) – 输入张量。

  • drop_prob (float) – 丢弃单个元素(将其设置为0)的概率

  • training (bool) – dropout 在训练阶段的默认操作是 重新缩放输出张量, 这样它就可以在推理过程中被一个 Identity 代替, 默认值:True

返回类型

Tensor

返回

输出张量

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.ones(10, dtype=np.float32))
out = F.dropout(x, 1./3.)
print(out.numpy())

输出:

[1.5 1.5 0.  1.5 1.5 1.5 1.5 1.5 1.5 1.5]
megengine.functional.nn.indexing_one_hot(src, index, axis=1, keepdims=False)[源代码]

对一些轴进行One-hot索引。

参数
  • src (Tensor) – 输入张量。

  • index (Tensor) – 索引张量。

  • axis (int) – 源数据上的轴,索引值为其索引。 默认: 1

  • keepdims – 是否在结果数据中删除该轴。 默认: False

返回类型

Tensor

返回

输出张量。

例如:

import megengine.functional as F
from megengine import tensor

src = tensor([[1.0, 2.0]])
index = tensor([0])
val = F.indexing_one_hot(src, index)
print(val.numpy())

输出:

[1.]
megengine.functional.nn.leaky_relu(inp, negative_slope=0.01)[源代码]

逐元素使用leaky_relu函数

更多信息参见 LeakyReLU

返回类型

Tensor

megengine.functional.nn.local_conv2d(inp, weight, bias=None, stride=1, padding=0, dilation=1, conv_mode='CROSS_CORRELATION')[源代码]

使用untied kernels对图像进行二维空域卷积。

megengine.functional.nn.logsigmoid(inp)[源代码]

逐元素应用函数:

\[\text{logsigmoid}(x) = \log(\frac{ 1 }{ 1 + \exp(-x)}) = \log(1/(1 + exp(-x))) = - \log(1 + exp(-x)) = - \text{softplus}(-x)\]
参数

inp (Tensor) – 输入张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-5, 5, dtype=np.float32))
y = F.logsigmoid(x)
print(y.numpy())

输出:

[-5.0067 -4.0181 -3.0486 -2.1269 -1.3133 -0.6931 -0.3133 -0.1269 -0.0486
 -0.0181]
返回类型

Tensor

megengine.functional.nn.logsoftmax(inp, axis)[源代码]

对一个n维的输入张量做 \(\log(\text{Softmax}(x))\) 函数LogSoftmax的公式可以简化为:

\[\text{LogSoftmax}(x_{i}) = \log(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} )\]

为了提高数值稳定性,实现根据以下的变换:

\[\operatorname{logsoftmax}(x) = \log (\frac{\exp (x)}{\sum_{i}(\exp (x_{i}))}) = x - \log (\sum_{i}(\exp (x_{i}))) = x - logsumexp(x)\]
参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int]]) – 沿着该维度应用 logsoftmax。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-5, 5, dtype=np.float32)).reshape(2,5)
y = F.logsoftmax(x, axis=1)
print(y.numpy())

输出:

[[-4.4519 -3.4519 -2.4519 -1.4519 -0.4519]
 [-4.4519 -3.4519 -2.4519 -1.4519 -0.4519]]
返回类型

Tensor

megengine.functional.nn.logsumexp(inp, axis, keepdims=False)[源代码]

计算输入数据沿给定维度 axis 的指数之和的对数。该计算是数值稳定的。

\[\operatorname{logsumexp}(\boldsymbol{x})= \log \sum_{j=1}^{n} \exp \left(x_{j}\right)\]

为了提高数值稳定性,实现根据以下的变换:

\[\operatorname{logsumexp}(\boldsymbol{x})= \log \sum_{j=1}^{n} \exp \left(x_{j}\right) = \operatorname{logsumexp}(\boldsymbol{x})=b+\log \sum_{j=1}^{n} \exp \left(x_{j}-b\right)\]

式中,

\[b = \max(x_j)\]
参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int]]) – 求和计算所在的维度。可以是单个维度或维度的列表。

  • keepdims (bool) – 输出张量是否保留 axis

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-5, 5, dtype=np.float32)).reshape(2,5)
y = F.logsumexp(x, axis=1, keepdims=False)
print(y.numpy())

输出:

[-0.5481  4.4519]
返回类型

Tensor

megengine.functional.nn.matmul(inp1, inp2, transpose_a=False, transpose_b=False, compute_mode='DEFAULT', format='DEFAULT')[源代码]

对矩阵 inp1inp2 进行矩阵乘法。

当输入的dim不同时,执行的函数是不同的:

  • 都是1维张量,此时等价于点积运算。

  • 都是2维张量,此时是普通的矩阵乘法。

  • 如果其中一个输入张量是1维的,此时是一个矩阵和一个向量相乘。

  • 如果至少有一个张量是3维的或大于3维的,此时会进行批矩阵乘法,低维的张量会被广播。例如:

    • inp1: (n, k, m), inp2: (n, m, p), 返回: (n, k, p)

    • inp1: (n, k, m), inp2: (m, p), 返回: (n, k, p)

    • inp1: (n, j, k, m), inp2: (n, j, m, p), 返回: (n, j, k, p)

参数
  • inp1 (Tensor) – 相乘计算中的第一个矩阵。

  • inp2 (Tensor) – 相乘计算中的第二个矩阵。

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data1 = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
data2 = tensor(np.arange(0, 6, dtype=np.float32).reshape(3, 2))
out = F.matmul(data1, data2)
print(out.numpy())

输出:

[[10. 13.]
 [28. 40.]]
megengine.functional.nn.max_pool2d(inp, kernel_size, stride=None, padding=0)[源代码]

对输入张量进行二维最大池化。

更多信息参见 MaxPool2d

参数
  • inp (Tensor) – 输入张量。

  • kernel_size (Union[int, Tuple[int, int]]) – 窗口的尺寸。

  • stride (Union[int, Tuple[int, int], None]) – 窗口的步长。 如果该值没有给出,则将值设置为 kernel_size 。默认:None

  • padding (Union[int, Tuple[int, int]]) – 添加在每一侧的隐含零值填充。 默认:0

返回类型

Tensor

返回

输出张量。

megengine.functional.nn.one_hot(inp, num_classes)[源代码]

对输入张量进行 one-hot 编码。

参数
  • inp (Tensor) – 输入张量。

  • num_classes (int) – 表示输出张量最后一个维度的类数。

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(1, 4, dtype=np.int32))
out = F.one_hot(x, num_classes=4)
print(out.numpy())

输出:

[[0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]
megengine.functional.nn.prelu(inp, weight)[源代码]

逐元素使用 PReLU 函数。

更多信息参见 PReLU

返回类型

Tensor

megengine.functional.nn.softmax(inp, axis=None)[源代码]

使用softmax函数。softmax被定义为:

\[\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}\]

这将应用到该轴的所有元素上,并重新缩放这些元素使其能够处于 [0, 1] 的范围内并且和为1。

更多信息参见 Softmax

参数
  • inp (Tensor) – 输入张量。

  • axis (Optional[int]) – 在该轴上使用softmax方法。默认情况下,softmax将在序号最大的轴上使用。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-5, 5, dtype=np.float32)).reshape(2,5)
out = F.softmax(x)
print(out.numpy())

输出:

[[0.0117 0.0317 0.0861 0.2341 0.6364]
 [0.0117 0.0317 0.0861 0.2341 0.6364]]
返回类型

Tensor

megengine.functional.nn.softplus(inp)[源代码]

逐元素应用函数:

\[\text{softplus}(x) = \log(1 + \exp(x))\]

softplus 是 ReLU 函数的一个平滑的近似,可以被用来保证机器的输出一定是正数。为了提高数值稳定性,实现根据以下变换:

\[\text{softplus}(x) = \log(1 + \exp(x)) = \log(1 + \exp(-\text{abs}(x))) + \max(x, 0) = \log1p(\exp(-\text{abs}(x))) + \text{relu}(x)\]
参数

inp (Tensor) – 输入张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(-3, 3, dtype=np.float32))
y = F.softplus(x)
print(y.numpy())

输出:

[0.0486 0.1269 0.3133 0.6931 1.3133 2.1269]
返回类型

Tensor

megengine.functional.nn.svd(inp, full_matrices=False, compute_uv=True)[源代码]

对输入矩阵 inp 进行奇异值分解。

参数

inp (Tensor) – 输入矩阵,形状必须是 [..., M, N]

返回类型

Tensor

返回

输出矩阵 (U, sigma, V)

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.arange(0, 6, dtype=np.float32).reshape(2,3))
_, y, _ = F.svd(x)
print(y.numpy())

输出:

[7.3485 1.    ]
megengine.functional.nn.warp_perspective(inp, M, dsize, border_mode='REPLICATE', border_val=0.0, interp_mode='LINEAR')[源代码]

对按批组织的二维图像进行透视变换。

输入图像通过变换矩阵变换为输出图像:

\[\text{output}(n, c, h, w) = \text{input} \left( n, c, \frac{M_{00}h + M_{01}w + M_{02}}{M_{20}h + M_{21}w + M_{22}}, \frac{M_{10}h + M_{11}w + M_{12}}{M_{20}h + M_{21}w + M_{22}} \right)\]
参数
  • inp (Tensor) – 输入图像。

  • M (Tensor) – (batch, 3, 3) 变换矩阵。

  • dsize (Union[Tuple[int, int], int, Tensor]) – (h, w) 输出图像的大小。

  • border_mode (str) – 像素外推方法。 默认: "REPLICATE"

  • border_val (float) – 边界填充值。 默认:0

  • interp_mode (str) – 插值方法。 默认: "LINEAR"

返回

输出张量。

备注:

转换矩阵是 cv2.warpPerspective 使用的矩阵的逆矩阵。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

inp_shape = (1, 1, 4, 4)
x = tensor(np.arange(16, dtype=np.float32).reshape(inp_shape))
M_shape = (1, 3, 3)
# M defines a translation: dst(1, 1, h, w) = rst(1, 1, h+1, w+1)
M = tensor(np.array([[1., 0., 1.],
                     [0., 1., 1.],
                     [0., 0., 1.]], dtype=np.float32).reshape(M_shape))
out = F.warp_perspective(x, M, (2, 2))
print(out.numpy())

输出:

[[[[ 5.  6.]
   [ 9. 10.]]]]

megengine.functional.quantized

megengine.functional.quantized.conv_bias_activation(inp, weight, bias, dtype=None, stride=1, padding=0, dilation=1, groups=1, nonlinear_mode='IDENTITY', conv_mode='CROSS_CORRELATION', compute_mode='DEFAULT')[源代码]

带有激活操作的卷积偏置,仅用于推断。

参数
  • inp (Tensor) – 卷积运算的特征图。

  • weight (Tensor) – 卷积核。

  • bias (Tensor) – 添加到卷积结果中的偏置量

  • stride (Union[int, Tuple[int, int]]) – 二维卷积运算中的步长。 默认: 1

  • padding (Union[int, Tuple[int, int]]) – 在输入值的空间维度上每一侧填充的尺寸。 仅支持用零值填充。 默认: 0

  • dilation (Union[int, Tuple[int, int]]) – 二维卷积运算的扩张值(dilation)。 默认: 1

  • groups (int) – 将输入和输出通道划分成的组数, 以便执行分组卷积 “grouped convolution” 。 当组数 groups 不为1时,输入通道 in_channels 和输出通道 out_channels 必须能被 groups 整除, 权值矩阵的形状应为 (groups, out_channel // groups, in_channels // groups, height, width)

  • conv_mode (string or P.Convolution.Mode.) – 支持 ‘CROSS_CORRELATION’ 或者 ‘CONVOLUTION’. 默认: ‘CROSS_CORRELATION’

  • dtype – 支持np.dtype, 默认:np.int8

  • scale – 使用量化操作后进行的缩放, 默认: 0.0

  • zero_point – 使用 quint8 量化操作后进行的缩放, 默认: 0.0

  • compute_mode (string or P.Convolution.ComputeMode.) – 当该值设置为 ‘DEFAULT’ 时,对中间结果的精度不做特殊要求。当设置为 ‘FLOAT32’ 时,累加器和中间结果将使用 Float32 类型,但该设置仅当输入和输出为 Float16 类型时有效。

返回类型

Tensor

megengine.functional.tensor

megengine.functional.tensor.arange(start=0, stop=None, step=1, dtype='float32', device=None)[源代码]

返回一个数值从 startstop ,相邻间隔为 step 的张量。

参数
  • start (Union[int, float, Tensor]) – 序列的第一个值,应为标量。

  • stop (Union[int, float, Tensor, None]) – 序列的最后一个值,应为标量。

  • step (Union[int, float, Tensor]) – 每对相邻值之间的间隔。默认:1

  • dtype – 结果的数据类型。

返回类型

Tensor

返回

生成的张量。

例如:

import numpy as np
import megengine.functional as F

a = F.arange(5)
print(a.numpy())

输出:

输出:

[0. 1. 2. 3. 4.]
megengine.functional.tensor.broadcast_to(inp, shape)[源代码]

将张量广播至指定的形状。

参数
  • inp (Tensor) – 输入张量。

  • shape (Union[int, Iterable[int]]) – 目标形状。

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data = tensor(np.arange(0, 6, dtype=np.float32).reshape(2, 3))
out = F.broadcast_to(data, (4, 2, 3))
print(out.numpy())

输出:

[[[0. 1. 2.]
  [3. 4. 5.]]

 [[0. 1. 2.]
  [3. 4. 5.]]

 [[0. 1. 2.]
  [3. 4. 5.]]

 [[0. 1. 2.]
  [3. 4. 5.]]]
megengine.functional.tensor.concat(inps, axis=0, device=None)[源代码]

拼接一些张量

参数
  • inps (Iterable[Tensor]) – 将要进行拼接的输入张量。

  • axis (int) – 对张量进行拼接的维度。默认:0

  • device – 输出所在的计算节点。 默认:None

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

data1 = tensor(np.arange(0, 6, dtype=np.float32).reshape((2, 3)))
data2 = tensor(np.arange(6, 12, dtype=np.float32).reshape((2, 3)))
out = F.concat([data1, data2])
print(out.numpy())

输出:

[[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]
 [ 9. 10. 11.]]
megengine.functional.tensor.cond_take(mask, x)[源代码]

如果在mask上满足了特定条件,则从数据中取出元素。此算子有两个输出:第一个是取出的元素,第二个是这些元素对应的索引;两个输出都是一维的。高维数据输入时将首先被展平。

参数
  • mask (Tensor) – 条件参数;必须与数据的形状相同

  • x (Tensor) – 将从其中取出元素的输入张量

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F
mask = tensor(np.array([[True, False], [False, True]], dtype=np.bool_))
x = tensor(np.array([[1, np.inf], [np.nan, 4]],
    dtype=np.float32))
v, index = F.cond_take(mask, x)
print(v.numpy(), index.numpy())

输出:

[1. 4.] [0 3]
返回类型

Tensor

megengine.functional.tensor.expand_dims(inp, axis)[源代码]

在给定的axis前添加维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int]]) – 若干新轴的位置

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor([1, 2])
out = F.expand_dims(x, 0)
print(out.shape)

输出:

(1, 2)
megengine.functional.tensor.eye(N, M=None, *, dtype='float32', device=None)[源代码]

返回一个二维张量,其对角线上值均为1,其他位置值为0。

参数
  • shape – 期望的输出张量的形状。

  • dtype – 数据类型。默认:None

  • device (Optional[CompNode]) – 矩阵的计算节点。默认:None

返回类型

Tensor

返回

单位矩阵。

例如:

import numpy as np
import megengine.functional as F

out = F.eye(4, 6, dtype=np.float32)
print(out.numpy())

输出:

[[1. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0.]]
megengine.functional.tensor.flatten(inp, start_axis=0, end_axis=- 1)[源代码]

通过将子张量从 start_axis 维展平到 end_axis 维,实现对张量的重塑(reshape)。

参数
  • inp (Tensor) – 输入张量。

  • start_axis (int) – 子张量被展平时的初始维数。 默认: 0

  • end_axis (int) – 子张量被展平时的最终维数。 默认: -1

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

inp_shape = (2, 2, 3, 3)
x = tensor(
    np.arange(36, dtype=np.int32).reshape(inp_shape),
)
out = F.flatten(x, 2)
print(x.numpy().shape)
print(out.numpy().shape)

输出:

(2, 2, 3, 3)
(2, 2, 9)
megengine.functional.tensor.full(shape, value, dtype='float32', device=None)[源代码]

返回一个给定形状和值的张量

megengine.functional.tensor.full_like(inp, value)[源代码]

返回一个与输入张量形状相同的且值为给定值的零张量

返回类型

Tensor

megengine.functional.tensor.gather(inp, axis, index)[源代码]

使用 indexaxis 上的 inp 聚合数据。

对于三维张量, 输出由下面内容确定:

out[i][j][k] = inp[index[i][j][k]][j][k] # if axis == 0
out[i][j][k] = inp[i][index[i][j][k]][k] # if axis == 1
out[i][j][k] = inp[i][j][index[i][j][k]] # if axis == 2

如果 inp 是一个尺寸为 \((x_0,x_1,...,x_{i-1},x_i,x_{i+1},...,x_{n-1})\) 且 axis=i的n维张量,则 index 必须是一个尺寸为 \((x_0,x_1,...,x_{i-1},y,x_{i+1},...,x_{n-1})\) 的n维张量,这里的 \(y\ge 1\) 和输出的尺寸都必须必须与 index 的尺寸相同。

参数
  • inp (Tensor) – 输入张量。

  • axis (int) – 将要进行索引的轴。

  • index (Tensor) – 将要进行聚合的元素的索引

返回类型

Tensor

返回

输出张量。

例如:

import megengine.functional as F
from megengine import tensor

inp = tensor([
    [1,2], [3,4], [5,6],
])
index = tensor([[0,2], [1,0]])
oup = F.gather(inp, 0, index)
print(oup.numpy())

输出:

[[1 6]
 [3 2]]
megengine.functional.tensor.linspace(start, stop, num, dtype='float32', device=None)[源代码]

返回指定间隔的等距数列。

参数
  • start (Union[int, float, Tensor]) – 序列的第一个值,应为标量。

  • stop (Union[int, float, Tensor]) – 序列的最后一个值,应为标量。

  • num (Union[int, Tensor]) – 将要产生的值的个数。

  • dtype – 结果的数据类型。

返回类型

Tensor

返回

生成的张量。

例如:

import numpy as np
import megengine.functional as F

a = F.linspace(3,10,5)
print(a.numpy())

输出:

[ 3.    4.75  6.5   8.25 10.  ]
megengine.functional.tensor.ones(shape, dtype='float32', device=None)[源代码]

返回一个具有给定形状的全1张量。

参数

inp – 输入张量。

返回

输出的全0张量。

例如:

import megengine.functional as F

out = F.ones((2, 1))
print(out.numpy())

输出:

[[1.]
 [1.]]
megengine.functional.tensor.ones_like(inp)[源代码]

返回一个与输入张量形状相同的全1张量

返回类型

Tensor

megengine.functional.tensor.reshape(inp, target_shape)[源代码]

将一个张量重塑为给定的目标形状;逻辑元素的总数必须保持不变

参数
  • inp (Tensor) – 输入张量。

  • target_shape (Iterable[int]) – 目标形状,所有组件将被连接成目标形状,其中可能包含用来表示unspec_axis的值为-1的元素。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F
x = tensor(np.arange(12, dtype=np.int32))
out = F.reshape(x, (3, 2, 2))
print(out.numpy())

输出:

[[[ 0  1]
  [ 2  3]]

 [[ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]]]
返回类型

Tensor

megengine.functional.tensor.scatter(inp, axis, index, source)[源代码]

把张量 source 中所有的值通过 index 张量指定的索引位置上写入到输入张量中。

对于 source 中的每个值,它的输出索引在 axis != dimension 时,为 source 的索引或在 axis = dimension 时,为 index 中相对应的值。

对于三维张量, inp 将更新为:

inp[index[i][j][k]][j][k] = source[i][j][k]  # if axis == 0
inp[i][index[i][j][k]][k] = source[i][j][k]  # if axis == 1
inp[i][j][index[i][j][k]] = source[i][j][k]  # if axis == 2

inp, index and source should have same number of dimensions.

在所有维度上需要满足 source.shape(d) <= inp.shape(d) 以及 index.shape(d) == source.shape(d)

此外, index 的值必须介于 0inp.shape(axis) - 1 之间(包含边界)。

注解

请注意,在GPU设备上,由于性能原因,若多个源数据被 index 指定同一个目标位置时,结果会不确定。

使用以下例子展示案例,如果将index[1][2]设置为1到0,则oup[0][2]可能来自值为0.2256的source[0][2],或值为0.5339的source[1][2]。

参数
  • inp (Tensor) – 将要进行scatter操作的inp张量。

  • axis (int) – 将要进行索引的轴。

  • index (Tensor) – 将要进行scatter操作的元素的索引。

  • source (Tensor) – 将要进行scatter操作的inp张量一个或多个源元素。

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
import megengine.functional as F
from megengine import tensor

inp = tensor(np.zeros(shape=(3,5),dtype=np.float32))
source = tensor([[0.9935,0.9465,0.2256,0.8926,0.4396],[0.7723,0.0718,0.5939,0.357,0.4576]])
index = tensor([[0,2,0,2,1],[2,0,1,1,2]])
oup = F.scatter(inp, 0, index,source)
print(oup.numpy())

输出:

[[0.9935 0.0718 0.2256 0.     0.    ]
 [0.     0.     0.5939 0.357  0.4396]
 [0.7723 0.9465 0.     0.8926 0.4576]]
megengine.functional.tensor.split(inp, nsplits_or_sections, axis=0)[源代码]

把一个张量分隔成很多个小张量。当`nsplits_or_sections`是整数时,最后一个张量可能比其他张量小。

参数
  • inp – 输入张量。

  • nsplits_or_sections – 子张量或每个部分的信息列表的个数。

  • axis – 需要被分隔的轴。

返回

输出张量列表。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.random.random((2,3,4,5)), dtype=np.float32)
out = F.split(x, 2, axis=3)
print(out[0].shape, out[1].shape)

输出:

(2, 3, 4, 3) (2, 3, 4, 2)
megengine.functional.tensor.squeeze(inp, axis=None)[源代码]

删除形状(shape)中下标为1的维度。

参数
  • inp (Tensor) – 输入张量。

  • axis (Union[int, Sequence[int], None]) – 将要被移除的轴的位置。

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor(np.array([1, 2], dtype=np.int32).reshape(1, 1, 2, 1))
out = F.squeeze(x, 3)
print(out.shape)

输出:

(1, 1, 2)
megengine.functional.tensor.stack(inps, axis=0, device=None)[源代码]

在一个新的轴上连接一个序列中的张量。输入张量必须有相同的形状。

参数
  • inps – 输入张量。

  • axis – 用来连接的轴。

  • device – 输出所在的计算节点。 默认:None

返回

输入拼接好的张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x1 = tensor(np.arange(0, 6, dtype=np.float32).reshape((2, 3)))
x2 = tensor(np.arange(6, 12, dtype=np.float32).reshape((2, 3)))
out = F.stack([x1, x2], axis=0)
print(out.numpy())

输出:

[[[ 0.  1.  2.]
  [ 3.  4.  5.]]

 [[ 6.  7.  8.]
  [ 9. 10. 11.]]]
megengine.functional.tensor.transpose(inp, pattern)[源代码]

根据给定模板交换形状和步长(stride)。

参数
  • inp (Tensor) – 输入张量。

  • pattern (Iterable[int]) – 一个包含 0, 1, …, ndim-1 的整数列表

一个包含0, 1, … , ndim -1的整型数(int)列表,任意数量的 'x' 字符位于张量要进行广播的维度上。例如:

  • ('x') -> 将一个0维向量(标量)放入一个1维向量中

  • (0, 1) -> 等价的2维向量

  • (1, 0) -> 将第一维和第二维互换

  • ('x', 0) -> 将1维向量 (N to 1xN) 中的数排成一行

  • (0, 'x') -> 将一维向量 (N to Nx1)中的数排成一列

  • (2, 0, 1) -> AxBxC 变为 CxAxB

  • (0, 'x', 1) -> AxB 变为 Ax1xB

  • (1, 'x', 0) -> AxB 变为 Bx1xA

  • (1,) -> 这样就删除了第0维。最终一定变为可以广播的维度 (1xA to A)

返回类型

Tensor

返回

输出张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F
x = tensor(np.array([[1, 1], [0, 0]], dtype=np.int32))
out = F.transpose(x, (1, 0))
print(out.numpy())

输出:

[[1 0]
 [1 0]]
megengine.functional.tensor.where(mask, x, y)[源代码]

根据mask选出张量x或张量y中的元素。

\[\textrm{out}_i = x_i \textrm{ if } \textrm{mask}_i \textrm{ is True else } y_i\]
参数
  • mask (Tensor) – 用于选择x或y的 mask。

  • x (Tensor) – 第一个选择。

  • y (Tensor) – 第二个选择。

返回类型

Tensor

返回

输出张量。

例如:

from megengine import tensor
import megengine.functional as F
mask = tensor(np.array([[True, False], [False, True]], dtype=np.bool))
x = tensor(np.array([[1, np.inf], [np.nan, 4]],
    dtype=np.float32))
y = tensor(np.array([[5, 6], [7, 8]], dtype=np.float32))
out = F.where(mask, x, y)
print(out.numpy())

输出:

[[1. 6.]
 [7. 4.]]
megengine.functional.tensor.zeros(shape, dtype='float32', device=None)[源代码]

返回一个给定形状的全0张量。

megengine.functional.tensor.zeros_like(inp)[源代码]

返回一个与输入张量形状相同的全0张量。

参数

inp (Tensor) – 输入张量。

返回类型

Tensor

返回

输出的全0张量。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

inp = tensor(np.arange(1, 7, dtype=np.int32).reshape(2,3))
out = F.zeros_like(inp)
print(out.numpy())

输出:

[[0 0 0]
 [0 0 0]]

megengine.functional.types

megengine.functional.types.get_ndtuple(value, *, n, allow_zero=True)[源代码]

把可能的1维元组转换成n维元组。

参数
  • value – 元素会被填充到生成的元组中。

  • n – 元组里包含的元素个数。

  • allow_zero (bool) – 是否允许出现0值。

返回

一个元组。

megengine.functional.utils

megengine.functional.utils.copy(inp, device=None)[源代码]

把张量复制到另一个设备上。

参数
  • inp – 输入张量。

  • device – 目标设备。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

x = tensor([1, 2, 3], np.int32)
y = F.copy(x, "xpu1")
print(y.numpy())

输出:

[1 2 3]
megengine.functional.utils.topk_accuracy(logits, target, topk=1)[源代码]

根据给定的预测的logits和真实值标签计算分类准确率。

参数
  • logits (TensorWrapper) – 模型预测值,形为 [batch_size, num_classes] ,表示其属于各类别(class)的概率。

  • target (TensorWrapper) – 真实值标签,int32类型的一维张量。

  • topk (Union[int, Iterable[int]]) – 指定前k个值,可以是整型数,也可以是整型数构成的元组。 默认: 1

返回类型

Union[TensorWrapper, Iterable[TensorWrapper]]

返回

表示分类准确率的张量(一个或多个),数值介于0.0到1.0之间。

例如:

import numpy as np
from megengine import tensor
import megengine.functional as F

logits = tensor(np.arange(80, dtype=np.int32).reshape(8,10))
target = tensor(np.arange(8, dtype=np.int32))
top1, top5 = F.topk_accuracy(logits, target, (1, 5))
print(top1.numpy(), top5.numpy())

输出:

[0.] [0.375]