tvm.topi

TVM 操作符清单。

TOPI是TVM的算子集合库，为构建计算声明和优化调度提供便捷方式。

某些调度函数可能已针对特定工作负载进行了专门优化。

类：

`Analyzer`()	整数运算分析器
`Cast`(dtype, value[, span])	转换表达式。
`PrimExpr`	所有基本表达式的基类。

功能：

`abs`(x)	对输入x逐元素取绝对值。
`acos`(x)	计算输入x的反余弦值。
`acosh`(x)	对输入x取反双曲余弦。
`add`(lhs, rhs)	支持自动广播的加法运算
`adv_index`(data, indices)	使用张量进行Numpy风格的索引。
`all`(数据[, 轴, 保持维度])	对给定轴或轴列表上的数组元素进行逻辑与运算
`any`(data[, axis, keepdims])	数组元素在给定轴或多个轴上的逻辑或运算
`arange`(start[, stop, step, dtype])	在给定区间内创建一个具有均匀间隔值的张量。
`argmax`(data[, axis, keepdims, select_last_index])	返回沿轴的最大值的索引。
`argmin`(data[, axis, keepdims, select_last_index])	返回沿指定轴的最小值索引。
`argsort`(data[, valid_count, axis, ...])	沿给定轴执行排序操作，并返回一个与输入数组形状相同的索引数组，该数组按排序后的顺序索引数据。
`asin`(x)	计算输入x的反正弦值。
`asinh`(x)	对输入x取反双曲正弦值。
`atan`(x)	计算输入x的反正切值。
`atanh`(x)	对输入x取反双曲正切。
`binary_search`(ib, sequence_offset, ...)	为CPU和GPU后端使用的二进制搜索通用IR生成器。
`bitwise_and`(lhs, rhs)	计算数据的逐元素按位与。
`bitwise_not`(data)	计算数据的逐元素按位非运算。
`bitwise_or`(lhs, rhs)	计算数据的逐元素按位或操作。
`bitwise_xor`(lhs, rhs)	计算数据的逐元素按位异或。
`broadcast_to`(data, shape)	将src广播到目标形状
`cast`(x, dtype[, span])	将输入转换为指定的数据类型。
`ceil`(x)	对输入x取上界。
`ceil_log2`(x)	计算整数向上取整的log2值，针对Vulkan SPIR-V的特殊代码路径（因为SPIR-V不支持fp64类型的log2运算）。
`clip`(x, a_min, a_max)	对数组中的值进行裁剪（限制）。
`collapse_sum`(data, target_shape)	返回数据到给定形状的求和结果。
`concatenate`(a_tuple[, axis])	沿现有轴连接一系列数组。
`const_vector`(vector[, 名称])	将常量numpy一维向量转换为tvm张量
`cos`(x)	计算输入x的余弦值。
`cosh`(x)	计算输入x的双曲余弦值。
`cumprod`(data[, axis, dtype, exclusive])	Numpy风格的累积乘积操作。
`cumsum`(data[, axis, dtype, exclusive])	Numpy风格的累加操作。
`decl_buffer`(shape[, dtype, name, data, ...])	声明一个新的符号缓冲区。
`dft`(re_data, im_data, inverse)	计算输入的离散傅里叶变换（沿最后一个轴进行计算）。
`div`(a, b[, span])	按照C/C++语义计算a / b。
`divide`(lhs, rhs)	支持自动广播的除法运算
`dynamic_strided_slice`(a, begin, end, ...)	数组切片。
`einsum`(subscripts, *operand)	对操作数执行爱因斯坦求和约定。
`elemwise_sum`(xs)	对输入执行逐元素求和
`equal`(lhs, rhs)	使用自动广播计算 (lhs==rhs)
`erf`(x)	对输入x取高斯误差函数。
`exp`(x)	对输入x取指数。
`expand_dims`(a, axis[, num_newaxis])	扩展数组的形状。
`expand_like`(a, shape_like, axis)	根据第二个数组的形状扩展输入数组。
`extern`(shape, inputs, fcompute[, name, ...])	通过外部函数计算多个张量。
`eye`(n[, m, k, dtype])	生成一个单位矩阵或在第k条对角线上为1的矩阵。
`fast_erf`(x)	使用fast_erf实现计算输入x的高斯误差函数。
`fast_exp`(x)	使用fast_exp实现计算输入x的指数
`fast_tanh`(x)	使用fast_tanh实现计算输入x的双曲正切值
`fixed_point_multiply`(x, multiplier, shift)	数据与定点常数之间的乘法运算，该常数表示为乘数 * 2^(-移位)，其中乘数是一个具有31位小数部分的Q格式数字
`fixed_point_multiply_per_axis`(x, y, lshift, ...)	数据与定点常数之间的定点乘法运算，该常数表示为乘数 * 2^(-位移)，其中乘数是一个具有31位小数部分的Q格式数
`flip`(a[, axis])	沿特定轴翻转/反转数组元素。
`floor`(x)	取输入x的向下取整。
`floor_divide`(lhs, rhs)	支持自动广播的向下取整除法
`floor_mod`(lhs, rhs)	支持自动广播的取模运算
`floordiv`(a, b[, span])	计算两个表达式的向下取整除。
`floormod`(a, b[, span])	计算两个表达式的取模运算结果。
`full`(shape, dtype, fill_value)	用fill_value填充张量
`full_like`(x, fill_value)	构造一个与输入张量形状相同的张量，
`gather`(data, axis, indices)	从给定索引沿指定轴收集值。
`gather_nd`(a, indices[, batch_dims])	从n维数组中收集元素。
`get_const_tuple`(in_tuple)	验证输入元组是否为IntImm或Var类型，返回整数或Var的元组。
`greater`(lhs, rhs)	计算(lhs>rhs)并自动进行广播操作
`greater_equal`(lhs, rhs)	计算(lhs>=rhs)并自动进行广播
`identity`(x)	获取输入x的标识。
`isfinite`(x)	检查x的值是否有限，逐元素检查。
`isinf`(x)	检查x的值是否为无穷大，逐元素进行。
`isnan`(x)	检查x的值是否为NaN，逐个元素判断。
`layout_transform`(array, src_layout, dst_layout)	根据源布局和目标布局转换布局
`left_shift`(lhs, rhs)	带自动广播的左移操作
`less`(lhs, rhs)	计算(lhs
`less_equal`(lhs, rhs)	使用自动广播计算 (lhs<=rhs)
`log`(x)	对输入x取对数。
`log10`(x)	对输入x取以10为底的对数。
`log2`(x)	对输入x取以2为底的对数。
`logical_and`(lhs, rhs)	计算数据的逐元素逻辑与。
`logical_not`(data)	对数据进行逐元素的逻辑非运算。
`logical_or`(lhs, rhs)	计算数据的逐元素逻辑或。
`logical_xor`(lhs, rhs)	计算数据的逐元素逻辑异或。
`make_idx`(b, e, s, z, i)	返回与完整数组中数组位置相对应的选择中的数组位置。
`matmul`(a, b[, transp_a, transp_b])	创建一个计算矩阵乘法的操作（行主序表示法）：当trans_a == trans_b时计算A(i, k) * B(k, j)，否则执行常规转置组合
`matrix_set_diag`(data, diagonal[, k, align])	返回一个张量，其中输入张量的对角线被替换为提供的对角线值。
`max`(data[, axis, keepdims])	计算给定轴或轴列表上数组元素的最大值
`maximum`(lhs, rhs)	对两个张量进行逐元素最大值计算，支持自动广播
`meshgrid`(a_tuple, indexing)	从坐标向量创建坐标矩阵。
`min`(data[, axis, keepdims])	计算给定轴或轴列表上数组元素的最小值
`minimum`(lhs, rhs)	对两个张量进行自动广播后的逐元素最大值计算
`mod`(lhs, rhs)	支持自动广播的模运算
`multiply`(lhs, rhs)	支持自动广播的乘法运算
`ndarray_size`(array[, dtype])	获取输入数组的元素数量
`negative`(x)	对输入x取反。
`not_equal`(lhs, rhs)	使用自动广播计算(lhs!=rhs)
`one_hot`(indices, on_value, off_value, depth, ...)	返回一个独热张量，其中由索引表示的位置取值为on_value，其他位置取值为off_value。
`power`(lhs, rhs)	支持自动广播的幂运算
`prod`(data[, axis, keepdims])	计算数组元素沿给定轴或轴列表的乘积
`reinterpret`(x, dtype)	将输入重新解释为指定的数据类型。
`repeat`(a, repeats, axis)	重复数组中的元素。
`reshape`(a, newshape)	重塑数组
`reverse_sequence`(a, seq_lengths[, seq_axis, ...])	反转可变长度切片的张量。
`right_shift`(lhs, rhs)	带自动广播的右移操作
`round`(x)	将x的元素四舍五入到最接近的整数。
`rsqrt`(x)	对输入x取反平方根。
`scanop`(data, binop, identity_value, op_name)	具有类似np.cumsum和np.cumprod轴行为的累积二元运算符(scan)。
`scatter_elements`(data, indices, updates[, ...])	将更新中的元素分散到复制数据的对应索引位置。
`scatter_nd`(data, indices, updates, mode)	从n维数组中分散元素。
`searchsorted`(sorted_sequence, values[, ...])	查找应插入元素以保持顺序的索引位置。
`sequence_mask`(data, valid_length[, ...])	将序列预期长度之外的所有元素设置为一个常量值。
`shape`(array[, dtype])	获取输入数组的形状
`sigmoid`(x)	对输入x取sigmoid tanh函数值。
`sign`(x)	根据x的符号返回-1、0或1。
`sin`(x)	计算输入x的正弦值。
`sinh`(x)	计算输入x的双曲正弦值。
`sliding_window`(data, axis, window_shape, strides)	在数据张量上滑动窗口。
`sort`(data[, axis, is_ascend])	沿给定轴执行排序操作，并返回按排序顺序排列的数组。
`sparse_reshape`(sparse_indices, prev_shape, ...)	重塑稀疏张量
`sparse_to_dense`(sparse_indices, ...[, ...])	将稀疏表示转换为密集张量。
`split`(ary, indices_or_sections[, axis])	将一个数组分割成多个子数组。
`sqrt`(x)	对输入x取平方根。
`squeeze`(a[, axis])	从数组的形状中移除单维度条目。
`stack`(a, axis)	将整个数组重复多次。
`stft`(data, n_fft, hop_length, win_length, ...)	STFT计算输入信号短时重叠窗口的傅里叶变换。
`strided_set`(a, v, begin, end[, strides])	设置数组的切片。
`strided_slice`(a, begin, end[, strides, ...])	数组切片。
`subtract`(lhs, rhs)	支持自动广播的减法运算
`sum`(data[, axis, keepdims])	沿给定轴或轴列表的数组元素求和
`take`(a, indices[, axis, batch_dims, mode])	沿轴从数组中提取元素。
`tan`(x)	计算输入x的正切值。
`tanh`(x)	对输入x取双曲正切tanh。
`tensordot`(a, b, axes)	将矩阵乘法推广到张量。
`tile`(a, reps)	将整个数组重复多次。
`topk`(data[, k, axis, ret_type, is_ascend, dtype])	获取输入张量沿给定轴的前k个元素。
`transpose`(a[, axes])	对数组的维度进行置换。
`trilu`(data, k, upper)	给定一个二维矩阵或二维矩阵批次，返回张量的上三角或下三角部分。
`trunc`(x)	对输入x的每个元素取截断值。
`unravel_index`(indices, shape)	将平面索引或平面索引数组转换为坐标数组的元组。
`where`(condition, x, y)	根据条件从x或y中获取元素。
`within_index`(b, e, s, i)	返回一个布尔值，表示i是否在给定的索引范围内。

异常情况：

InvalidShapeError

topi函数形状无效。

class tvm.topi.Analyzer

整数运算分析器

这是一个有状态的分析器类，可用于执行各种符号整数分析。

方法：

`const_int_bound`(expr)	为表达式寻找常量整数边界。
`modular_set`(expr)	查找表达式所属的模块化集合。
`simplify`(expr[, steps])	通过重写和规范化来简化表达式。
`rewrite_simplify`(expr)	通过重写规则简化表达式。
`canonical_simplify`(expr)	通过规范化简化表达式。
`int_set`(expr, dom_map)	计算一个符号化的IntSet，该集合覆盖了在dom_map中所有值对应的expr。
`can_prove`(expr[, strength])	检查我们是否能证明表达式为真。
`bind`(变量, 表达式)	将变量绑定到表达式。
`constraint_scope`(约束条件)	创建一个约束范围。
`update`(变量, 信息[, 覆盖])	更新变量相关信息
`can_prove_equal`(lhs, rhs)	我们能否证明 lhs == rhs

属性：

enabled_extensions

返回当前已启用的扩展

const_int_bound(expr)

为表达式寻找常量整数边界。

Parameters:: expr (PrimExpr) – 表达式。
Returns:: bound - 结果边界
Return type:: ConstIntBound

modular_set(expr)

查找表达式所属的模块化集合。

Parameters:: expr (PrimExpr) – 表达式。
Returns:: result – 结果。
Return type:: 模块化集合

simplify(expr, steps=2)

通过重写和规范化来简化表达式。

Parameters:

expr (PrimExpr) – 表达式。
steps (简化步骤按以下顺序运行) – rewrite_simplify (步骤1) -> canonical_simplify (步骤2) -> rewrite_simplify (步骤3) -> canonical_simplify (步骤4) -> … 参数steps控制运行的步骤数量。默认值为2，即rewrite_simplify + canonical_simplify。

Returns:

result – 结果。

Return type:

表达式

rewrite_simplify(expr)

通过重写规则简化表达式。

Parameters:: expr (PrimExpr) – 表达式。
Returns:: result – 结果。
Return type:: 表达式

canonical_simplify(expr)

通过规范化简化表达式。

Parameters:: expr (PrimExpr) – 表达式。
Returns:: result – 结果。
Return type:: 表达式

int_set(expr, dom_map)

计算一个符号化的IntSet，该集合覆盖了在dom_map中所有值对应的expr。

Parameters:

expr (PrimExpr) – 表达式。
dom_map (Dict[tvm.tir.Var, tvm.arith.IntSet]) – 需要松弛的变量的定义域。

Returns:

result – 结果。

Return type:

IntSet

can_prove(expr, strength=ProofStrength.DEFAULT)

检查我们是否能证明表达式为真。

Parameters:

expr (PrimExpr) – 表达式。
strength (ProofStrength) – 证明强度

Returns:

result – 结果。

Return type:

表达式

bind(var: 变量, expr: PrimExpr | 范围)

将变量绑定到表达式。

Parameters:

var (tvm.tir.Var) – 变量。
expr (Union[tir.PrimExpr, ir.Range]) – 要绑定的表达式或范围。

constraint_scope(constraint)

创建一个约束范围。

Parameters:: constraint (PrimExpr) – 约束表达式。
Returns:: scope – 约束范围
Return type:: 约束范围

示例

x = te.var("x")
analyzer = tvm.arith.Analyzer()
with analzyer.constraint_scope(x % 3 == 0):
    # constraint in effect
    assert analyzer.modular_set(x).coeff == 3
# constraint no longer in effect
assert analyzer.modular_set(x).coeff != 3

update(var, info, override=False)

更新变量相关信息

Parameters:

var (tvm.tir.Var) – 该变量。
info (tvm.Object) – 相关信息。
override (bool) – 是否允许覆盖。

can_prove_equal(lhs: PrimExpr, rhs: PrimExpr)

我们能否证明 lhs == rhs

Parameters:

lhs (PrimExpr) – 比较操作的左侧表达式
rhs (PrimExpr) – 比较操作的右侧表达式

Returns:

result – 我们是否能证明 lhs == rhs

Return type:

bool

property enabled_extensions: Extension: 返回当前已启用的扩展

class tvm.topi.Cast(dtype, value, span: Span | None = None)

转换表达式。

Parameters:

dtype (str) – 数据类型
value (PrimExpr) – 该函数的值。
span (可选[Span]) – 该表达式在源代码中的位置。

class tvm.topi.PrimExpr

所有基本表达式的基类。

PrimExpr 用于底层代码优化和整数分析。

tvm.topi.abs(x)

对输入x逐元素取绝对值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.acos(x)

计算输入x的反余弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.acosh(x)

对输入x取反双曲余弦。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.add(lhs, rhs)

支持自动广播的加法运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.adv_index(data, indices)

使用张量进行Numpy风格的索引。

Parameters:

data (tvm.te.Tensor) – 输入数据。
indices (列表，包含tvm.te.Tensor) – 张量索引。

Returns:

result – 输出张量

Return type:

tvm.te.Tensor

tvm.topi.all(data, axis=None, keepdims=False)

对给定轴或轴列表上的数组元素进行逻辑与运算

Parameters:

data (tvm.te.Tensor) – 输入的tvm布尔张量
axis (None 或 int 或 tuple 的 int) – 沿此轴或这些轴执行逻辑AND操作。默认值axis=None将对输入数组的所有元素执行逻辑AND操作。如果axis为负数，则从最后一个轴开始倒数。
keepdims (bool) – 如果设置为True，被缩减的轴会保留在结果中作为大小为1的维度。通过此选项，结果将能正确地与输入数组进行广播。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.any(data, axis=None, keepdims=False)

数组元素在给定轴或多个轴上的逻辑或运算

Parameters:

data (tvm.te.Tensor) – 输入的tvm布尔张量
axis (None 或 int 或 tuple 的 int) – 沿着执行逻辑OR运算的轴或多个轴。默认值axis=None将对输入数组的所有元素执行逻辑OR运算。如果axis为负数，则从最后一个轴到第一个轴计数。
keepdims (bool) – 如果设置为True，被缩减的轴将在结果中保留为大小为1的维度。通过此选项，结果将能够正确地对输入数组进行广播。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.arange(start, stop=None, step=1, dtype='float32')

在给定区间内创建一个具有均匀间隔值的张量。

Parameters:

start (tvm.Expr, optional) – 区间的起始值。该区间包含此值。默认起始值为0。
stop (tvm.Expr) – 区间的结束值。该区间不包含此值。
step (tvm.Expr, optional) – 数值之间的间隔。默认步长为1。
dtype (str, 可选) – 目标数据类型。

Returns:

result – 结果张量。

Return type:

tvm.te.Tensor

tvm.topi.argmax(data, axis=None, keepdims=False, select_last_index=False)

返回沿轴的最大值的索引。

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None 或 int 或 tuple 包含 int) – 执行argmax操作所沿的轴。默认值axis=None时，会找出输入数组所有元素中的最大值索引。如果axis为负数，则从最后一个轴开始倒数。
keepdims (bool) – 如果设置为True，被缩减的轴将保留在结果中作为大小为1的维度。通过此选项，结果将能够正确广播到输入数组。
select_last_index (bool) – 如果最大元素出现多次时是否选择最后一个索引，否则选择第一个索引。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.argmin(data, axis=None, keepdims=False, select_last_index=False)

返回沿指定轴的最小值索引。

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None 或 int 或 tuple 的 int) – 执行argmin操作所沿的轴或多个轴。默认值axis=None时，将在输入数组的所有元素中查找最小元素的索引。如果axis为负数，则从最后一个轴到第一个轴进行计数。
keepdims (bool) – 如果设置为True，被缩减的轴会保留在结果中作为大小为1的维度。通过此选项，结果将能正确地与输入数组进行广播。
select_last_index (bool) – 如果最小元素出现多次，是否选择最后一个索引，否则选择第一个索引。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.argsort(data, valid_count=None, axis=-1, is_ascend=1, dtype='float32')

沿给定轴执行排序，并返回一个与输入数组形状相同的索引数组，该数组按排序顺序索引数据。

Parameters:

data (tvm.te.Tensor) – 输入张量。
valid_count (tvm.te.Tensor, optional) – 表示有效框数量的1维张量。
axis (int, optional) – 指定沿哪个轴对输入张量进行排序。默认使用展平的数组。
is_ascend (boolean, optional) – 指定按升序还是降序排序。
dtype (string, optional) – 输出索引的数据类型。

Returns:

out – 排序后的索引张量。

Return type:

tvm.te.Tensor

示例

# An example to use argsort
dshape = (1, 5, 6)
data = te.placeholder(dshape, name="data")
axis = 0
is_ascend = False
out = argsort(data, axis=axis, is_ascend=is_ascend)
np_data = np.random.uniform(dshape)
s = topi.generic.schedule_argsort(out)
f = tvm.compile(s, [data, out], "llvm")
dev = tvm.cpu()
tvm_data = tvm.nd.array(np_data, dev)
tvm_out = tvm.nd.array(np.zeros(dshape, dtype=data.dtype), dev)
f(tvm_data, tvm_out)

tvm.topi.asin(x)

计算输入x的反正弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.asinh(x)

对输入x取反双曲正弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.atan(x)

计算输入x的反正切值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.atanh(x)

对输入x取反双曲正切。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.binary_search(ib, sequence_offset, search_range, sorted_sequence, value, right, out_dtype)

为CPU和GPU后端使用的二进制搜索通用IR生成器。

sorted_sequence是一个N维缓冲区，其最内层维度用于搜索value，而search_range表示最内层维度的大小。sequence_offset是一个一维线性偏移量，用于指定要搜索的最内层序列。

因此，对value的搜索是在 sorted_sequence[sequence_offset:(sequence_offset + search_range)]范围内进行的。请注意，我们使用一维线性索引来访问N维缓冲区。

tvm.topi.bitwise_and(lhs, rhs)

计算数据的逐元素按位与。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.bitwise_not(data)

计算数据的逐元素按位非运算。

Parameters:: data (tvm.te.Tensor 或 Expr)
Returns:: ret – 如果操作数是Expr则返回Expr，否则返回Tensor。
Return type:: tvm.te.Tensor 或表达式

tvm.topi.bitwise_or(lhs, rhs)

计算数据的逐元素按位或操作。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.bitwise_xor(lhs, rhs)

计算数据的逐元素按位异或。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.broadcast_to(data, shape)

将src广播到目标形状

We follows the numpy broadcasting rule. See also https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html

Parameters:

data (tvm.te.Tensor) – 输入数据
shape (list 或 tuple) - 要进行广播的目标形状。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.cast(x, dtype, span=None)

将输入转换为指定的数据类型。

Parameters:

x (tvm.te.Tensor 或 Expr) – 输入参数。
dtype (str) – 数据类型。
span (可选[Span]) – 转换操作在源代码中的位置。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.ceil(x)

对输入x取上界。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.ceil_log2(x)

计算整数向上取整的log2值，针对Vulkan有特殊处理路径 SPIR-V不支持fp64类型的log2运算。因此当目标平台是Vulkan时，我们通过clz内建函数来计算整数ceil_log2。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.clip(x, a_min, a_max)

对数组中的值进行裁剪（限制）。给定一个区间，区间外的值将被裁剪到区间的边缘。

Parameters:

x (tvm.te.Tensor) – 输入参数。
a_min (tvm.tir.PrimExpr) – 最小值。
a_max (tvm.tir.PrimExpr) – 最大值。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.collapse_sum(data, target_shape)

返回数据到给定形状的求和结果。

collapse_sum 旨在作为自动微分过程中 topi 广播算子的反向算子。

我们预期数据是在某个广播操作中对目标形状张量进行广播后的结果。因此目标形状和数据形状必须遵循广播规则。

在计算过程中，会从右到左检查data.shape和target_shape的各个轴。对于每个轴，如果满足以下任一条件： - 该轴存在于data中但不存在于target_shape中，或者 - 在data中该轴大小大于1而在target_shape中等于1，则会对该轴上的数据进行求和。

Parameters:

data (tvm.te.Tensor) – 输入张量。
shape (Tuple[int]) – 要折叠成的形状。

Returns:

ret – 求和后的结果张量。

Return type:

tvm.te.Tensor

tvm.topi.concatenate(a_tuple, axis=0)

沿现有轴连接一系列数组。

Parameters:

a_tuple (tuple of tvm.te.Tensor) – 要连接的数组
axis (int, optional) – 数组将沿此轴连接。默认为0。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.const_vector(vector, name='const_vector')

将常量numpy一维向量转换为tvm张量

Parameters:

vector (numpy.ndarray) - 常量输入数组
name (str, optional) – 输出操作的名称

Returns:

tensor – 创建的张量

Return type:

Tensor

tvm.topi.cos(x)

计算输入x的余弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.cosh(x)

计算输入x的双曲余弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.cumprod(data: 张量, axis: int | None = None, dtype: int | None = None, exclusive: bool | None = None) → 张量

Numpy风格的cumprod操作。返回沿给定轴元素的累积乘积。

Parameters:

data (tvm.te.Tensor) – 操作符的输入数据。
axis (int, optional) – 计算累积乘积的轴。默认值(None)表示对展平的数组进行累积乘积计算。
dtype (string, optional) – 返回数组的类型以及元素相乘时使用的累加器类型。如果未指定dtype，则默认为数据的dtype。
exclusive (bool, optional) – 如果为True，将返回排他性乘积，其中不包含第一个元素。换句话说，如果为True，第j个输出元素将是前(j-1)个元素的乘积。否则，它将是前j个元素的乘积。

Returns:

结果 – 结果与数据大小相同，如果轴不为None，则形状也与数据相同。如果轴为None，则结果是一个一维数组。

Return type:

tvm.te.Tensor

tvm.topi.cumsum(data: 张量, axis: int | None = None, dtype: str | None = None, exclusive: bool | None = None) → 张量

Numpy风格的累加操作。返回沿给定轴元素的累积和。

Parameters:

data (tvm.te.Tensor) – 输入到算子的数据。
axis (int, optional) – 计算累积和的轴。默认值(None)表示对展平后的数组计算累积和。
dtype (string, optional) – 返回数组的类型以及元素求和时使用的累加器类型。如果未指定dtype，则默认为数据的dtype。
exclusive (bool, optional) – 如果为True，将返回不包含第一个元素的独占求和。换句话说，当设为True时，第j个输出元素将是前(j-1)个元素的和；否则将是前j个元素的和。

Returns:

结果 – 结果与数据大小相同，如果轴不为None则形状也与数据相同。如果轴为None，结果将是一个一维数组。

Return type:

tvm.te.Tensor

tvm.topi.decl_buffer(shape, dtype=None, name='buffer', data=None, strides=None, elem_offset=None, scope='', data_alignment=-1, offset_factor=0, buffer_type='', axis_separators=None, span=None)

声明一个新的符号缓冲区。

通常缓冲区会在加载和构建过程中自动创建。只有在用户希望指定自己的缓冲区布局时才需要此操作。

关于缓冲区的使用详情讨论，请参阅下方说明。

Parameters:

shape (tuple of Expr) – 缓冲区的形状。
dtype (str, optional) – 缓冲区的数据类型。
name (str, optional) – 缓冲区的名称。
data (tir.Var, optional) – 缓冲区中的数据指针。
strides (array of Expr) – 缓冲区的步长。
elem_offset (Expr, optional) – 数组数据起始偏移量。以dtype元素数量为单位。
scope (str, optional) – 缓冲区的存储作用域，如果不是全局的。如果scope等于空字符串，表示它是全局内存。
data_alignment (int, optional) – 数据指针的字节对齐方式。如果传入-1，对齐方式将被设置为TVM的内部默认值。
offset_factor (int, optional) – 偏移因子参数，当设置该参数时，要求elem_offset必须是offset_factor的倍数。如果传入0，对齐值将被设为1。如果传入非零值，当elem_offset不为None时，我们会为elem_offset创建一个变量。
buffer_type (str, optional, {"", "auto_broadcast"}) - auto_broadcast缓冲区允许实现广播计算而无需考虑维度大小是否等于1。如果维度j的形状等于1，TVM会将buffer[i][j][k]映射为buffer[i][0][k]。
axis_separators (list of int, optional) – 如果传入该参数，表示轴组之间的分隔符列表，每组轴会被展平为一个输出轴。对于扁平内存空间，该参数应为None或空列表。
span (可选[Span]) – 声明缓冲区在源代码中的创建位置。

Returns:

buffer – 创建的缓冲区

Return type:

tvm.tir.Buffer

注意

缓冲区数据结构反映了dlpack中的DLTensor结构。虽然DLTensor数据结构非常通用，但通常创建仅处理特定数据结构情况的函数会很有帮助，并使编译后的函数从中受益。

如果用户在构造函数时传递了strides参数而elem_offset参数为None，那么该函数将专门针对紧凑且对齐的DLTensor进行优化。如果用户传递一个完全通用的符号数组给strides参数，那么生成的函数将变成完全通用的。

tvm.topi.dft(re_data: 张量, im_data: 张量, inverse: IntImm)

计算输入的离散傅里叶变换（沿最后一个轴进行计算）。这给出了信号随时间变化的频率分量。

Parameters:

re_data (te.Tensor) – N维张量，输入信号的实部。
im_data (te.Tensor) – N维张量，输入信号的虚部。如果信号是实数，则该张量的值为零。
inverse (bool) – 是否执行逆离散傅里叶变换。

Returns:

re_output (te.Tensor) – 输入的傅里叶变换（实部）。
im_output (te.Tensor) – 输入的傅里叶变换（虚部）。

tvm.topi.div(a, b, span=None)

按照C/C++语义计算a / b。

Parameters:

a (PrimExpr) – 左侧操作数，已知为非负数。
b (PrimExpr) – 右侧操作数，已知为非负数。
span (可选[Span]) – 该操作符在源代码中的位置。

Returns:

res – 结果表达式。

Return type:

PrimExpr

注意

当操作数为整数时，返回 truncdiv(a, b, span)。

tvm.topi.divide(lhs, rhs)

支持自动广播的除法运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.dynamic_strided_slice(a, begin, end, strides, output_shape)

数组切片。

Parameters:

a (tvm.te.Tensor) – 要被切片的张量。
begin (tvm.te.Tensor) – 切片操作中起始的索引。
end (tvm.te.Tensor) – 表示切片结束位置的索引。
strides (tvm.te.Tensor) - 指定步长值，可以为负数。在这种情况下，输入张量将在该特定轴上反转。
output_shape (list of PrimExpr) – 指定输出形状

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.einsum(subscripts, *operand)

对操作数执行爱因斯坦求和约定。

Parameters:

subscripts (string) – 指定求和的标号，作为以逗号分隔的标号标签列表。除非包含明确的指示符'->'以及精确输出形式的标号标签，否则将执行隐式(经典爱因斯坦求和)计算。
a_tuple (tuple of tvm.te.Tensor) - 这些是运算的张量。 tvm和numpy中einsum的唯一区别是张量需要额外的括号。例如，topi.einsum("ij, jk -> ik", (A, B))。

Returns:

out – 基于爱因斯坦求和约定的计算结果。

Return type:

tvm.te.Tensor

tvm.topi.elemwise_sum(xs)

对输入执行逐元素求和

Parameters:: xs (list of tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.equal(lhs, rhs)

使用自动广播计算 (lhs==rhs)

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.erf(x)

对输入x取高斯误差函数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.exp(x)

对输入x取指数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.expand_dims(a, axis, num_newaxis=1)

扩展数组的形状。

Parameters:

a (tvm.te.Tensor) – 需要扩展的张量。
num_newaxis (int, optional) – 要在轴上插入的新轴数量

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.expand_like(a, shape_like, axis)

根据第二个数组的形状扩展输入数组。该操作始终可以通过在未压缩的轴上解压和扩展维度来实现。

示例

input = [ 12.  19.  27.]
input.shape = (3,)

new_shape_array = [[[1,2],[2,3],[1,3]],
                [[1,4],[4,3],[5,2]],
                [[7,1],[7,2],[7,3]]]
new_shape_array.shape = (3, 3, 2)

expand_like(input, [1,2], new_shape_array) =
                [[[12,12],[12,12],[12,12]],
                [[19,19],[19,19],[19,19]],
                [[27,27],[27,27],[27,27]]]

Parameters:

a (tvm.te.Tensor) – 需要扩展的张量。
shape_like (tvm.te.Tensor) – 具有目标形状的张量。
axis (list of int) – 需要扩展的轴

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.extern(shape, inputs, fcompute, name='extern', dtype=None, in_buffers=None, out_buffers=None, tag='', attrs=None)

通过外部函数计算多个张量。

Parameters:

shape (元组或列表的元组) – 输出的形状。
inputs (list of Tensor) – 输入张量列表
fcompute (lambda函数，参数为inputs和outputs-> stmt) –
指定执行计算的IR语句。关于fcompute的函数签名，请参阅以下说明
注意

参数
- ins (tvm.tir.Buffer列表) - 每个输入的占位符
- outs (tvm.tir.Buffer列表) - 每个输出的占位符
返回值
- stmt (tvm.tir.Stmt) - 执行数组计算的语句。
name (str, optional) – 张量的名称提示
dtype (str 或 list 包含 str，可选) – 输出的数据类型，默认情况下dtype将与输入保持一致。
in_buffers (tvm.tir.Buffer 或 list 的 tvm.tir.Buffer, 可选) – 输入缓冲区。
out_buffers (tvm.tir.Buffer or list of tvm.tir.Buffer, optional) – 输出缓冲区。

tag: str, optional: 关于计算的附加标签信息。
attrs: dict, optional: 关于计算的额外辅助属性。

Returns:: tensor – 创建的张量或张量元组包含多个输出。
Return type:: Tensor 或 list 的 Tensors

示例

在下面的代码中，C是通过调用外部PackedFunc tvm.contrib.cblas.matmul生成的

A = te.placeholder((n, l), name="A")
B = te.placeholder((l, m), name="B")
C = te.extern((n, m), [A, B],
               lambda ins, outs: tvm.tir.call_packed(
                  "tvm.contrib.cblas.matmul",
                    ins[0], ins[1], outs[0], 0, 0), name="C")

tvm.topi.eye(n: int, m: int | None = None, k: int = 0, dtype: str = 'float32') → 张量

生成一个单位矩阵或在第k条对角线上为1的矩阵。

Parameters:

n (int) – 行数
m (int, 可选) – 列数。如果为None，则默认为n。
k (int, optional) – 对角线的索引。0（默认值）表示主对角线。正值表示上对角线，负值表示下对角线。
dtype (str, optional) – 返回数组的数据类型。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.fast_erf(x)

使用fast_erf实现计算输入x的高斯误差函数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.fast_exp(x)

使用fast_exp实现计算输入x的指数

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.fast_tanh(x)

使用fast_tanh实现计算输入x的双曲正切值

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.fixed_point_multiply(x, multiplier, shift)

数据与定点常数之间的定点乘法运算，该常数表示为乘数 * 2^(-移位)，其中乘数是一个具有31位小数部分的Q数

Parameters:

x (tvm.te.Tensor 或 Expr) – 输入参数。
multiplier (int) – 定点浮点数的乘数，表示为multiplier*2^(-shift)。
shift (int) - 描述定点浮点数的位移量，表示为乘数*2^(-shift)。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.fixed_point_multiply_per_axis(x: 张量, y: 张量, lshift: 张量, rshift: 张量, is_lshift_required: int, is_rshift_required: int, axes)

数据与定点常数之间的定点乘法，该常数表示为乘数 * 2^(-移位)，其中乘数是一个具有31位小数部分的Q格式数

Parameters:

x (tvm.te.Tensor) – 输入参数。
y (tvm.te.Tensor) – 固定浮点数的乘数，表示为乘数*2^(-位移)。
lshift (tvm.te.Tensor) – 描述为乘数*2^(-shift)的定点浮点数的左移操作。
rshift (tvm.te.Tensor) – 描述为乘数*2^(-shift)的定点浮点数的右移操作。
is_lshift_required (int) – 是否需要执行左移操作。
is_rshift_required (int) – 是否需要执行右移操作。

Returns:

z – 结果。

Return type:

tvm.te.Tensor

tvm.topi.flip(a, axis=0)

沿特定轴翻转/反转数组元素。

Parameters:

a (tvm.te.Tensor) – 需要扩展的张量。
axis (int, optional) – 指定张量将被反转的轴向。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.floor(x)

取输入x的向下取整。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.floor_divide(lhs, rhs)

支持自动广播的向下取整除法

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.floor_mod(lhs, rhs)

支持自动广播的取模运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.floordiv(a, b, span=None)

计算两个表达式的向下取整除。

Parameters:

a (PrimExpr) – 左侧操作数
b (PrimExpr) – 右侧操作数
span (可选[Span]) – 该操作符在源代码中的位置。

Returns:

res – 结果表达式。

Return type:

PrimExpr

tvm.topi.floormod(a, b, span=None)

计算两个表达式的取模运算结果。

Parameters:

a (PrimExpr) – 左侧操作数
b (PrimExpr) – 右侧操作数
span (可选[Span]) – 该操作符在源代码中的位置。

Returns:

res – 结果表达式。

Return type:

PrimExpr

tvm.topi.full(shape, dtype, fill_value)

用fill_value填充张量

Parameters:

shape (tuple) – 输入张量的形状。
dtype (str) – 数据类型
fill_value (float) – 要填充的值

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.full_like(x, fill_value)

Construct a tensor with same shape as input tensor,: 然后用 fill_value 填充张量。

Parameters:

x (tvm.te.Tensor) – 输入参数。
fill_value (float) – 需要填充的值

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.gather(data, axis, indices)

从给定索引沿指定轴收集值。

例如对于一个3D张量，输出计算方式如下：

out[i][j][k] = data[indices[i][j][k]][j][k]  # if axis == 0
out[i][j][k] = data[i][indices[i][j][k]][k]  # if axis == 1
out[i][j][k] = data[i][j][indices[i][j][k]]  # if axis == 2

indices 的形状必须与 data 相同，除了在 axis 维度上该维度只需非空。输出形状将与 indices 相同。

Parameters:

data (tvm.te.Tensor) – 输入到算子的数据。
axis (int) – 指定沿哪个轴进行索引。
indices (tvm.te.Tensor) – 要提取的值的索引。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.gather_nd(a, indices, batch_dims=0)

从n维数组中收集元素。

Parameters:

a (tvm.te.Tensor) – 源数组。
indices (tvm.te.Tensor) – 要提取值的索引。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.get_const_tuple(in_tuple)

验证输入元组是否为IntImm或Var类型，返回整数或Var的元组。

Parameters:: in_tuple (tuple of Expr) – 输入参数。
Returns:: out_tuple – 输出结果。
Return type:: tuple 的 int

tvm.topi.greater(lhs, rhs)

计算(lhs>rhs)并自动进行广播操作

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.greater_equal(lhs, rhs)

计算(lhs>=rhs)并自动进行广播

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.identity(x)

获取输入x的标识。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.isfinite(x)

检查x的值是否有限，逐元素检查。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.isinf(x)

检查x的值是否为无穷大，逐元素进行。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.isnan(x)

检查x的值是否为NaN，逐个元素判断。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.layout_transform(array, src_layout, dst_layout, schedule_rule='None')

根据源布局和目标布局转换布局

Parameters:

array (tvm.te.Tensor) – 源数组。
src_layout (str) – 源布局。
dst_layout (str) – 目标布局。
schedule_rule (str) – 如果有的话，要应用的调度规则

tvm.topi.left_shift(lhs, rhs)

带自动广播的左移操作

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.less(lhs, rhs)

计算(lhs

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.less_equal(lhs, rhs)

使用自动广播计算 (lhs<=rhs)

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.log(x)

对输入x取对数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.log10(x)

对输入x取以10为底的对数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.log2(x)

对输入x取以2为底的对数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.logical_and(lhs, rhs)

计算数据的逐元素逻辑与。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.logical_not(data)

对数据进行逐元素的逻辑非运算。

Parameters:: data (tvm.te.Tensor 或 Expr)
Returns:: ret – 如果操作数是Expr则返回Expr，否则返回Tensor。
Return type:: tvm.te.Tensor 或表达式

tvm.topi.logical_or(lhs, rhs)

计算数据的逐元素逻辑或。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.logical_xor(lhs, rhs)

计算数据的逐元素逻辑异或。

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.make_idx(b, e, s, z, i)

返回选择数组中与完整数组中数组位置相对应的位置。

返回值只有在同一组参数的within_index()返回True时才有意义。

Parameters:

b (Expr) – 索引的起始位置
e (Expr) – 索引的结束位置
s (Expr) – 索引的步长
z (Expr) – 索引维度的尺寸
i (Expr) – 数组位置

Returns:

position – 对应于选择中数组位置的整数表达式。

Return type:

表达式

tvm.topi.matmul(a, b, transp_a=False, transp_b=False)

创建一个计算矩阵乘法的操作（行主序表示法）： A(i, k) * B(k, j) 如果trans_a == trans_b，则为常规转置组合，否则

Parameters:

a (矩阵A)
b (矩阵 B)
trans_a (A的布局是否转置？)
trans_b (B的布局是否转置？)

Return type:

一个张量，其操作成员是矩阵乘法运算

tvm.topi.matrix_set_diag(data, diagonal, k=0, align='RIGHT_LEFT')

返回一个张量，其中输入张量的对角线被替换为提供的对角线值。

Parameters:

data (tvm.te.Tensor) – 输入张量。
diagonal (tvm.te.Tensor) – 要填充到对角线上的值。
k (int 或 tuple 的 int, 可选) – 对角线偏移量。要设置的对角线或对角线范围(默认为0)。正值表示上对角线，0表示主对角线，负值表示下对角线。k可以是单个整数(表示单条对角线) 或指定矩阵带上下限的一对整数。 k[0]必须不大于k[1]。
align (string, optional) – 某些对角线比max_diag_len短，需要进行填充。 align是一个字符串，指定超对角线和次对角线应如何对齐。有四种可能的对齐方式："RIGHT_LEFT"（默认）、"LEFT_RIGHT"、 "LEFT_LEFT"和"RIGHT_RIGHT"。"RIGHT_LEFT"将超对角线向右对齐（左填充行）并将次对角线向左对齐（右填充行）。这是LAPACK使用的打包格式。 cuSPARSE使用"LEFT_RIGHT"，这是相反的对齐方式。

Returns:

result – 包含给定对角线值的新张量。

Return type:

tvm.te.Tensor

示例

data = [[[7, 7, 7, 7],
         [7, 7, 7, 7],
         [7, 7, 7, 7]],
        [[7, 7, 7, 7],
         [7, 7, 7, 7],
         [7, 7, 7, 7]]]

diagonal = [[1, 2, 3],
            [4, 5, 6]]

topi.matrix_set_diag(input, diagonal) =
    [[[1, 7, 7, 7],
      [7, 2, 7, 7],
      [7, 7, 3, 7]],
     [[4, 7, 7, 7],
      [7, 5, 7, 7],
      [7, 7, 6, 7]]]

tvm.topi.max(data, axis=None, keepdims=False)

计算给定轴或轴列表上数组元素的最大值

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None 或 int 或 tuple 包含 int) – 指定沿哪个轴或哪些轴执行最大值操作。默认值axis=None时，将从输入数组的所有元素中查找最大值。如果axis为负数，则从最后一个轴向第一个轴计数。
keepdims (bool) – 如果设置为True，被缩减的轴将保留在结果中作为大小为1的维度。通过此选项，结果将能够正确广播到输入数组。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.maximum(lhs, rhs)

对两个张量进行自动广播后的逐元素最大值计算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.meshgrid(a_tuple, indexing)

从坐标向量创建坐标矩阵。

Parameters:

a_tuple (tuple of tvm.te.Tensor) – 坐标向量或标量。
indexing (str) – 索引模式，可选"ij"或"xy"。

Returns:

result – 每个轴的最终网格结果。

Return type:

tuple 的 tvm.te.Tensor

tvm.topi.min(data, axis=None, keepdims=False)

计算给定轴或轴列表上数组元素的最小值

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None 或 int 或 tuple 包含 int) – 执行最小值操作所沿的轴。默认值 axis=None 将从输入数组的所有元素中查找最小元素。如果 axis 为负数，则从最后一个轴向第一个轴计数。
keepdims (bool) – 如果设置为True，被缩减的轴将保留在结果中作为大小为1的维度。通过此选项，结果将能够正确广播到输入数组。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.minimum(lhs, rhs)

对两个张量进行自动广播后的逐元素最大值计算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.mod(lhs, rhs)

支持自动广播的模运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.multiply(lhs, rhs)

支持自动广播的乘法运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.ndarray_size(array, dtype='int32')

获取输入数组的元素数量

Parameters:

array (tvm.te.Tensor) – 源张量。
dtype (str, 可选) – 目标数据类型。

Returns:

result – 结果张量。

Return type:

tvm.te.Tensor

tvm.topi.negative(x)

对输入x取反。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.not_equal(lhs, rhs)

使用自动广播计算(lhs!=rhs)

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.one_hot(indices, on_value, off_value, depth, axis, dtype)

返回一个独热张量，其中由索引表示的位置取值为on_value，其他位置取值为off_value。最终维度是<索引外部维度> x 深度 x <索引内部维度>。

Parameters:

indices (tvm.te.Tensor) – 要设置为on_value的位置。
on_value (tvm.te.Tensor) – 在索引位置填充的值。
off_value (tvm.te.Tensor) – 除索引位置外所有其他位置需要填充的值。
depth (int) – 独热编码维度的深度。
axis (int) – 要填充的轴。
dtype (str) – 输出张量的数据类型。

Returns:

ret – 独热编码张量。

Return type:

tvm.te.Tensor

示例

indices = [0, 1, 2]

topi.one_hot(indices, 3) =
    [[1, 0, 0],
     [0, 1, 0],
     [0, 0, 1]]

tvm.topi.power(lhs, rhs)

支持自动广播的幂运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.prod(data, axis=None, keepdims=False)

计算数组元素沿给定轴或轴列表的乘积

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None 或 int 或 tuple 包含 int) – 指定进行乘积运算的轴。默认值axis=None时，将对输入数组的所有元素进行乘积运算。如果axis为负数，则从最后一个轴开始倒数。
keepdims (bool) – 如果设置为True，被缩减的轴将保留在结果中作为大小为1的维度。通过此选项，结果将能够正确广播到输入数组。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.reinterpret(x, dtype)

将输入重新解释为指定的数据类型。

Parameters:

x (tvm.te.Tensor) – 输入参数。
dtype (str) – 数据类型。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.repeat(a, repeats, axis)

重复数组中的元素。

Parameters:

a (tvm.te.Tensor) – 需要重复的张量。
repeats (int, required) - 每个元素的重复次数
axis (int, optional) – 指定沿哪个轴重复数值

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.reshape(a, newshape)

重塑数组

Parameters:

a (tvm.te.Tensor) – 需要重塑形状的张量
newshape (tuple of ints) – 新的形状

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.reverse_sequence(a, seq_lengths, seq_axis=1, batch_axis=0)

对可变长度切片进行张量反转。输入首先沿着批次轴切片，然后沿着序列轴反转元素。

Parameters:

a (tvm.te.Tensor) – 需要反转的张量。
seq_lengths (tvm.te.Tensor) – 一个一维张量，长度为a.dims[batch_axis] 必须是以下类型之一：int32, int64 如果seq_lengths[i] > a.dims[seq_axis]，则会被舍入为a.dims[seq_axis] 如果seq_lengths[i] < 1，则会被舍入为1
seq_axis (int, optional) – 元素将被反转的轴。默认为1。
batch_axis (int, optional) – 指定张量将被切分的轴向。默认值为0。

Returns:

ret – 与输入形状和类型相同的计算结果。

Return type:

tvm.te.Tensor

tvm.topi.right_shift(lhs, rhs)

带自动广播的右移操作

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.round(x)

将x的元素四舍五入到最接近的整数。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.rsqrt(x)

对输入x取反平方根。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.scanop(data: 张量, binop: 可调用[[tvm.Expr, tvm.Expr], tvm.Expr], identity_value: tvm.Expr, op_name: str, axis: int | None = None, dtype: str | None = None, exclusive: bool | None = None) → 张量

具有类似np.cumsum和np.cumprod轴行为的累积二元运算符(scan)。

关于使用示例，请参见 cumprod 和 cumsum。

例如，如果 * 是您的二元运算符，输入张量为 [1, 2, 3, 4]，则输出可能是 [1, 1 * 2, 1 * 2 * 3, 1 * 2 * 3 * 4]

Parameters:

data (tvm.te.Tensor) – 输入到算子的数据。
binop (Callable (tvm.Expr, tvm.Expr) -> tvm.Expr) – 一个二元运算符，需要满足结合律和交换律。例如，如果*是运算符，那么a * (b * c) = (a * b) * c且a * b = b * a
identity_value (tvm.Expr) – 为二元操作提供恒等属性的值。例如，如果 * 是运算符且 i 是 identity_value，那么对于操作定义域中的所有 a 都有 a * i = a。
axis (int, optional) – 指定计算操作的轴向。默认值(None)表示对展平后的数组进行累积计算。
dtype (string, optional) – 返回数组的类型以及计算元素时使用的累加器类型。如果未指定dtype，则默认为数据的dtype。
exclusive (bool, optional) – 如果为True，将返回排他性累积操作，其中不包含第一个元素。换句话说，如果为True，第j个输出元素将是前(j-1)个元素的累积操作结果；否则将是前j个元素的累积操作结果。零个元素的累积操作默认为identity_value。

Returns:

结果 – 结果与数据大小相同，如果轴不为None则形状也与数据相同。如果轴为None，结果将是一个一维数组。

Return type:

tvm.te.Tensor

tvm.topi.scatter_elements(data, indices, updates, axis=0, reduction='update')

将更新中的元素分散到复制数据的对应索引位置。

数据、索引、更新和输出具有相同的形状。当reduction == "update"时，索引不能有重复项（如果idx1 != idx2，则indices[idx1] != indices[idx2]）

output[indices[i][j]][j] = f(output[indices[i][j]][j], updates[i][j]) if axis = 0
output[i][indices[i][j]] = f(output[i][indices[i][j]], updates[i][j]) if axis = 1

其中更新函数f由归约操作决定。支持五种函数类型："update"、"add"、"mul"、"min"和"max"（如下所示）

Parameters:

data (tvm.te.Tensor) – 源数组。
indices (tvm.te.Tensor) – 要提取值的索引。
updates (tvm.te.Tensor) – 要在索引处应用的更新
axis (可选参数, int) – 指定进行scatter操作的轴，默认为0。
reduction (可选, 字符串) – 算法的更新模式，可选值为"update"、"add"、"mul"、"min"或"max" 如果选择update，更新值将替换输入数据如果选择add，更新值将被加到输入数据上如果选择mul，输入数据将与更新值相乘如果选择mean，输入数据将是更新值与输入数据的平均值如果选择min，将在更新值和输入数据之间选择最小值如果选择max，将在更新值和输入数据之间选择最大值默认为"update"

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.scatter_nd(data, indices, updates, mode)

从n维数组中分散元素。

给定形状为(Y_0, ..., Y_{K-1}, X_M, ..., X_{N-1})的更新数据，形状为(M, Y_0, ..., Y_{K-1})的索引，以及从形状为(X_0, X_1, ..., X_{N-1})的数据复制的输出，scatter_nd计算

output[indices[0, y_0, ..., y_{K-1}],
       ...,
       indices[M-1, y_0, ..., y_{K-1}],
       x_M,
       ...,
       x_{N-1}
      ] = f(output[...], updates[y_0, ..., y_{K-1}, x_M, ..., x_{N-1}])

其中更新函数f由模式决定。

Parameters:

data (tvm.te.Tensor) – 源数组。
indices (tvm.te.Tensor) – 要提取值的索引。
updates (tvm.te.Tensor) – 要在索引处应用的更新
mode (string) – 算法的更新模式，可选"update"或"add" 如果选择update，更新值将替换输入数据如果选择add，更新值将被添加到输入数据中

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.searchsorted(sorted_sequence, values, right=False, out_dtype='int64')

Find indices where elements should be inserted to maintain order.: 如果sorted_sequence是N维的，则会在sorted_sequence对应的维度中搜索values的最内层维度。

Parameters:

sorted_sequence (te.Tensor) – N维或1维张量，在最内层维度上包含单调递增的序列
values (te.Tensor) - 包含搜索值的N维张量。当sorted_sequence是一维时，values的形状可以是任意的。否则，sorted_sequence和values的秩必须相同，且外部的N-1个轴必须具有相同的大小。
right (bool, optional) – 控制当值恰好落在排序值之一时返回哪个索引。如果为False，则返回找到的第一个合适位置的索引。如果为true，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是最内层维度的大小）。
dtype (string, optional) – 输出索引的数据类型。

Returns:

indices – 与values形状相同的张量，表示如果将values元素插入到sorted_sequence中时对应的索引位置。

Return type:

te.Tensor

tvm.topi.sequence_mask(data, valid_length, mask_value=0, axis=0)

将序列预期长度之外的所有元素设置为一个常量值。

该函数接收一个n维输入数组，形式为[MAX_LENGTH, batch_size, …]或[batch_size, MAX_LENGTH, …]，并返回一个相同形状的数组。

axis 表示长度维度的轴，只能是0或1。如果 axis 为0，数据必须具有形状 [MAX_LENGTH, batch_size, ...]。否则（axis=1），数据必须具有形状 [batch_size, MAX_LENGTH, ...]。

valid_length 给出每个序列的长度。valid_length 应该是一个包含正整数的一维整型数组，其维度为 [batch_size,]。

Parameters:

data (tvm.te.Tensor) – N维张量，形状为[MAX_LENGTH, batch_size, ...]或[batch_size, MAX_LENGTH, ...]，具体取决于axis的值。
valid_length (tvm.te.Tensor) – 一维张量，形状为 [batch_size,]
mask_value (float, optional) – 掩码值，默认为0
axis (int, optional) – 长度维度的轴，必须是0或1，默认为0

Returns:

输出 – N维数组，形状为[MAX_LENGTH, batch_size, …] 或 [batch_size, MAX_LENGTH, …]，具体取决于axis参数的值。

Return type:

tvm.te.Tensor

tvm.topi.shape(array, dtype='int32')

获取输入数组的形状

Parameters:

array (tvm.te.Tensor) – 源张量。
dtype (str, 可选) – 目标数据类型。

Returns:

result – 结果张量。

Return type:

tvm.te.Tensor

tvm.topi.sigmoid(x)

对输入x取sigmoid tanh函数值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.sign(x)

根据x的符号返回-1、0或1。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.sin(x)

计算输入x的正弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.sinh(x)

计算输入x的双曲正弦值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.sliding_window(data, axis, window_shape, strides)

在数据张量上滑动窗口。

Parameters:

data (tvm.te.Tensor) – 输入到算子的数据。
axis (int) – 指定窗口开始滑动的轴。窗口将沿着该轴及其后续所有轴进行滑动。该轴的值决定了窗口的形状（进而决定步长数量）：窗口形状和步长必须都是data.ndim-axis的长度。
window_shape (List[int]) – 在输入数据上形成的窗口形状。窗口形状的长度必须等于data.ndim-axis。
strides (List[int]) – 窗口沿每个维度的步长。步长长度必须等于data.ndim-axis。

Returns:

result – 结果张量。

Return type:

tvm.te.Tensor

tvm.topi.sort(data, axis=-1, is_ascend=1)

沿着给定轴执行排序操作，并返回按排序顺序排列的数组。

Parameters:

data (tvm.te.Tensor) – 输入张量。
axis (int, optional) – 指定沿哪个轴对输入张量进行排序。默认使用展平的数组。
is_ascend (boolean, optional) – 指定按升序还是降序排序。
dtype (string, optional) – 输出索引的数据类型。

Returns:

out – 排序后的索引张量。

Return type:

tvm.te.Tensor

tvm.topi.sparse_reshape(sparse_indices, prev_shape, new_shape, new_sparse_indices_shape, new_shape_shape)

重塑稀疏张量

Parameters:

sparse_indices (te.Expr) – 一个二维整数张量[N, n_dim]，包含稀疏值的位置，其中N是稀疏值的数量，n_dim是dense_shape的维度数
prev_shape (te.Expr) – 一个包含稠密张量先前形状的一维张量
new_shape (te.Expr) – 一个一维张量，包含稠密张量的新形状

Returns:

result – 输出张量。

Return type:

te.Expr

示例

sparse_indices = [[0, 0, 0],
                    [0, 0, 1],
                    [0, 1, 0],
                    [1, 0, 0],
                    [1, 2, 3]]
prev_shape = [2, 3, 4]
new_shape = [9, -1]
new_sparse_indices, new_shape = topi.sparse_reshape(
    sparse_indices, prev_shape, new_shape)
new_sparse_indices = [[0, 0],
                      [0, 1],
                      [1, 2],
                      [4, 2],
                      [8, 1]]
new_shape = [9, 4]

tvm.topi.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value=0)

将稀疏表示转换为密集张量。

示例:: - sparse_to_dense([[0, 0], [1, 1]], [2, 2], [3, 3], 0) = [[3, 0], [0, 3]]

Parameters:

sparse_indices (tvm.te.Tensor) – 一个0维、1维或2维的整数张量，包含稀疏值的位置。
output_shape (一个整数列表) – 密集输出张量的形状。
sparse_values (tvm.te.Tensor) – 一个0维或1维张量，包含稀疏索引对应的稀疏值。
default_value (tvm.te.Tensor) – 一个0维张量，包含剩余位置的默认值。默认为0。

Returns:

result – 形状为output_shape的密集张量。与sparse_values具有相同类型。

Return type:

tvm.te.Tensor

tvm.topi.split(ary, indices_or_sections, axis=0)

将一个数组分割成多个子数组。

Parameters:

ary (tvm.te.Tensor)
indices_or_sections (int 或 一维数组)
axis (int)

Returns:

返回值

Return type:

tuple 的 tvm.te.Tensor

tvm.topi.sqrt(x)

对输入x取平方根。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.squeeze(a, axis=None)

从数组的形状中移除单维度条目。

Parameters:

a (tvm.te.Tensor)
axis (None 或 int 或 tuple 的 ints, 可选) – 选择形状中一维条目的子集。如果选择的轴对应的形状条目大于1，则会引发错误。

Returns:

压缩

Return type:

tvm.te.Tensor

tvm.topi.stack(a, axis)

将整个数组重复多次。

Parameters:

a (tvm.te.Tensor) – 需要堆叠的张量。
axis (int, optional) – 结果数组中输入数组堆叠所沿的轴。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.stft(data, n_fft, hop_length, win_length, window, normalized, onesided, output_shape)

STFT计算输入信号短时重叠窗口的傅里叶变换。这可以获取信号随时间变化的频率成分。 :param data: 一维张量或二维批次张量 :type data: te.Tensor :param n_fft: 傅里叶变换的尺寸 :type n_fft: int :param hop_length: 相邻滑动窗口帧之间的距离 :type hop_length: int :param win_length: 窗口帧和STFT滤波器的大小 :type win_length: int :param window: 一维张量窗口帧 :type window: te.Tensor :param normalized: 是否返回归一化的STFT结果 :type normalized: bool :param onesided: 是否返回单边结果或使用共轭对称填充 :type onesided: bool

Returns:: output - 包含STFT结果的张量
Return type:: te.Tensor

示例

data = [1, 2, 3, 4, 5, 6]
window = [4, 3, 2]
[n_fft, hop_length, win_length, normalized, onesided] = [3, 3, 3, False, True]
topi.stft(data, n_fft, hop_length, win_length, window, normalized, onesided)
-> [[[15.0000,  0.0000], [34.0000,  0.0000]], [[ 4.5000,  0.8660], [ 1.0000, -1.7321]]]

tvm.topi.strided_set(a, v, begin, end, strides=None)

设置数组的切片。

Parameters:

a (tvm.te.Tensor) – 要被切片的张量。
v (tvm.te.Tensor) – 要设置的值
begin (tvm.te.Tensor) – 切片操作中起始的索引。
end (tvm.te.Tensor) – 表示切片结束位置的索引。
strides (tvm.te.Tensor, optional) – 指定步长值，可以为负数。在这种情况下，输入张量将在特定轴上进行反转。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.strided_slice(a, begin, end, strides=None, axes=None, slice_mode='end', assume_inbound=True)

数组切片。

Parameters:

a (tvm.te.Tensor) – 要被切片的张量。
begin (list of int) – 切片操作的起始索引列表。
end (list of int) – 表示切片结束位置的索引列表。
strides (list of int, optional) - 指定步长值，可以为负数。在这种情况下，输入张量将在特定轴上反转。
axes (list of int, optional) – 指定切片操作所沿的轴。当该参数被指定时，begin、end、strides和axes需要是相同长度的整数列表。
slice_mode (str, optional) – 切片模式 [end, size]。 end - 切片的结束索引 [默认模式]。 size - 将忽略输入步长，在此模式下输入end表示从begin指定位置开始的切片大小。如果end[i]为-1，则该维度中所有剩余元素都将包含在切片中。
assume_inbound (bool, optional) – 一个标志位，用于指示是否假定所有索引都在边界内

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.subtract(lhs, rhs)

支持自动广播的减法运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.sum(data, axis=None, keepdims=False)

沿给定轴或轴列表的数组元素求和

Parameters:

data (tvm.te.Tensor) – 输入的tvm张量
axis (None or int or tuple of int) – 执行求和操作的轴或轴组。默认值axis=None将对输入数组的所有元素求和。如果axis为负数，则从最后一个轴开始倒数。
keepdims (bool) – 如果设置为True，被缩减的轴将保留在结果中作为大小为1的维度。通过此选项，结果将能够正确广播到输入数组。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.take(a, indices, axis=None, batch_dims=0, mode='clip')

沿轴从数组中提取元素。

Parameters:

a (tvm.te.Tensor) – 源数组。
indices (tvm.te.Tensor) – 要提取值的索引。
axis (int, optional) – 选择数值所沿的轴。默认情况下，使用展平的输入数组。
batch_dims (int) – 批处理维度的数量。默认为0。
mode (str, optional) - 指定越界索引的处理方式。 clip - 裁剪到范围内（默认） wrap - 循环索引 fast - 不裁剪也不循环（用户需确保索引在范围内）

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.tan(x)

计算输入x的正切值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.tanh(x)

对输入x取双曲正切tanh。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.tensordot(a, b, axes)

将矩阵乘法推广到张量。

Parameters:

a (张量A)
b (张量B)
axes (要缩减的维度数量)

Return type:

一个计算结果的张量

tvm.topi.tile(a, reps)

将整个数组重复多次。

Parameters:

a (tvm.te.Tensor) – 需要进行平铺操作的张量。
reps (tuple of ints, required) - 张量重复的次数

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.topk(data, k=1, axis=-1, ret_type='both', is_ascend=False, dtype='int64')

获取输入张量沿给定轴的前k个元素。

Parameters:

data (tvm.te.Tensor) – 输入张量。
k (int 或 tvm.te.Tensor, 可选) – 要选择的顶部元素数量。如果k小于1则返回所有元素。
axis (int, optional) – 指定沿哪个轴对输入张量进行排序。
ret_type (str, optional) – 返回类型 [both, values, indices]。 "both": 同时返回前k个数据和索引。 "values": 仅返回前k个数据。 "indices": 仅返回前k个索引。
is_ascend (boolean, optional) – 指定按升序还是降序排序。
dtype (string, optional) – 索引输出的数据类型。

Returns:

out – 计算结果。

Return type:

tvm.te.Tensor 或 List[tvm.te.Tensor]

tvm.topi.transpose(a, axes=None)

对数组的维度进行置换。

Parameters:

a (tvm.te.Tensor) – 需要扩展的张量。
axes (tuple of ints, optional) – 默认情况下，反转维度。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.trilu(data, k, upper)

给定一个二维矩阵或批量二维矩阵，返回张量的上三角或下三角部分。

Parameters:

data (tvm.te.Tensor) – 将应用trilu运算的张量。必须是二维矩阵或二维矩阵批次的张量。
k (tvm.te.Tensor) – 要排除或包含的主对角线之上或之下的对角线数量。
upper (bool) – 如果为True，则只保留输入矩阵的上三角部分值；如果为False，则保留下三角部分值。

Returns:

ret – 新的张量，其适当对角线被设为零。

Return type:

tvm.te.Tensor

示例

x = [[0, 1, 2],
     [3, 4, 5],
     [6, 7, 8]]

topi.trilu(x, True, 0) =
    [[0, 1, 2],
     [0, 4, 5],
     [0, 0, 8]]

tvm.topi.trunc(x)

对输入x的每个元素取截断值。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.unravel_index(indices, shape)

将平面索引或平面索引数组转换为坐标数组的元组。

示例:: - unravel_index([22, 41, 37], [7, 6]) = [[3, 6, 6], [4, 5, 1]]

Parameters:

indices (tvm.te.Tensor) – 一个包含索引的整数数组。
shape (tvm.te.Tensor) – 数组的形状。

Returns:

result – 坐标数组的元组。

Return type:

tvm.te.Tensor

tvm.topi.where(condition, x, y)

根据条件从x或y中获取元素。

Parameters:

condition (tvm.te.Tensor) – 条件数组。
x (tvm.te.Tensor) – 待选择的第一个数组。
y (tvm.te.Tensor) – 第二个待选择的数组。

Returns:

result – 根据条件从x或y中选择的张量。

Return type:

tvm.te.Tensor

tvm.topi.within_index(b, e, s, i)

返回一个布尔值，表示i是否在给定的索引范围内。

Parameters:

b (Expr) – 索引的起始位置
e (Expr) – 索引的结束位置
s (Expr) – 索引的步长
i (Expr) – 数组位置

Returns:

selected – 布尔表达式，当数组位置被索引选中时为True，否则为False

Return type:

表达式

exception tvm.topi.InvalidShapeError: topi函数的形状无效。例如为非3x3内核调用winograd模板)

tvm.topi.nn

神经网络算子

类：

工作负载(in_dtype, out_dtype, height, width, ...)

功能：

`adaptive_pool`(data, output_size, pool_type)	对数据的高度和宽度维度执行池化操作。
`adaptive_pool1d`(data, output_size, pool_type)	对三维数据进行池化操作。
`adaptive_pool3d`(data, output_size, pool_type)	对三维数据进行池化操作。
`add`(lhs, rhs)	支持自动广播的加法运算
`batch_matmul`(tensor_a, tensor_b[, oshape, ...])	计算tensor_a和tensor_b的批量矩阵乘法。
`batch_norm`(data, gamma, beta, moving_mean, ...)	批量归一化层（Ioffe和Szegedy，2014年提出）。
`batch_to_space_nd`(data, block_shape, ...)	对数据执行空间到批量的转换
`binarize_pack`(data[, axis, name])	沿特定轴进行二值化和位打包。
`binary_dense`(data, weight)	使用异或和位计数进行二进制矩阵乘法。
`bitpack`(data, bits, pack_axis, bit_axis, ...)	将数据打包为位串行计算所需的格式
`bitserial_conv2d_nchw`(data, kernel, stride, ...)	Bitserial Conv2D 算子。
`bitserial_conv2d_nhwc`(data, kernel, stride, ...)	比特串行Conv2D算子。
`bitserial_dense`(data, weight, data_bits, ...)	topi中bitserial dense的默认实现。
`concatenate`(a_tuple[, axis])	沿现有轴连接一系列数组。
`conv`(inp, filt, stride, padding, dilation, ...)	NCHW或NHWC布局中的卷积算子。
`conv1d`(data, kernel[, strides, padding, ...])	一维卷积前向算子。
`conv1d_ncw`(data, kernel[, strides, padding, ...])	NCW布局中的一维卷积。
`conv1d_nwc`(data, kernel[, strides, padding, ...])	NWC布局中的一维卷积。
`conv1d_transpose_ncw`(data, kernel, stride, ...)	转置一维卷积ncw前向算子。
`conv2d`(input, filter, strides, padding, dilation)	Conv2D 运算符。
`conv2d_NCHWc`(data, kernel, stride, padding, ...)	适用于nChw[x]c布局的Conv2D算子。
`conv2d_NCHWc_int8`(data, kernel, stride, ...)	适用于nChw[x]c布局的Conv2D算子。
`conv2d_hwcn`(Input, Filter, stride, padding, ...)	HWCN布局中的卷积算子。
`conv2d_nchw`(Input, Filter, stride, padding, ...)	NCHW布局中的卷积算子。
`conv2d_nhwc`(Input, Filter, stride, padding, ...)	NHWC布局中的卷积算子。
`conv2d_transpose_nchw`(Input, Filter, ...)	转置二维卷积nchw前向算子。
`conv2d_transpose_nchw_preprocess`(data, ...)	预处理数据和内核，使conv2d_transpose的计算模式与conv2d相同
`conv2d_winograd_nchw`(data, weight, strides, ...)	NCHW布局中的Conv2D Winograd。
`conv2d_winograd_nchw_without_weight_transform`(...)	在NCHW布局中不进行布局转换的Conv2D Winograd。
`conv2d_winograd_nhwc`(data, weight, strides, ...)	NHWC布局中的Conv2D Winograd。
`conv2d_winograd_nhwc_without_weight_transform`(...)	在NHWC布局中无需进行布局转换的Conv2D Winograd。
`conv2d_winograd_weight_transform`(kernel, ...)	Winograd的权重变换
`conv3d_ncdhw`(Input, Filter, stride, padding, ...)	NCDHW布局中的Conv3D算子。
`conv3d_ndhwc`(Input, Filter, stride, padding, ...)	NDHWC布局中的卷积算子。
`conv3d_transpose_ncdhw`(Input, Filter, ...)	转置3D卷积ncdhw前向算子。
`conv3d_transpose_ncdhw_preprocess`(data, ...)	预处理数据和内核，使conv3d_transpose的计算模式与conv3d相同
`conv3d_winograd_weight_transform`(kernel, ...)	3D Winograd的权重变换
`correlation_nchw`(data1, data2, kernel_size, ...)	NCHW布局中的相关性运算符。
`declaration_conv2d_transpose_impl`(data, ...)	实现conv2d转置操作
`declaration_conv3d_transpose_impl`(data, ...)	conv3d转置的实现
`deformable_conv2d_nchw`(data, offset, kernel, ...)	NCHW布局中的可变形conv2D算子。
`deformable_conv2d_nhwc`(data, offset, kernel, ...)	NHWC布局中的可变形conv2D算子。
`dense`(data, weight[, bias, out_dtype, ...])	topi中dense的默认实现。
`dense_pack`(data, weight[, bias, out_dtype])	topi中dense_pack的默认实现。
`depth_to_space`(data, block_size[, layout, mode])	对数据执行深度到空间的转换
`depthwise_conv2d_NCHWc`(Input, Filter, ...[, ...])	深度卷积NCHW[x]c前向算子。
`depthwise_conv2d_backward_input_nhwc`(Filter, ...)	深度卷积 nhwc 反向输入算子。
`depthwise_conv2d_backward_weight_nhwc`(Input, ...)	深度卷积nhwc对权重的反向传播算子。
`depthwise_conv2d_nchw`(Input, Filter, stride, ...)	深度可分离卷积nchw前向算子。
`depthwise_conv2d_nhwc`(Input, Filter, stride, ...)	深度卷积nhwc前向算子。
`dilate`(data, strides[, dilation_value, name])	使用给定的膨胀值（默认为0）对数据进行膨胀处理。
`equal_const_int`(expr, value)	如果expr等于value则返回。
`fast_softmax`(x[, axis])	对数据进行softmax激活。
`fifo_buffer`(数据, 缓冲区, 轴)	FIFO缓冲区，用于在具有滑动窗口输入的CNN中实现计算重用
`flatten`(data)	通过折叠更高维度将输入数组展平为二维数组。
`get_const_int`(expr)	验证表达式是否为整数并获取其常量值。
`get_const_tuple`(in_tuple)	验证输入元组是否为IntImm或Var类型，返回整数或Var的元组。
`get_pad_tuple`(padding, kernel)	获取填充选项的通用代码
`get_pad_tuple1d`(padding, kernel)	获取填充选项的通用代码
`get_pad_tuple3d`(padding, kernel)	获取填充选项的通用代码
`get_pad_tuple_generic`(padding, kernel)	获取填充选项的通用代码
`global_pool`(data, pool_type[, layout])	对数据的高度和宽度维度执行全局池化。
`group_conv1d_ncw`(data, kernel[, strides, ...])	针对NCW布局的一维卷积前向算子。
`group_conv1d_nwc`(data, kernel[, strides, ...])	针对NWC布局的一维卷积前向算子。
`group_conv1d_transpose_ncw`(data, kernel, ...)	转置的一维分组卷积 ncw 前向算子。
`group_conv2d_nchw`(Input, Filter, stride, ...)	NCHW布局中的分组卷积算子。
`group_conv2d_nhwc`(Input, Filter, stride, ...)	NHWC布局中的分组卷积算子。
`group_conv2d_transpose_nchw`(data, kernel, ...)	NCHW布局中的分组卷积算子。
`group_conv3d_transpose_ncdhw`(data, kernel, ...)	转置分组3D卷积ncdhw前向算子。
`leaky_relu`(x, alpha)	对输入x进行leaky relu处理。
`log_softmax`(x[, axis])	对数据执行对数softmax激活
`lrn`(data, size[, axis, alpha, beta, bias])	对输入数据执行跨通道局部响应归一化。
`lstm`(Xs, Wi, Wh[, Bi, Bh, h_init, c_init, ...])	使用TE扫描实现的通用LSTM。
`matmul`(tensor_a, tensor_b[, bias, ...])	topi中matmul的默认实现。
`mirror_pad`(data, pad_before[, pad_after, ...])	使用对称或反射镜像对输入进行填充。
`namedtuple`(typename, field_names, *[, ...])	返回一个具有命名字段的元组新子类。
`nll_loss`(predictions, targets, weights, ...)	输入数据的负对数似然损失。
`pad`(data, pad_before[, pad_after, ...])	用零填充输入。
`pool1d`(data, kernel, stride, dilation, ...)	对数据的宽度维度执行池化操作。
`pool2d`(data, kernel, stride, dilation, ...)	对数据的高度和宽度维度执行池化操作。
`pool3d`(data, kernel, stride, dilation, ...)	对数据的深度、高度和宽度维度进行池化操作。
`pool_grad`(grads, data, kernel, stride, ...)	数据在高度和宽度维度上的池化梯度。
`prelu`(x, slope[, axis])	PReLU。
`reduce`(function, sequence[, initial])	对一个序列中的元素从左到右累积应用一个双参数函数，从而将序列缩减为单个值。
`relu`(x)	对输入x进行relu操作。
`scale_shift_nchw`(Input, Scale, Shift)	推理中的批量归一化算子。
`scale_shift_nchwc`(Input, Scale, Shift)	推理中的批量归一化算子。
`scale_shift_nhwc`(Input, Scale, Shift)	推理中的批量归一化算子。
`simplify`(expr)	如果是Expr类型则简化表达式，如果是int类型则直接返回。
`simulated_dequantize`(data, in_dtype[, ...])	模拟QNN去量化操作符，在不改变数据类型的情况下模拟QNN输出。
`simulated_quantize`(data, out_dtype[, ...])	模拟QNN量化操作符，在不改变数据类型的情况下模仿QNN输出。
`softmax`(x[, 轴])	对数据进行softmax激活。
`softmax_common`(x, axis, use_fast_exp)	softmax和fast_softmax的公共部分
`softplus`(x[, beta, threshold])	为输入x计算具有数值稳定性的Softplus激活函数。
`space_to_batch_nd`(data, block_shape, ...[, ...])	对数据进行批量到空间的转换
`space_to_depth`(数据, 块大小[, 布局])	对数据进行空间到深度的转换
`strided_slice`(a, begin, end[, strides, ...])	数组切片。
`unpack_NCHWc_to_nchw`(packed_out, out_dtype)	将conv2d_NCHWc的输出从NCHWc布局解包为NCHW布局
`upsampling`(data, scale_h, scale_w[, layout, ...])	对数据进行上采样。
`upsampling3d`(data, scale_d, scale_h, scale_w)	对数据进行上采样。
`winograd_transform_matrices`(tile_size, ...)	计算针对 tile_size 作为 tvm.Expr 的 A、B 和 G 变换矩阵。
`instance_norm`(data, gamma, beta, axis[, epsilon])	实例归一化算子。
`layer_norm`(data, gamma, beta, axis[, epsilon])	层归一化算子。
`group_norm`(data, gamma, beta, num_groups, ...)	分组归一化操作符。
`rms_norm`(data, weight, axis[, epsilon])	均方根归一化运算符。

class tvm.topi.nn.Workload(in_dtype, out_dtype, height, width, in_filter, out_filter, kernel_h, kernel_w, padt, padl, padb, padr, dilation_h, dilation_w, stride_h, stride_w)

属性：

`dilation_h`	字段编号12的别名
`dilation_w`	字段编号13的别名
`height`	字段编号2的别名
`in_dtype`	字段编号0的别名
`in_filter`	字段编号4的别名
`kernel_h`	字段编号6的别名
`kernel_w`	字段编号7的别名
`out_dtype`	字段编号1的别名
`out_filter`	字段编号5的别名
`padb`	字段编号10的别名
`padl`	字段编号9的别名
`padr`	字段编号11的别名
`padt`	字段编号8的别名
`stride_h`	字段编号14的别名
`stride_w`	字段编号15的别名
`width`	字段编号3的别名

dilation_h: 字段编号12的别名

dilation_w: 字段编号13的别名

height: 字段编号2的别名

in_dtype: 字段编号0的别名

in_filter: 字段编号4的别名

kernel_h: 字段编号6的别名

kernel_w: 字段编号7的别名

out_dtype: 字段编号1的别名

out_filter: 字段编号5的别名

padb: 字段编号10的别名

padl: 字段编号9的别名

padr: 字段编号11的别名

padt: 字段编号8的别名

stride_h: 字段编号14的别名

stride_w: 字段编号15的别名

width: 字段编号3的别名

tvm.topi.nn.adaptive_pool(data, output_size, pool_type, layout='NCHW')

Perform pooling on height and width dimension of data.: 池化核和步长大小会根据期望的输出尺寸自动选择。它根据布局字符串决定高度和宽度维度，其中'W'和'H'分别表示宽度和高度。宽度和高度维度不能被分割。例如，NCHW、NCHW16c等对池化操作有效，而NCHW16w、NCHW16h则无效。有关布局字符串约定的更多信息，请参阅参数layout。

Parameters:

data (tvm.te.Tensor) – n维张量，具有指定布局的形状
output_size (tuple of int) – 输出的高度和宽度。
pool_type (str) – 池化类型，'max'或'avg'
layout (string) – 输入数据的布局格式。该布局应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母带因子大小表示切分维度。例如，NCHW16c可以描述一个5维张量 [batch_size, channel, height, width, channel_block]，其中channel_block=16是通道维度的切分。

Returns:

输出 – 相同布局的n维

Return type:

tvm.te.Tensor

tvm.topi.nn.adaptive_pool1d(data, output_size, pool_type, layout='NCW'): 对三维数据进行池化操作。详情请参阅上方的二维版本。

tvm.topi.nn.adaptive_pool3d(data, output_size, pool_type, layout='NCDHW'): 对三维数据进行池化操作。详情请参阅上方的二维版本。

tvm.topi.nn.add(lhs, rhs)

支持自动广播的加法运算

Parameters:

lhs (tvm.te.Tensor 或 Expr) – 左操作数
rhs (tvm.te.Tensor 或 Expr) – 右操作数

Returns:

ret – 如果两个操作数都是Expr则返回Expr，否则返回Tensor。

Return type:

tvm.te.Tensor 或表达式

tvm.topi.nn.batch_matmul(tensor_a, tensor_b, oshape=None, out_dtype=None, transpose_a=False, transpose_b=True, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

计算tensor_a和tensor_b的批量矩阵乘法。

张量tensor_a和tensor_b都可以进行转置。出于历史原因，我们默认使用NT格式(transpose_a=False, transpose_b=True)。

Parameters:

tensor_a (tvm.te.Tensor) – 三维张量，形状为 [batch, M, K] 或 [batch, K, M]。
tensor_b (tvm.te.Tensor) – 三维张量，形状为 [batch, K, N] 或 [batch, N, K]。
oshape (List[Optional]) – 计算结果的显式预期输出形状。在输入形状动态变化的情况下特别有用。
out_dtype (可选[str]) – 指定混合精度批量矩阵乘法的输出数据类型。
transpose_a (可选[bool] = False) - 第一个张量是否为转置格式。
transpose_b (可选[bool] = True) - 是否第二个张量是转置格式。
auto_scheduler_rewritten_layout (可选[str] = "") - 经过auto-scheduler布局重写处理后的布局。
meta_schedule_original_shape (可选[列表[PrimExpr]] = 无) – 张量的原始形状

Returns:

output – 三维张量，形状为 [batch, M, N]

Return type:

tvm.te.Tensor

批量归一化层（Ioffe和Szegedy，2014年提出）。

对每批输入进行归一化处理，即应用一种变换，使激活均值保持在接近0，激活标准差保持在接近1。

Parameters:

data (tvm.te.Tensor) – 需要进行批量归一化的输入数据。
gamma (tvm.te.Tensor) – 应用于归一化张量的缩放因子。
beta (tvm.te.Tensor) – 应用于归一化张量的偏移量。
moving_mean (tvm.te.Tensor) – 输入的滑动平均值。
moving_var (tvm.te.Tensor) – 输入的运行方差。
axis (int, 可选, 默认值=1) – 指定沿哪个形状轴进行归一化。
epsilon (float, optional, default=1e-5) – 添加到方差中的小浮点数，用于避免除以零的情况。
center (bool, optional, default=True) - 如果为True，则将beta的偏移量加到归一化张量上；如果为False，则忽略beta。
scale (bool, optional, defualt=True) – 如果为True，则通过gamma缩放归一化后的张量。如果为False，则忽略gamma参数。
training (bool, 可选, 默认=False) – 指示是否处于训练模式。如果为True，则更新移动平均值(moving_mean)和移动方差(moving_var)。
momentum (float, optional, default=0.1) – 用于更新moving_mean和moving_var的值。

Returns:

output (list of tvm.te.Tensor) – 与输入形状相同的归一化数据
moving_mean (tvm.te.Tensor) – 输入的滑动平均值
moving_var (tvm.te.Tensor) – 输入的滑动方差

tvm.topi.nn.batch_to_space_nd(data, block_shape, crop_begin_list, crop_end_list)

对数据执行空间到批量的转换

Parameters:

data (tvm.te.Tensor) – 具有形状[batch, spatial_shape, remaining_shapes]的N维张量，其中spatial_shape有M个维度。
block_size (list of ints) – 大小为[M]的列表，其中M是空间维度数，指定每个空间维度的块大小。
crop_begin_list (list of ints) – 形状为[M]的列表，其中M是空间维度数，指定每个空间维度的起始裁剪大小。
crop_end_list (list of ints) – 形状为[M]的列表，其中M是空间维度数，指定每个空间维度的结束裁剪大小。

Returns:

输出

Return type:

tvm.te.Tensor

tvm.topi.nn.binarize_pack(data, axis=None, name='PackedInput')

沿特定轴进行二值化和位打包。

Parameters:

data (tvm.te.Tensor) – n维输入，可以是任意布局。
axis (None 或 int) – 进行二值化和位打包操作的轴，默认为最后一个轴。
name (str, optional) – 运算符生成时的名称前缀。

Returns:

输出 – n维，与输入布局相同，数据类型为uint32。

Return type:

tvm.te.Tensor

tvm.topi.nn.binary_dense(data, weight)

使用异或和位计数进行二进制矩阵乘法。

Parameters:

data (tvm.te.Tensor) – 二维张量，形状为 [batch, in_dim]，数据类型为 uint32。
weight (tvm.te.Tensor) – 二维张量，形状为[out_dim, in_dim]，数据类型为uint32。

Returns:

输出 – 二维数组，形状为 [batch, out_dim]，数据类型为 float32。

Return type:

tvm.te.Tensor

tvm.topi.nn.bitpack(data, bits, pack_axis, bit_axis, pack_type, name='QuantizeInput')

将数据打包为位串行计算所需的格式

Parameters:

pack_axis (int) – 数据中要打包的轴索引
bit_axis (int) – 在结果打包数据中放置位轴的索引

tvm.topi.nn.bitserial_conv2d_nchw(data, kernel, stride, padding, activation_bits, weight_bits, pack_dtype='uint32', out_dtype='int16', unipolar=True)

比特串行Conv2D算子。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_channel, in_height, in_width]
kernel (tvm.te.Tensor) – 4维张量，形状为[num_filter, in_channel, filter_height, filter_width]
stride (int 或 列表/元组包含 两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组包含两个或四个整数) - 填充尺寸，[高度填充，宽度填充]，[上填充，左填充，下填充，右填充]
activation_bits (int) – 用于激活/输入元素的比特数
weight_bits (int) – 用于权重元素的比特数
out_dtype (str) – 卷积运算的返回类型
pack_dtype (str) – 位打包类型
unipolar (bool) – 如果二值化风格采用单极1/0格式，而非双极-1/+1格式

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.bitserial_conv2d_nhwc(data, kernel, stride, padding, activation_bits, weight_bits, pack_dtype='uint32', out_dtype='int16', unipolar=True)

比特串行Conv2D算子。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
kernel (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
stride (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 包含两个或四个整数的列表/元组) – 填充尺寸，可以是 [高度填充, 宽度填充] 或 [顶部填充, 左侧填充, 底部填充, 右侧填充]
activation_bits (int) – 用于激活/输入元素的比特数
weight_bits (int) – 用于权重元素的比特数
out_dtype (str) – 卷积运算的返回类型
pack_dtype (str) – 位打包类型
unipolar (bool) – 如果二值化风格采用单极1/0格式，而非双极-1/+1格式

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.bitserial_dense(data, weight, data_bits, weight_bits, pack_dtype='uint32', out_dtype='int16', unipolar=True)

topi中bitserial dense的默认实现。

Parameters:

data (tvm.te.Tensor) – 二维张量，形状为 [batch, in_dim]
weight (tvm.te.Tensor) – 二维张量，形状为[out_dim, in_dim]或三维张量，形状为[out_dim, weight_bits, in_dim]

Returns:

输出 – 二维张量，形状为 [batch, out_dim]

Return type:

tvm.te.Tensor

tvm.topi.nn.concatenate(a_tuple, axis=0)

沿现有轴连接一系列数组。

Parameters:

a_tuple (tuple of tvm.te.Tensor) – 要连接的数组
axis (int, optional) – 数组将沿此轴连接。默认为0。

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.nn.conv(inp: 张量, filt: 张量, stride: int | 序列[int], padding: int | 序列[int], dilation: int | 序列[int], groups: int, data_layout: str, kernel_layout: str = '', out_dtype: str | None = None, auto_scheduler_rewritten_layout: str | None = None, meta_schedule_original_shape=None, auto_scheduler_should_rewrite_layout: bool = False)

NCHW或NHWC布局中的卷积算子。

支持一维、二维、三维...以及分组操作。

Parameters:

inp (tvm.te.Tensor) – N维张量，形状为[batch, in_channel, in_height, in_width, ...]，采用data_layout格式
filt (tvm.te.Tensor) - N维张量，形状为[num_filter, in_channel // groups, filter_height, filter_width, ...]，使用kernel_layout布局
stride (int 或 列表/元组形式的维度整数) – (其中NCHW格式dim=2，NCH格式dim=1，以此类推) 步长大小，或表示为[垂直步长, 水平步长, ...]
padding (int 或 列表/元组包含 dim 或 2*dim 个整数) – (其中dim=2对应NCHW格式，dim=1对应NCH格式等) 填充尺寸，可以是： [pad_height, pad_width, ...] 当有dim个整数时，或 [pad_top, pad_left, pad_bottom, pad_right] 当有2*dim个整数时
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
groups (int) – 分组数量
data_layout (str) - 输入数据的布局。N表示批次维度，C表示通道数，其他字符表示高度和宽度(对于1D和3D情况分别表示H或HWD)。
kernel_layout (Optional[str]) – 过滤器的布局。I表示输入通道，O表示输出通道，其他字符表示过滤器的HW维度（对于1D和3D则使用H或HWD）。如果kernel_layout为空，则使用data_layout来推断默认的kernel_layout。默认情况下，对于NCHW数据布局，kernel_layout为OIHW；对于NHWC数据布局，kernel_layout为HWIO。
out_dtype (str) – 在逐元素相乘和求和之前，元素会被转换为该类型。
auto_scheduler_rewritten_layout (str) – 来自自动调度器布局重写的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]]) – 输入张量的原始形状。
auto_scheduler_should_rewrite_layout (bool) – 是否允许自动调度器重写滤波器张量的布局。默认为false。如果与分组卷积一起使用可能会导致错误。

Returns:

输出 – N维数组，形状为 [batch, out_channel, out_height, out_width, …]，采用data_layout格式

Return type:

tvm.te.Tensor

tvm.topi.nn.conv1d(data, kernel, strides=1, padding='VALID', dilation=1, groups=1, data_layout='NCW', kernel_layout='', out_dtype=None)

一维卷积前向算子。

Parameters:

data (tvm.te.Tensor) – 当data_layout为'NCW'时输入为3维形状[batch, in_channel, in_width] 当data_layout为'NWC'时输入为3维形状[batch, in_width, in_channel]
kernel (tvm.te.Tensor) – 三维核张量，当kernel_layout == 'OIW'时形状为[num_filter, in_channel, filter_size]；当kernel_layout == 'WIO'时形状为[filter_size, in_channel, num_filter]
strides (int 或 tuple) – 沿宽度方向的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 tuple) - 如果卷积需要扩张时的扩张率。
data_layout (str) – 输入数据的布局方式，必须是['NCW', 'NWC']中的一个
kernel_layout (可选[str]) – 内核的布局。如果未指定，则使用默认布局。当data_layout == "NCW"时为"OIW"，当data_layout == "NWC"时为"WIO"。
out_dtype (str) – 输出数据类型。如果为None则输出与输入类型相同。

tvm.topi.nn.conv1d_ncw(data, kernel, strides=1, padding='VALID', dilation=1, out_dtype=None): NCW布局中的一维卷积。有关参数详情，请参阅conv()

tvm.topi.nn.conv1d_nwc(data, kernel, strides=1, padding='VALID', dilation=1, out_dtype=None): NWC布局中的一维卷积。有关参数的详细信息，请参见conv()

tvm.topi.nn.conv1d_transpose_ncw(data, kernel, stride, padding, out_dtype, output_padding)

转置一维卷积ncw前向算子。

Parameters:

data (tvm.te.Tensor) – 三维张量，形状为 [batch, in_channel, in_width]
kernel (tvm.te.Tensor) – 三维张量，形状为[输入通道数, 滤波器数量, 滤波器宽度]
stride (ints) – 沿宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (ints) – 用于在存在多个可能输出形状时恢复实际输出形状。必须小于步长(stride)。

Returns:

输出 – 三维形状，尺寸为 [批次, 输出通道, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d(input, filter, strides, padding, dilation, data_layout='NCHW', kernel_layout='', out_dtype=None)

Conv2D 运算符。

Parameters:

input (tvm.te.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]，采用data_layout格式
filter (tvm.te.Tensor) – 在kernel_layout中形状为[num_filter, in_channel, filter_height, filter_width]的4维张量
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 2个或4个整数的列表/元组) - 填充大小，对于2个整数是[pad_height, pad_width]，对于4个整数是[pad_top, pad_left, pad_bottom, pad_right]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
data_layout (str) – 数据的布局
kernel_layout (可选[str]) – 内核布局。如果未指定，则使用从data_layout推断出的默认布局。当data_layout == "NCHW"时为"OIHW"，当data_layout == "NHWC"时为"HWIO"。

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_NCHWc(data, kernel, stride, padding, dilation, layout, out_layout, out_dtype='float32')

适用于nChw[x]c布局的Conv2D算子。

Parameters:

data (tvm.te.Tensor) – 5维张量，形状为 [批次, 输入通道块, 输入高度, 输入宽度, 输入通道块]
kernel (tvm.te.Tensor) – 6维张量，形状为 [num_filter_chunk, in_channel_chunk, filter_height, filter_width, in_channel_block, num_filter_block]
stride (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
layout (str) – 输入数据布局
out_layout (str) – 输出数据布局
out_dtype (str) – 输出数据类型

Returns:

输出 – 5维张量，形状为 [批次, 输出通道块, 输出高度, 输出宽度, 输出通道块]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_NCHWc_int8(data, kernel, stride, padding, dilation, layout, out_layout, out_dtype='int32', n_elems=4)

适用于nChw[x]c布局的Conv2D算子。

Parameters:

data (tvm.te.Tensor) – 5维张量，形状为 [批次大小, 输入通道块, 输入高度, 输入宽度, 输入通道块]
kernel (tvm.te.Tensor) – 7维张量，形状为 [num_filter_chunk, in_channel_chunk, filter_height, filter_width, in_channel_block/4, num_filter_block, 4]
stride (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 2个或4个整数的列表/元组) - 填充大小，对于2个整数是[pad_height, pad_width]，对于4个整数是[pad_top, pad_left, pad_bottom, pad_right]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
layout (str) – 输入数据布局
out_layout (str) – 输出数据布局
out_dtype (str) – 输出数据类型
n_elems (int) – 累计的int8元素数量

Returns:

输出 – 5维，形状为 [批次, 输出通道块, 输出高度, 输出宽度, 输出通道子块]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_hwcn(Input, Filter, stride, padding, dilation, out_dtype=None)

HWCN布局中的卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为[in_height, in_width, in_channel, batch]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
stride (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 2个或4个整数的列表/元组) - 填充大小，对于2个整数是[pad_height, pad_width]，对于4个整数是[pad_top, pad_left, pad_bottom, pad_right]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]

Returns:

输出 – 4维张量，形状为[out_height, out_width, out_channel, batch]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_nchw(Input, Filter, stride, padding, dilation, out_dtype=None)

NCHW布局中的卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[num_filter, in_channel, filter_height, filter_width]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [stride_height, stride_width]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_nhwc(Input, Filter, stride, padding, dilation, out_dtype='float32', auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

NHWC布局中的卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str = "float32",) – 输出张量的类型
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_transpose_nchw(Input, Filter, strides, padding, out_dtype, output_padding)

转置二维卷积nchw前向算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[输入通道数, 过滤器数量, 过滤器高度, 过滤器宽度]
strides (tuple of two ints) – 沿高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (tuple of ints) – 用于获取梯度的正确输出形状

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_transpose_nchw_preprocess(data, kernel, strides, padding, out_dtype, output_padding): 预处理数据和内核，使conv2d_transpose的计算模式与conv2d相同

tvm.topi.nn.conv2d_winograd_nchw(data, weight, strides, padding, dilation, out_dtype, pre_computed=False, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

NCHW布局中的Conv2D Winograd。这是一个简洁版本，供自动调度器用于CPU和GPU。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_channel, in_height, in_width]
weight (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组 包含 两个整数) – 填充大小，或 [pad_height, pad_width]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) - 指定输出数据类型。
pre_computed (bool) – 内核是否已预先计算
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_winograd_nchw_without_weight_transform(data, weight, strides, padding, dilation, out_dtype, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

在NCHW布局中无需进行布局转换的Conv2D Winograd算法。这是一个干净版本，可供元调度器(meta-schedule)用于CPU和GPU。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
weight (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组包含 两个整数) – 填充大小，或 [pad_height, pad_width]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) – 指定输出数据类型。
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_winograd_nhwc(data, weight, strides, padding, dilation, out_dtype, pre_computed=False, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

NHWC布局中的Conv2D Winograd。这是一个简洁版本，可供自动调度器用于CPU和GPU。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
weight (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组包含 两个整数) – 填充大小，或 [高度填充, 宽度填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) - 指定输出数据类型。
pre_computed (bool) – 内核是否已预计算
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_winograd_nhwc_without_weight_transform(data, weight, strides, padding, dilation, out_dtype, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

在NHWC布局下不进行布局转换的Conv2D Winograd算法。这是一个简洁版本，供自动调度器用于CPU和GPU。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
weight (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组 包含 两个整数) – 填充大小，或 [高度填充, 宽度填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) - 指定输出数据类型。
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv2d_winograd_weight_transform(kernel, tile_size)

Winograd的权重变换

Parameters:

kernel (Tensor) – 原始内核张量，布局为"NCHW"。
tile_size (int) – Winograd变换的瓦片大小。例如：2对应F(2x2, 3x3)，4对应F(4x4, 3x3)

Returns:

output – 4维张量，形状为 [alpha, alpha, CO, CI]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv3d_ncdhw(Input, Filter, stride, padding, dilation, groups, out_dtype=None)

NCDHW布局中的Conv3D算子。

Parameters:

输入 (tvm.te.Tensor) – 5维张量，形状为[batch, in_channel, in_depth, in_height, in_width]
过滤器 (tvm.te.Tensor) – 5维张量，形状为[num_filter, in_channel, filter_depth, filter_height, filter_width]
stride (int 或 三个整数的列表/元组) – 步长大小，或 [strid_depth, stride_height, stride_width]
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 列表/元组包含三个整数) – 膨胀尺寸，或 [膨胀深度, 膨胀高度, 膨胀宽度]
groups (int) – 分组数量。

Returns:

输出 - 5维张量，形状为 [批次大小, 输出通道数, 输出深度, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv3d_ndhwc(Input, Filter, stride, padding, dilation, groups, out_dtype='float32', auto_scheduler_rewritten_layout='', meta_schedule_origin_shape=None)

NDHWC布局中的卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 5维张量，形状为 [批次大小, 输入深度, 输入高度, 输入宽度, 输入通道数]
过滤器 (tvm.te.Tensor) – 5维张量，形状为[filter_depth, filter_height, filter_width, in_channel, num_filter]
stride (int 或 三个整数的列表/元组) – 步长大小，或 [stride_depth, stride_height, stride_width]
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 三个整数的列表/元组) – 膨胀尺寸，或 [dilation_depth, dilation_height, dilation_width]
groups (int) – 组数。
out_dtype (str = "float32",) – 输出张量的类型
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_origin_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 5维张量，形状为 [batch, out_depth, out_height, out_width, out_channel]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv3d_transpose_ncdhw(Input, Filter, strides, padding, out_dtype, output_padding)

转置3D卷积ncdhw前向算子。

Parameters:

输入 (tvm.te.Tensor) – 5维张量，形状为[batch, in_channel, in_depth, in_height, in_width]
过滤器 (tvm.te.Tensor) – 5维张量，形状为[输入通道数, 过滤器数量, 过滤器深度, 过滤器高度, 过滤器宽度]
strides (int 或 三个整数的列表/元组) – 沿着深度、高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (tuple of ints) – 用于获取梯度的正确输出形状

Returns:

输出 - 5维张量，形状为 [批次大小, 输出通道数, 输出深度, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.conv3d_transpose_ncdhw_preprocess(data, kernel, strides, padding, out_dtype, output_padding): 预处理数据和内核，使conv3d_transpose的计算模式与conv3d保持一致

tvm.topi.nn.conv3d_winograd_weight_transform(kernel, tile_size)

3D Winograd的权重变换

Parameters:

kernel (Tensor) – 原始内核张量，布局为"NCDHW"。
tile_size (int) – Winograd变换的瓦片大小。例如：2对应F(2x2, 3x3)，4对应F(4x4, 3x3)

Returns:

输出 – 5维张量，形状为 [alpha, alpha, alpha, CO, CI]

Return type:

tvm.te.Tensor

tvm.topi.nn.correlation_nchw(data1, data2, kernel_size, max_displacement, stride1, stride2, padding, is_multiply)

NCHW布局中的相关性运算符。

Parameters:

data1 (tvm.te.Tensor) – 4维张量，形状为 [批次, 通道, 高度, 宽度]
data2 (tvm.te.Tensor) – 4维张量，形状为[批次, 通道, 高度, 宽度]
kernel_size (int) - 相关性计算的内核大小，必须为奇数
max_displacement (int) – 相关性的最大位移量
stride1 (int) – 数据1的步长
stride2 (int) – 以data1为中心的邻域内data2的步长
padding (int 或 包含2或4个整数的列表/元组) – 填充尺寸，对于2个整数表示[高度填充，宽度填充]，对于4个整数表示[上填充，左填充，下填充，右填充]
is_multiply (bool) – 操作类型是乘法还是减法

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.declaration_conv2d_transpose_impl(data, kernel, strides, padding, out_dtype, output_padding): 实现conv2d转置操作

tvm.topi.nn.declaration_conv3d_transpose_impl(data, kernel, strides, padding, out_dtype, output_padding): conv3d转置的实现

tvm.topi.nn.deformable_conv2d_nchw(data, offset, kernel, strides, padding, dilation, deformable_groups, groups, out_dtype)

NCHW布局中的可变形conv2D算子。

可变形卷积操作的描述详见https://arxiv.org/abs/1703.06211

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_channel, in_height, in_width]
offset (tvm.te.Tensor) – 4维张量，形状为 [batch, deformable_groups * filter_height * filter_width * 2, out_height, out_width]。
kernel (tvm.te.Tensor) – 4维张量，形状为[num_filter, in_channel, filter_height, filter_width]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组 包含 两个整数) – 填充大小，或 [高度填充, 宽度填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
deformable_groups (int) – 可变形组的数量
groups (int) – 分组数量

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.deformable_conv2d_nhwc(data, offset, kernel, strides, padding, dilation, deformable_groups, groups, out_dtype)

NHWC布局中的可变形conv2D算子。

可变形卷积操作的描述详见https://arxiv.org/abs/1703.06211

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
offset (tvm.te.Tensor) –

4维张量，形状为 [batch, out_height, out_width,
deformable_groups * filter_height * filter_width * 2].
kernel (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, num_filter]
strides (int 或 列表/元组包含两个整数) – 步长大小，或 [垂直步长, 水平步长]
padding (int 或 列表/元组 包含 两个整数) – 填充大小，或 [高度填充, 宽度填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
deformable_groups (int) – 可变形组的数量
groups (int) – 分组数量

Returns:

输出 – 4维张量，形状为 [批次, 输出高度, 输出宽度, 输出通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.dense(data, weight, bias=None, out_dtype=None, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

topi中dense操作的默认实现。这是matmul_nt运算符的别名，用于处理数据张量（非转置格式）和权重张量（转置格式）。

Parameters:

data (tvm.te.Tensor) – 二维张量，形状为 [batch, in_dim]
weight (tvm.te.Tensor) – 二维张量，形状为[out_dim, in_dim]
bias (可选[tvm.te.Tensor]) – 一维张量，形状为[out_dim]
out_dtype (可选[str]) - 输出类型。用于混合精度计算。
auto_scheduler_rewritten_layout (str = "") – 自动调度器布局重写过程后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 二维张量，形状为 [batch, out_dim]

Return type:

tvm.te.Tensor

tvm.topi.nn.dense_pack(data, weight, bias=None, out_dtype=None)

topi中dense_pack的默认实现。

Parameters:

data (tvm.te.Tensor) – 二维张量，形状为 [batch, in_dim]
weight (tvm.te.Tensor) – 二维张量，形状为[out_dim, in_dim]
bias (可选[tvm.te.Tensor]) - 一维张量，形状为[out_dim]
out_dtype (可选[str]) - 输出类型。用于混合精度。

Returns:

输出 – 二维张量，形状为 [batch, out_dim]

Return type:

tvm.te.Tensor

tvm.topi.nn.depth_to_space(data, block_size, layout='NCHW', mode='DCR')

对数据执行深度到空间的转换

Parameters:

data (tvm.te.Tensor) – 4维张量，支持NCHW或NHWC布局格式。
block_size (int) – 从通道维度组成块的大小。
layout (string) - 可以是NCHW或NHWC，表示数据布局。
mode (string) - 可以是DCR或CDR，表示应如何访问通道。在DCR模式下，通道以Tensorflow风格交错访问，而在CDR模式下，通道则像Pytorch那样按顺序访问。

Returns:

输出 – 形状为 [N, C / block_size**2, H * block_size, W * block_size] 的输出

Return type:

tvm.te.Tensor

tvm.topi.nn.depthwise_conv2d_NCHWc(Input, Filter, stride, padding, dilation, layout, out_layout, out_dtype=None)

深度卷积NCHW[x]c前向算子。

Parameters:

输入 (tvm.te.Tensor) – 5维张量，形状为 [批次大小, 输入通道块, 输入高度, 输入宽度, 输入通道块]
过滤器 (tvm.te.Tensor) – 6维张量，形状为[out_channel_chunk, 1, filter_height, filter_width, 1, out_channel_block] 在NCHWc深度卷积中，我们将内核的输入通道和通道乘数组合在一起，然后进行平铺处理。
stride (tuple of two ints) – 沿高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
layout (str) – 输入数据布局
out_layout (str) – 输出数据布局
out_dtype (str, optional) – 输出数据类型

Returns:

输出 – 5维张量，形状为 [批次, 输出通道块, 输出高度, 输出宽度, 输出通道块]

Return type:

tvm.te.Tensor

tvm.topi.nn.depthwise_conv2d_backward_input_nhwc(Filter, Out_grad, oshape, ishape, stride, padding)

深度卷积 nhwc 反向输入算子。

Parameters:

过滤器 (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, channel_multiplier]
Out_grad (tvm.te.Tensor) – 4维张量，形状为 [batch, out_height, out_width, out_channel]
stride (tuple of two ints) – 沿高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]

Returns:

输出 – 4维张量，形状为 [batch, in_height, in_width, in_channel]

Return type:

tvm.te.Tensor

tvm.topi.nn.depthwise_conv2d_backward_weight_nhwc(Input, Out_grad, oshape, fshape, stride, padding)

深度卷积nhwc对权重的反向传播算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
Out_grad (tvm.te.Tensor) – 4维张量，形状为 [batch, out_height, out_width, out_channel]
stride (tuple of two ints) – 沿高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]

Returns:

输出 – 4维张量，形状为 [filter_height, filter_width, in_channel, channel_multiplier]

Return type:

tvm.te.Tensor

tvm.topi.nn.depthwise_conv2d_nchw(Input, Filter, stride, padding, dilation, out_dtype=None)

深度可分离卷积nchw前向算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[输入通道数, 通道乘数, 过滤器高度, 过滤器宽度]
stride (int 或 两个整数的列表/元组) – 空间步长，或(步长高度, 步长宽度)。
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) – 输出数据类型

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.depthwise_conv2d_nhwc(Input, Filter, stride, padding, dilation, kernel_layout='HWOI', out_dtype=None)

深度卷积nhwc前向算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为 [batch, in_height, in_width, in_channel]
Filter (tvm.te.Tensor) – 4维张量，形状为[filter_height, filter_width, in_channel, channel_multiplier]
stride (tuple of two ints) – 沿高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (str, optional) – 输出数据类型

Returns:

输出 – 4维，形状为 [batch, out_height, out_width, out_channel]

Return type:

tvm.te.Tensor

tvm.topi.nn.dilate(data, strides, dilation_value=0.0, name='DilatedInput')

使用给定的膨胀值（默认为0）对数据进行膨胀处理。

Parameters:

data (tvm.te.Tensor) – n维张量，可以是任意布局。
strides (list / tuple of n ints) – 各维度上的扩张步长，1表示不扩张。
dilation_value (int/float, optional) – 用于扩张输入的值。
name (str, optional) – 生成运算符的名称前缀

Returns:

输出 – n-D，与数据相同的布局。

Return type:

tvm.te.Tensor

tvm.topi.nn.equal_const_int(expr, value)

如果expr等于value则返回。

Parameters:: expr (tvm.Expr) – 输入表达式。
Returns:: equal – 判断是否相等。
Return type:: bool

tvm.topi.nn.fast_softmax(x, axis=-1)

对数据进行softmax激活。使用近似方法计算指数以提高速度。

Parameters:

data (tvm.te.Tensor) – 可以是任意维度
axis (int) – 通道轴

Returns:

output - 输出形状与输入相同

Return type:

tvm.te.Tensor

tvm.topi.nn.fifo_buffer(data, buffer, axis)

FIFO缓冲区，用于在具有滑动窗口输入的CNN中实现计算重用

计算等效于

concat(buffer, data, axis=axis)
.slice_axis(axis=axis,
            begin=data.shape[axis],
            end=data.shape[axis]+buffer.shape[axis])

适用场景

在滑动窗口输入上操作的卷积运算中编码显式计算重用
实现一个FIFO队列来缓存中间结果，例如在Fast WaveNet中的应用。

Parameters:

data (tvm.te.Tensor) – 输入数据
buffer (tvm.te.Tensor) – FIFO缓冲区的先前值
axis (int) – 指定应该使用哪个轴进行缓冲

Returns:

result – 缓冲区的更新值

Return type:

tvm.te.Tensor

tvm.topi.nn.flatten(data)

通过折叠更高维度将输入数组展平为二维数组。

Parameters:: data (tvm.te.Tensor) – 输入数组。
Returns:: output – 已折叠高维度的二维数组。
Return type:: tvm.te.Tensor

tvm.topi.nn.get_const_int(expr)

验证表达式是否为整数并获取其常量值。

Parameters:: expr (tvm.Expr 或 int) – 输入表达式。
Returns:: out_value – 输出值。
Return type:: int

tvm.topi.nn.get_const_tuple(in_tuple)

验证输入元组是否为IntImm或Var类型，返回整数或Var的元组。

Parameters:: in_tuple (tuple of Expr) – 输入参数。
Returns:: out_tuple – 输出结果。
Return type:: tuple 的 int

tvm.topi.nn.get_pad_tuple(padding, kernel)

获取填充选项的通用代码

Parameters:

padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
kernel (tuple of int) – 卷积核大小

Returns:

pad_top (int) – 顶部填充大小
pad_left (int) – 左侧填充大小
pad_down (int) – 底部填充大小
pad_right (int) – 右侧填充大小

tvm.topi.nn.get_pad_tuple1d(padding, kernel)

获取填充选项的通用代码

Parameters:

padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
kernel (tuple of int) – 卷积核大小

Returns:

pad_left (int) – 左侧填充大小
pad_right (int) – 右侧填充大小

tvm.topi.nn.get_pad_tuple3d(padding, kernel)

获取填充选项的通用代码

Parameters:

padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
kernel (tuple of int) - 卷积核大小

Returns:

pad_front (int) – 前部填充大小
pad_top (int) – 顶部填充大小
pad_left (int) – 左侧填充大小
pad_back (int) – 后部填充大小
pad_down (int) – 底部填充大小
pad_right (int) – 右侧填充大小

tvm.topi.nn.get_pad_tuple_generic(padding, kernel)

获取填充选项的通用代码

Parameters:

padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
kernel (tuple of int) – 卷积核大小

Returns:

pad_top (int) – 顶部填充大小
pad_down (int) – 底部填充大小
pad_left (int) – 左侧填充大小
pad_right (int) – 右侧填充大小

tvm.topi.nn.global_pool(data, pool_type, layout='NCHW')

Perform global pooling on height and width dimension of data.: 它根据布局字符串决定高度和宽度维度，其中'W'和'H'分别表示宽度和高度。宽度和高度维度不能被拆分。例如，NCHW、NCHW16c等对池化操作有效，而NCHW16w、NCHW16h则无效。有关布局字符串约定的更多信息，请参阅参数layout。

Parameters:

data (tvm.te.Tensor) – n维张量，具有指定布局的形状
pool_type (str) – 池化类型，'max'或'avg'
layout (str) – 输入数据的布局。布局应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母带因子大小表示分割维度。例如，NCHW16c可以描述一个5维张量 [批次大小, 通道, 高度, 宽度, 通道块]，其中通道块=16是通道维度的分割。

Returns:

输出 – 保持相同布局的n维数组，高度和宽度维度尺寸为1。例如，对于NCHW格式，输出形状将为[batch, channel, 1, 1]

Return type:

tvm.te.Tensor

tvm.topi.nn.group_conv1d_ncw(data, kernel, strides=1, padding='VALID', dilation=1, groups=1, out_dtype=None)

针对NCW布局的一维卷积前向算子。

Parameters:

data (tvm.te.Tensor) – 三维张量，形状为 [batch, in_channel, in_width]
kernel (tvm.te.Tensor) – 3维张量，形状为[num_filter, in_channel, filter_size]
strides (int 或 tuple) – 沿宽度方向的空间步长
padding (int, tuple, or str) - 填充大小可以是整数表示等距填充，也可以是(left, right)元组或['VALID', 'SAME']中的字符串。
dilation (int 或 tuple) - 如果卷积需要扩张时的扩张率。
groups (int) – 分组数量
out_dtype (str) – 输出数据类型。如果为None则输出与输入类型相同。

tvm.topi.nn.group_conv1d_nwc(data, kernel, strides=1, padding='VALID', dilation=1, groups=1, out_dtype=None)

针对NWC布局的一维卷积前向算子。

Parameters:

data (tvm.te.Tensor) – 三维张量，形状为 [batch, in_width, in_channel]
kernel (tvm.te.Tensor) – 三维张量，形状为[filter_size, in_channel, num_filter]
strides (int 或 tuple) – 沿宽度方向的空间步长
padding (int, tuple, 或 str) - 填充大小可以是整数表示等距填充，一个(left, right)元组，或者是['VALID', 'SAME']中的字符串。
dilation (int 或 tuple) - 如果卷积需要扩张时的扩张率。
groups (int) – 分组数量
out_dtype (str) – 输出数据类型。如果为None则输出与输入类型相同。

tvm.topi.nn.group_conv1d_transpose_ncw(data, kernel, stride, padding, out_dtype, output_padding, groups)

转置的一维分组卷积 ncw 前向算子。

Parameters:

data (tvm.te.Tensor) – 三维张量，形状为 [batch, in_channel, in_width]
kernel (tvm.te.Tensor) – 三维张量，形状为[输入通道数, 滤波器数量, 滤波器宽度]
stride (ints) – 沿宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (ints) –

用于在存在多个可能形状时恢复实际输出形状
必须小于步幅

groupsint
分组数量

Returns:

输出 – 三维形状，尺寸为 [批次, 输出通道, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.group_conv2d_nchw(Input, Filter, stride, padding, dilation, groups, out_dtype=None)

NCHW布局中的分组卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[num_filter, in_channel // groups, filter_height, filter_width]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
groups (int) – 分组数量
out_dtype (str) – 输出类型。用于混合精度计算。

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.group_conv2d_nhwc(Input, Filter, stride, padding, dilation, groups, out_dtype=None)

NHWC布局中的分组卷积算子。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为 [批次, 输入高度, 输入宽度, 输入通道, ...]
过滤器 (tvm.te.Tensor) – 4维张量，形状为[过滤器高度, 过滤器宽度, 输入通道数 // 分组数, 过滤器数量]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
dilation (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
groups (int) – 分组数量
out_dtype (str) – 输出类型。用于混合精度计算。

Returns:

输出 – 4维，形状为 [batch, out_height, out_width, out_channel]

Return type:

tvm.te.Tensor

tvm.topi.nn.group_conv2d_transpose_nchw(data, kernel, stride, padding, out_dtype, output_padding, groups)

NCHW布局中的分组卷积算子。

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [batch, in_channel, in_height, in_width]
kernel (tvm.te.Tensor) – 4维张量，形状为[输入通道数, 输出通道数//分组数, 滤波器高度, 滤波器宽度]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int 或 包含2或4个整数的列表/元组) - 填充大小，对于2个整数表示[填充高度, 填充宽度]，对于4个整数表示[上填充, 左填充, 下填充, 右填充]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (tuple of ints) – 用于获取梯度的正确输出形状
groups (int) – 分组数量
out_dtype – 输出类型。用于混合精度。

Returns:

输出 – 4维张量，形状为 [批次大小, 输出通道数, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.group_conv3d_transpose_ncdhw(data, kernel, strides, padding, out_dtype, output_padding, groups)

转置分组3D卷积ncdhw前向算子。

Parameters:

data (tvm.te.Tensor) – 5维张量，形状为 [批次大小, 输入通道数, 输入深度, 输入高度, 输入宽度]
kernel (tvm.te.Tensor) – 5维张量，形状为[输入通道数, 滤波器数量, 滤波器深度, 滤波器高度, 滤波器宽度]
strides (int 或 三个整数的列表/元组) – 沿着深度、高度和宽度的空间步长
padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
out_dtype (str) – 输出数据类型。用于混合精度计算。
output_padding (tuple of ints) – 用于获取梯度的正确输出形状
groups (int) – 分组数量

Returns:

输出 - 5维张量，形状为 [批次大小, 输出通道数, 输出深度, 输出高度, 输出宽度]

Return type:

tvm.te.Tensor

tvm.topi.nn.leaky_relu(x, alpha)

对输入x进行leaky relu处理。

Parameters:

x (tvm.te.Tensor) – 输入参数。
alpha (float) – 当x < 0时小梯度的斜率

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.nn.log_softmax(x, axis=-1)

对数据执行对数softmax激活

Parameters:: data (tvm.te.Tensor) – N维输入数据
Returns:: output – 具有相同形状的N维输出
Return type:: tvm.te.Tensor

tvm.topi.nn.lrn(data, size, axis=1, alpha=0.0001, beta=0.75, bias=2)

对输入数据执行跨通道局部响应归一化。

sum_sqr_up^i{x, y} = (bias+((alpha/size)* {sum_{j=max(0, i-size/2)}^{min(N-1,i+size/2)} (data^j{x,y})^2}))^beta output^i{x, y} = data^i{x, y}/sum_sqr_up^i{x, y} N 表示输入通道的数量

Parameters:

data (tvm.te.Tensor) – 4维张量，形状为 [批次, 通道, 高度, 宽度]
size (int) – 归一化窗口大小
axis (int) – 输入数据布局的通道轴默认值为1，对应NCHW格式
bias (float) – 偏移量，用于避免除以0的情况
alpha (float) – 待除数值
beta (float) – 指数

Returns:

output - 与输入形状相同的4维输出

Return type:

tvm.te.Tensor

tvm.topi.nn.lstm(Xs, Wi, Wh, Bi=None, Bh=None, h_init=None, c_init=None, proj=None, p_i=None, p_f=None, p_o=None, f_act=<function sigmoid>, g_act=<function tanh>, h_act=<function tanh>, reverse=False, weight_layout: str = 'IFGO')

使用TE扫描实现的通用LSTM。

Parameters:

Xs (te.Tensor) – 输入序列，形状为 (seq_len, batch_size, in_dim)
Wi (te.Tensor) – 输入权重矩阵，形状为(4 * hidden_dim, in_dim)。权重按照weight_layout进行打包。
Wh (te.Tensor) – 形状为(4 * hidden_dim, hidden_dim or proj_dim)的隐藏权重矩阵。打包为Wh。
Bi (te.Tensor, optional) – 输入偏置，形状为(4 * hidden_dim,)，默认为None。打包为Wh。
Bh (te.Tensor, optional) – 形状与Bi相同的隐藏偏置项，默认为None。与Wh打包在一起。
h_init (te.Tensor, optional) – 初始隐藏状态，形状为(batch_size, hidden_dim or proj_dim)，若为None则初始化为零
c_init (te.Tensor, optional) – 初始细胞状态，形状与h_init相同，若为None则初始化为零
proj (te.Tensor, optional) – 形状为(proj_dim, hidden_dim)的投影矩阵，默认为None
p_i (te.Tensor, optional) – 形状为(batch_size, hidden_dim)的窥孔LSTM矩阵，默认为None
p_f (te.Tensor, optional) – 窥孔LSTM矩阵，形状为(batch_size, hidden_dim)，默认为None
p_o (te.Tensor, 可选参数) – 窥孔LSTM矩阵，形状为(batch_size, hidden_dim)，默认为None
f_act (F, optional) – 门控激活函数
g_act (F, optional) – 门控激活函数
h_act (F, optional) – 门控激活函数
reverse (bool, optional) – 是否反向处理Xs，默认为False
weight_layout (str, optional) – 门控单元的打包权重布局，默认为“IFGO”。注意：I = 输入门，F = 遗忘门，G = 细胞状态，O = 输出门。

Returns:

result – 由隐藏状态（形状为(seq_len, batch_size, hidden_dim or proj_dim)）和单元状态（形状为(seq_len, batch_size, hidden_dim)）组成的元组。

Return type:

te.Tensor, te.Tensor

tvm.topi.nn.matmul(tensor_a, tensor_b, bias=None, out_dtype=None, transpose_a=False, transpose_b=False, auto_scheduler_rewritten_layout='', meta_schedule_original_shape=None)

topi中matmul的默认实现。

Parameters:

tensor_a (tvm.te.Tensor) – 二维张量，形状为 [batch, in_dim]
tensor_b (tvm.te.Tensor) – 二维张量，形状为 [输出维度, 输入维度]
bias (可选[tvm.te.Tensor]) - 一维张量，形状为[out_dim]
out_dtype (可选[str]) - 输出类型。用于混合精度。
transpose_a (可选[bool] = False) - 表示张量a是否处于转置格式。
transpose_b (可选[bool] = False) - 表示tensor_b是否处于转置格式。
auto_scheduler_rewritten_layout (可选[str] = "") - 经过auto-scheduler布局重写处理后的布局。
meta_schedule_original_shape (Optional[List[PrimExpr]] = None) – 输入张量的原始形状。

Returns:

输出 – 二维张量，形状为 [batch, out_dim]

Return type:

tvm.te.Tensor

tvm.topi.nn.mirror_pad(data, pad_before, pad_after=None, mode='SYMMETRIC', name='MirrorPadInput')

使用对称或反射镜像对输入进行填充。

Parameters:

data (tvm.te.Tensor) – n维输入，可以是任意布局。
pad_before (list / tuple of n ints) – 在每个维度上填充的宽度，用于在轴开始之前进行填充。
pad_after (list / tuple of n ints, optional) – 在每个维度的轴末端之后填充的宽度。
mode (str, optional) – 镜像填充类型。必须是 SYMMETRIC 或 REFLECT
name (str, optional) – 生成运算符的名称前缀

Returns:

输出 – n维，与输入保持相同的布局。

Return type:

tvm.te.Tensor

tvm.topi.nn.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

返回一个具有命名字段的元组新子类。

>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__                   # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22)             # instantiate with positional args or keywords
>>> p[0] + p[1]                     # indexable like a plain tuple
33
>>> x, y = p                        # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y                       # fields also accessible by name
33
>>> d = p._asdict()                 # convert to a dictionary
>>> d['x']
11
>>> Point(**d)                      # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)

tvm.topi.nn.nll_loss(predictions, targets, weights, reduction, ignore_index)

输入数据的负对数似然损失。

output{n, i_1, i_2, …, i_k} = -p * w

where t = target{n, i_1, i_2, …, i_k}: p = 预测值{n, t, i_1, i_2, i_k} w = 权重{n, i_1, i_2, …, i_k} 如果 t != 忽略索引否则为 0

结果 = 归约操作(输出)

Parameters:

predictions (tvm.te.Tensor) – (k+2)维张量，形状为(N, C, d_1, d_2, ..., d_k)，其中C表示目标类别数量
targets (tvm.te.Tensor) – (k+1)维张量，形状为 (N, d_1, d_2, ..., d_k) 输入的期望目标值。
weights (tvm.te.Tensor) – 一维张量，形状为 (C,) 每个目标值的权重。
reduction (string) – 应用于输出的归约方法。可以是"mean"、"sum"或"none"。
ignore_index (int) – 要忽略的目标值。

Returns:

output – 如果缩减类型是"mean"或"sum"则输出标量，否则与target形状相同。

Return type:

tvm.te.Tensor

tvm.topi.nn.pad(data, pad_before, pad_after=None, pad_value=0.0, name='PadInput', attrs=None)

用零填充输入。

Parameters:

data (tvm.te.Tensor) – n维输入，可以是任意布局。
pad_before (list / tuple of n ints) – 在每个维度上填充的宽度，用于在轴开始前进行填充。
pad_after (list / tuple of n ints, optional) – 在每个维度上指定填充宽度，用于在轴末端之后进行填充。
pad_value (float, optional) – 用于填充的值。
name (str, optional) – 生成运算符的名称前缀

Returns:

输出 – n维，与输入保持相同的布局。

Return type:

tvm.te.Tensor

tvm.topi.nn.pool1d(data, kernel, stride, dilation, padding, pool_type, ceil_mode=False, layout='NCW', count_include_pad=True)

Perform pooling on width dimension of data.: 宽度轴是根据布局字符串确定的。其中'w'代表宽度。宽度维度不能被分割。例如，NCW、NCW16c等对于池是有效的，而NCW16w则无效。有关布局字符串约定的更多信息，请参见参数layout。

Parameters:

data (tvm.te.Tensor) – n维张量，具有指定布局的形状
kernel (list/tuple of one int or int) – 核大小，[kernel_width]
stride (list/tuple of one int or int) – 步长大小，[stride_width]
dilation (list/tuple of two ints) – 膨胀尺寸，[膨胀高度, 膨胀宽度]
padding (list/tuple of two ints) – 填充大小，[左填充，右填充]
pool_type (str) – 池化类型，'max'或'avg'
ceil_mode (bool) – 计算输出大小时是否使用向上取整。
layout (string) – 输入数据的布局格式。布局格式应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母与因子大小表示分割维度。例如，NCW16c可以描述一个4维张量 [batch_size, channel, width, channel_block]，其中channel_block=16是channel维度的分割。
count_include_pad (bool) - 当pool_type为'avg'时，计算中是否包含填充

Returns:

输出 – 相同布局的n维

Return type:

tvm.te.Tensor

tvm.topi.nn.pool2d(data, kernel, stride, dilation, padding, pool_type, ceil_mode=False, layout='NCHW', count_include_pad=True)

Perform pooling on height and width dimension of data.: 它根据布局字符串决定高度和宽度维度，其中'W'和'H'分别表示宽度和高度。宽度和高度维度不能被拆分。例如，NCHW、NCHW16c等对池化操作有效，而NCHW16w、NCHW16h则无效。有关布局字符串约定的更多信息，请参阅参数layout。

Parameters:

data (tvm.te.Tensor) – n维张量，具有指定布局的形状
kernel (list/tuple of two ints) – 核大小，[核高度, 核宽度]
stride (list/tuple of two ints) – 步长大小，[高度步长, 宽度步长]
dilation (list/tuple of two ints) – 膨胀尺寸，[高度膨胀系数, 宽度膨胀系数]
padding (list/tuple of four ints) – 填充大小，[上填充，左填充，下填充，右填充]
pool_type (str) – 池化类型，'max'或'avg'
ceil_mode (bool) – 计算输出大小时是否使用向上取整。
layout (string) – 输入数据的布局格式。该布局应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母带因子大小表示切分维度。例如，NCHW16c可以描述一个5维张量 [batch_size, channel, height, width, channel_block]，其中channel_block=16是通道维度的切分。
count_include_pad (bool) – 当pool_type为‘avg’时，计算中是否包含填充

Returns:

输出 – 相同布局的n维

Return type:

tvm.te.Tensor

tvm.topi.nn.pool3d(data, kernel, stride, dilation, padding, pool_type, ceil_mode=False, layout='NCDHW', count_include_pad=True)

Perform pooling on depth, height and width dimension of data.: 它根据布局字符串决定深度、高度和宽度维度，其中'D'、'W'和'H'分别表示深度、宽度和高度。深度、宽度和高度维度不能被分割。例如，NCDHW、NCDHW16c等对池化操作有效，而NCDHW16d、NCDHW16w、NCDHW16h则无效。有关布局字符串约定的更多信息，请参阅参数layout。

Parameters:

data (tvm.te.Tensor) – n维张量，具有指定布局的形状
kernel (list/tuple of three ints) – 核大小，[核深度, 核高度, 核宽度]
stride (list/tuple of three ints) – 步长大小，[stride_depth, stride_height, stride_width]
dilation (list/tuple of two ints) – 膨胀尺寸，[膨胀高度, 膨胀宽度]
padding (list/tuple of six ints) – 填充大小，[前填充, 上填充, 左填充, 后填充, 下填充, 右填充]
pool_type (str) – 池化类型，'max'或'avg'
ceil_mode (bool) – 计算输出大小时是否使用向上取整。
layout (string) – 输入数据的布局。布局应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母带因子大小表示分割维度。例如，NCDHW16c可以描述一个6维张量 [batch_size, channel, depth, height, width, channel_block]，其中channel_block=16是通道维度的分割。
count_include_pad (bool) - 当pool_type为'avg'时，计算中是否包含填充

Returns:

输出 – 相同布局的n维

Return type:

tvm.te.Tensor

tvm.topi.nn.pool_grad(grads, data, kernel, stride, padding, pool_type, ceil_mode=False, count_include_pad=True, layout='NCHW')

Gradient of pooling on height and width dimension of data.: 它根据布局字符串决定高度和宽度维度，其中'W'和'H'分别表示宽度和高度。宽度和高度维度不能被拆分。例如，NCHW、NCHW16c等对池化操作有效，而NCHW16w、NCHW16h则无效。有关布局字符串约定的更多信息，请参阅参数layout。

Parameters:

grads (tvm.te.Tensor) - 具有布局形状的n维张量
data (tvm.te.Tensor) – n维张量，具有指定布局的形状
kernel (list/tuple of two ints) – 核大小，[核高度, 核宽度]
stride (list/tuple of two ints) – 步长大小，[高度方向步长, 宽度方向步长]
padding (list/tuple of four ints) – 填充大小，[上填充，左填充，下填充，右填充]
pool_type (str) – 池化类型，'max'或'avg'
ceil_mode (bool) – 计算输出大小时是否使用向上取整。
count_include_pad (bool) - 当pool_type为'avg'时，计算中是否包含填充
layout (string) – 输入数据的布局格式。该布局应由大写字母、小写字母和数字组成，其中大写字母表示维度，对应的小写字母带因子大小表示切分维度。例如，NCHW16c可以描述一个5维张量 [batch_size, channel, height, width, channel_block]，其中channel_block=16是通道维度的切分。

Returns:

输出 – 相同布局的n维

Return type:

tvm.te.Tensor

tvm.topi.nn.prelu(x, slope, axis=1)

PReLU。它接受两个参数：输入x和权重数组W，并计算输出为\(PReLU(x) y = x > 0 ? x : W * x\)，其中\(*\)表示对批次中每个样本进行逐元素乘法运算。

Parameters:

x (tvm.te.Tensor) – 输入参数。
slope (tvm.te.Tensor) – 用于prelu的通道化斜率张量
axis (int) – 需要应用通道数据的轴

Returns:

y (tvm.te.Tensor) – 结果张量
相关链接
—–
[http (//arxiv.org/pdf/1502.01852v1.pdf])

tvm.topi.nn.reduce(function, sequence[, initial]) → value: 对一个序列中的元素从左到右累积地应用一个双参数函数，从而将序列缩减为单个值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算的是 ((((1+2)+3)+4)+5)。如果提供了initial参数，它会被放在序列元素之前参与计算，并在序列为空时作为默认值。

tvm.topi.nn.relu(x)

对输入x进行relu操作。

Parameters:: x (tvm.te.Tensor) – 输入参数。
Returns:: y – 结果。
Return type:: tvm.te.Tensor

tvm.topi.nn.scale_shift_nchw(Input, Scale, Shift)

推理中的批量归一化算子。

Parameters:

输入 (tvm.te.Tensor) – 4维输入张量，NCHW布局 [批次, 通道, 高度, 宽度]
Scale (tvm.te.Tensor) – 缩放张量，一维通道数大小
Shift (tvm.te.Tensor) – 位移张量，一维通道数大小

Returns:

输出 – 输出张量，布局格式为NCHW

Return type:

tvm.te.Tensor

tvm.topi.nn.scale_shift_nchwc(Input, Scale, Shift)

推理中的批量归一化算子。

Parameters:

输入 (tvm.te.Tensor) – 5维输入张量，NCHWc布局 [批次, 通道块, 高度, 宽度, 通道块]
Scale (tvm.te.Tensor) – 缩放张量，二维尺寸为[channel_chunk, channel_block]
Shift (tvm.te.Tensor) – 位移张量，二维尺寸为[channel_chunk, channel_block]

Returns:

输出 – 输出张量，布局为NHWC

Return type:

tvm.te.Tensor

tvm.topi.nn.scale_shift_nhwc(Input, Scale, Shift)

推理中的批量归一化算子。

Parameters:

输入 (tvm.te.Tensor) – 4维输入张量，NHWC布局 [批次, 高度, 宽度, 通道]
Scale (tvm.te.Tensor) – 缩放张量，一维通道数大小
Shift (tvm.te.Tensor) – 平移张量，1维且大小为通道数

Returns:

输出 – 输出张量，布局为NHWC

Return type:

tvm.te.Tensor

tvm.topi.nn.simplify(expr)

如果是Expr类型则简化表达式，如果是int类型则直接返回。

Parameters:: expr (Expr 或 int) - 输入参数。
Returns:: out – 简化后的输出
Return type:: 表达式或int

tvm.topi.nn.simulated_dequantize(data, in_dtype, input_scale=None, input_zero_point=None, axis=-1)

模拟QNN反量化操作的算子，在不改变数据类型的情况下模拟QNN输出。该算子相比真正的QNN反量化操作的优势在于：它允许动态选择数据类型，并且可以同时处理逐通道和标量的缩放因子与零点值，而QNN反量化操作要求在编译时固定这些参数。

Parameters:

data (tvm.te.Tensor) – 操作符的N维输入张量。
in_dtype (tvm.te.Tensor) – 一个标量变量，指示使用哪种数据类型来模拟去量化。使用SQNN_DTYPE_TO_CODE将数据类型字符串转换为相应的变量值。
input_scale (tvm.te.Tensor, optional) – 一个标量张量，表示从整数数据类型反量化时要使用的比例。当它包含多个值时，N必须与数据中的通道数匹配。
input_zero_point (tvm.te.Tensor, optional) – 一个一维张量，表示从整数数据类型反量化时使用的零点值。当它包含多个值时，N必须与数据中的通道数匹配。
axis (int, optional) – 量化处理的通道轴。默认值为-1，对应最后一个轴。

tvm.topi.nn.simulated_quantize(data, out_dtype, output_scale=None, output_zero_point=None, axis=-1)

模拟QNN量化操作符，在不改变数据类型的情况下模拟QNN输出。该操作符相比真正的QNN量化的优势在于：它允许动态选择数据类型，并且可以同时处理逐通道和标量的缩放因子和零点值，而QNN量化要求这些参数在编译时就必须固定。

Parameters:

data (tvm.te.Tensor) – 一个N维输入张量，作为运算符的输入。
out_dtype (tvm.te.Tensor) – 一个标量变量，用于指示使用哪种数据类型来模拟量化。使用SQNN_DTYPE_TO_CODE将数据类型字符串转换为相应的变量值。
output_scale (tvm.te.Tensor, optional) – 表示量化到整数数据类型时要使用的比例系数的标量张量。当它包含多个值时，N必须与数据中的通道数匹配。
output_zero_point (tvm.te.Tensor, optional) – 表示量化到整数数据类型时使用的零点的1维张量。当包含多个值时，N必须与数据中的通道数匹配。
axis (int, optional) – 量化处理的通道轴。默认值为-1，对应最后一个轴。

tvm.topi.nn.softmax(x, axis=-1)

对数据进行softmax激活。

Parameters:

data (tvm.te.Tensor) – 可以是任意维度
axis (int) – 通道轴

Returns:

output - 输出形状与输入相同

Return type:

tvm.te.Tensor

tvm.topi.nn.softmax_common(x, axis, use_fast_exp): softmax和fast_softmax的公共部分

tvm.topi.nn.softplus(x, beta=1.0, threshold=20.0)

为输入x计算具有数值稳定性的Softplus激活函数。

Parameters:

x (tvm.te.Tensor) – 输入张量。
beta (float, optional) – Softplus公式中的缩放因子β（默认为1.0）。
threshold (float, optional) – 数值稳定性的阈值（默认值为20.0）。

Returns:

y – 结果。

Return type:

tvm.te.Tensor

tvm.topi.nn.space_to_batch_nd(data, block_shape, pad_before, pad_after, pad_value=0.0)

对数据进行批量到空间的转换

Parameters:

data (tvm.te.Tensor) – 具有形状[batch, spatial_shape, remaining_shapes]的N维张量，其中spatial_shape有M个维度。
block_shape (list of ints) – 大小为[M]的列表，其中M是空间维度数，指定每个空间维度的块大小。
pad_before (list of ints) – 形状为[M]的列表，其中M是空间维度数，指定每个空间维度前的零填充大小。
pad_after (list of ints) – 形状为[M]的列表，其中M是空间维度数，指定每个空间维度后的零填充大小。
pad_value (float, optional) – 用于填充的值。

Returns:

输出

Return type:

tvm.te.Tensor

tvm.topi.nn.space_to_depth(data, block_size, layout='NCHW')

对数据进行空间到深度的转换

Parameters:

data (tvm.te.Tensor) – 4维张量，支持NCHW或NHWC布局格式。
block_size (int) – 分解到通道维度的块大小。
layout (string) - 可以是NCHW或NHWC，表示数据布局。

Returns:

output – 输出形状为 [N, C * block_size**2, H / block_size, W / block_size]

Return type:

tvm.te.Tensor

tvm.topi.nn.strided_slice(a, begin, end, strides=None, axes=None, slice_mode='end', assume_inbound=True)

数组切片。

Parameters:

a (tvm.te.Tensor) – 要被切片的张量。
begin (list of int) – 切片操作的起始索引列表。
end (list of int) – 表示切片结束位置的索引列表。
strides (list of int, optional) - 指定步长值，可以为负数。在这种情况下，输入张量将在特定轴上反转。
axes (list of int, optional) – 指定切片操作所沿的轴。当该参数被指定时，begin、end、strides和axes需要是相同长度的整数列表。
slice_mode (str, optional) – 切片模式 [end, size]。 end - 切片的结束索引 [默认模式]。 size - 将忽略输入步长，在此模式下输入end表示从begin指定位置开始的切片大小。如果end[i]为-1，则该维度中所有剩余元素都将包含在切片中。
assume_inbound (bool, optional) – 一个标志位，用于指示是否假定所有索引都在边界内

Returns:

返回值

Return type:

tvm.te.Tensor

tvm.topi.nn.unpack_NCHWc_to_nchw(packed_out, out_dtype)

将conv2d_NCHWc的输出从NCHWc布局解包为NCHW布局

Parameters:

packed_out (tvm.te.Tensor) – conv2d_NCHWc的输出张量。
out_dtype (str) – 输出数据类型。

Returns:

unpacked_out – 以NCHW布局展开的输出张量。

Return type:

tvm.te.Tensor

tvm.topi.nn.upsampling(data, scale_h, scale_w, layout='NCHW', method='nearest_neighbor', align_corners=False, output_shape=None)

Perform upsampling on the data.: 支持最近邻和双线性上采样。

Parameters:

inputs (tvm.te.Tensor) – inputs 是一个4维张量，形状为 [batch, channel, in_height, in_width] 或 [batch, in_height, in_width, channel]
scale_h (float) – 高度的缩放因子
scale_w (float) – 宽度缩放因子
layout (string, optional) – 可以是"NCHW"或"NHWC"
method ({"bilinear", "nearest_neighbor", "bicubic"}) – 用于上采样的方法。
output_shape (tvm.tir.container.Array, optional) – 返回的形状。如果留空则会自动推断（如果形状是动态确定的，请将out_dtype.shape作为output_shape传递）

Returns:

输出 – 4维张量，形状为 [批次大小, 通道数, 输入高度*缩放比例_h, 输入宽度*缩放比例_w] 或 [批次大小, 输入高度*缩放比例, 输入宽度*缩放比例, 通道数]

Return type:

tvm.te.Tensor

tvm.topi.nn.upsampling3d(data, scale_d, scale_h, scale_w, layout='NCDHW', method='nearest_neighbor', coordinate_transformation_mode='half_pixel', output_shape=None)

Perform upsampling on the data.: 支持最近邻和双线性上采样。

Parameters:

inputs (tvm.te.Tensor) – inputs是一个5维张量，形状为 [batch, channel, in_depth, in_height, in_width] 或 [batch, in_depth, in_height, in_width, channel]
scale_d (float) – 深度缩放因子
scale_h (float) – 高度的缩放因子
scale_w (float) – 宽度缩放因子
layout (string, optional) – 可以是"NCDHW"或"NDHWC"
method ({"trilinear", "nearest_neighbor"}) – 用于上采样的方法。
coordinate_transformation_mode (string, optional) – 描述如何将调整大小后的张量中的坐标转换为原始张量中的坐标。详情请参考ONNX Resize操作符规范。可用选项包括"half_pixel"、"align_corners"和"asymmetric"。
output_shape (tvm.tir.container.Array, optional) – 返回的形状。如果留空则会自动推断 (如果形状是动态确定的，请将out_dtype.shape作为output_shape传递)

Returns:

输出 – 5维张量，形状为 [批次, 通道, 输入深度*缩放比例, 输入高度*缩放比例, 输入宽度*缩放比例] 或 [批次, 输入深度*缩放比例, 输入高度*缩放比例, 输入宽度*缩放比例, 通道]

Return type:

tvm.te.Tensor

tvm.topi.nn.winograd_transform_matrices(tile_size, kernel_size, out_dtype): 计算针对 tile_size 作为 tvm.Expr 的 A、B 和 G 变换矩阵。

tvm.topi.nn.instance_norm(data, gamma, beta, axis, epsilon=1e-05)

实例归一化算子。

Parameters:

data (tvm.te.Tensor) – N维张量，形状为(d_0, d_1, ..., d_{N-1})
gamma (tvm.te.Tensor) – K维张量，形状为(r_0, r_1, ..., r_{K-1})，其中K等于轴的长度且d_{axis_k}等于r_k
beta (tvm.te.Tensor) – 可选参数，K维张量，形状为(r_0, r_1, ..., r_{K-1})，其中K == len(axis)且d_{axis_k} == r_k
axis (list of int) – 应用归一化的轴（计算均值和方差的轴向）
epsilon (float) - 用于避免除零错误的epsilon值。

Returns:

结果 – 一个N维数组，形状为 (d_0, d_1, …, d_{N-1})

Return type:

tvm.te.Tensor

tvm.topi.nn.layer_norm(data, gamma, beta, axis, epsilon=1e-05)

层归一化算子。它接受fp16和fp32作为输入数据类型。算子会将输入转换为fp32 进行计算。输出将与输入保持相同的数据类型。

Parameters:

data (tvm.te.Tensor) – N维张量，形状为(d_0, d_1, ..., d_{N-1})
gamma (tvm.te.Tensor) – K维张量，形状为(r_0, r_1, ..., r_{K-1})，其中K == len(axis)且d_{axis_k} == r_k
beta (tvm.te.Tensor) – 可选参数，K维张量，形状为(r_0, r_1, ..., r_{K-1})，其中K == len(axis)且d_{axis_k} == r_k
axis (list of int) – 应用归一化的轴
epsilon (float) - 用于避免除零错误的epsilon值。

Returns:

结果 – N维数组，形状为 (d_0, d_1, …, d_{N-1})

Return type:

tvm.te.Tensor

tvm.topi.nn.group_norm(data, gamma, beta, num_groups, channel_axis, axes, epsilon=1e-05)

分组归一化操作符。它接受fp16和fp32作为输入数据类型。它会将输入转换为fp32 来执行计算。输出将与输入具有相同的数据类型。

Parameters:

data (tvm.te.Tensor) – N维张量，形状为(d_0, d_1, ..., d_{N-1})
gamma (tvm.te.Tensor) – 一维张量，形状为(r_0)，其中r_0 == d_{channel_axis}
beta (tvm.te.Tensor) – 可选参数，一维张量，形状为(r_0)，其中r_0 == d_{channel_axis}
num_groups (int) – 分组数量
channel_axis (int) – 通道轴
axes (list of int) – 应用归一化的轴，不包括通道轴
epsilon (float) - 用于避免除零错误的epsilon值。

Returns:

结果 – 一个N维数组，形状为 (d_0, d_1, …, d_{N-1})

Return type:

tvm.te.Tensor

tvm.topi.nn.rms_norm(data, weight, axis, epsilon=1e-05)

均方根归一化操作符。输出将与输入具有相同的数据类型。

Parameters:

data (tvm.te.Tensor) – N维张量，形状为(d_0, d_1, ..., d_{N-1})
weight (tvm.te.Tensor) – K维张量，形状为(r_0, r_1, ..., r_{K-1})，其中K == len(axis)且d_{axis_k} == r_k
axis (list of int) – 应用归一化的轴
epsilon (float) - 用于避免除零错误的epsilon值。

Returns:

结果 – 一个N维数组，形状为 (d_0, d_1, …, d_{N-1})

Return type:

tvm.te.Tensor

tvm.topi.image

IMAGE 网络运营商

功能：

`affine_grid`(data, target_shape)	生成2D采样网格的affine_grid算子。
`can_convert_multiply_to_intdiv`(origin_size, ...)	检查是否可以将乘法转换为除法
`crop_and_resize`(data, boxes, box_indices, ...)	对数据进行裁剪和调整大小的操作。
`dilation2d_nchw`(input, filter, stride, ...)	NCHW布局中的形态学膨胀操作。
`dilation2d_nhwc`(input, filter, stride, ...)	形态学二维膨胀NHWC布局。
`get_1d_indices`(indices[, layout])	获取一维索引
`get_1d_pixel`(data, layout, image_width, n, ...)	获取1d像素
`get_2d_indices`(indices[, layout])	获取二维索引
`get_2d_pixel`(data, layout, image_height, ...)	获取2D像素
`get_3d_indices`(indices[, layout])	获取3D索引
`get_3d_pixel`(data, layout, image_depth, ...)	获取3D像素
`get_closest_index`(in_x, rounding_method, boxes)	根据指定的舍入方法获取最接近某个值的索引
`get_inx`(x, image_width, target_width, ...[, ...])	通过多种坐标变换方法从输出x反推输入x
`get_pad_tuple`(padding, kernel)	获取填充选项的通用代码
`grid_sample`(data, grid[, method, layout, ...])	对输入特征图应用网格采样。
`nchw_pack_layout`(layout_info)	检查布局类型是否为NCHWinic
`nchw_xc_layout`(layout_info)	检查布局类型是否为NCHWxc
`pad`(data, pad_before[, pad_after, ...])	用零填充输入。
`resize1d`(data, roi, size[, layout, method, ...])	对数据执行调整大小的操作。
`resize2d`(data, roi, size[, layout, method, ...])	对数据执行调整大小操作。
`resize3d`(data, roi, size[, layout, method, ...])	对数据执行调整大小操作。
`simplify`(expr)	如果是Expr类型则简化表达式，如果是int类型则直接返回。

tvm.topi.image.affine_grid(data, target_shape)

生成2D采样网格的affine_grid算子。

此操作在https://arxiv.org/pdf/1506.02025.pdf中有详细描述。它会在目标形状内生成一个均匀采样网格，并将其归一化到[-1, 1]范围。然后对采样网格应用提供的仿射变换。

Parameters:

data (tvm.Tensor) – 三维张量，形状为 [batch, 2, 3]。表示仿射矩阵。
target_shape (list/tuple of two int) - 指定输出形状(H, W)。

Returns:

输出 – 4维张量，形状为 [batch, 2, target_height, target_width]

Return type:

tvm.Tensor

tvm.topi.image.can_convert_multiply_to_intdiv(origin_size, scaled_size): 检查是否可以将乘法转换为除法

tvm.topi.image.crop_and_resize(data, boxes, box_indices, crop_size, layout='NCHW', method='bilinear', extrapolation_value=None, out_dtype=None)

对数据进行裁剪和调整大小的操作。

Parameters:

data (tvm.te.Tensor) – 输入是一个4维张量，形状为 [batch, channel, in_height, in_width] 或 [batch, in_height, in_width, channel]
boxes (tvm.te.Tensor) – 一个形状为[num_boxes, 4]的2维张量。张量的每一行指定了一个框的坐标。
box_indices (tvm.te.Tensor) – 一个形状为[num_boxes]的一维张量，box_indices[i]指定了第i个框所引用的数据。
crop_size (Tuple) – 每个框的目标尺寸。
layout (string, optional) – "NCHW", "NHWC"
method ({"bilinear", "nearest_neighbor"}) – 用于调整大小的插值方法。
extrapolation_value (float, optional) - 用于外推的值（如适用时）。
out_dtype (string, optional) – 返回类型。如果留空则与输入类型相同。

Returns:

输出 – 4维数组，形状为 [num_boxes, channel, crop_height, crop_width] 或 [num_boxes, crop_height, crop_width, channel]

Return type:

tvm.te.Tensor

tvm.topi.image.dilation2d_nchw(input, filter, stride, padding, dilations, out_dtype=None)

NCHW布局中的形态学膨胀操作。

Parameters:

输入 (tvm.te.Tensor) – 4维张量，形状为 [批次大小, 输入通道数, 输入高度, 输入宽度]
filter (tvm.te.Tensor) – 3维张量，形状为[输入通道数, 滤波器高度, 滤波器宽度]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int 或 str) - 填充大小
dilations (int 或 列表/元组包含 两个整数) – 扩张尺寸，或 [扩张高度, 扩张宽度]
out_dtype (Optional[str]) – 指定输出数据类型。

Returns:

输出 – 4维张量，形状为 [batch, in_channel, out_height, out_width]

Return type:

tvm.te.Tensor

tvm.topi.image.dilation2d_nhwc(input, filter, stride, padding, dilations, out_dtype=None)

形态学二维膨胀NHWC布局。

Parameters:

input (tvm.te.Tensor) – 4维张量，形状为[batch, in_height, in_width, in_channel]
filter (tvm.te.Tensor) – 3维张量，形状为[filter_height, filter_width, in_channel]
stride (int 或 两个整数的列表/元组) – 步长大小，或 [纵向步长, 横向步长]
padding (int) – 填充大小
dilations (int 或 列表/元组包含 两个整数) – 膨胀尺寸，或 [dilation_height, dilation_width]
out_dtype (Optional[str]) - 指定输出数据类型。

Returns:

输出 – 4维张量，形状为 [batch, out_height, out_width, in_channel]

Return type:

tvm.te.Tensor

tvm.topi.image.get_1d_indices(indices, layout='NCW'): 获取一维索引

tvm.topi.image.get_1d_pixel(data, layout, image_width, n, c, x, cc, ib, ic): 获取1d像素

tvm.topi.image.get_2d_indices(indices, layout='NCHW'): 获取二维索引

tvm.topi.image.get_2d_pixel(data, layout, image_height, image_width, n, c, y, x, cc, ib, ic): 获取2D像素

tvm.topi.image.get_3d_indices(indices, layout='NCDHW'): 获取3D索引

tvm.topi.image.get_3d_pixel(data, layout, image_depth, image_height, image_width, n, c, z, y, x, cc): 获取3D像素

tvm.topi.image.get_closest_index(in_x, rounding_method, boxes, use_int_div=False): 根据指定的舍入方法获取最接近某个值的索引

tvm.topi.image.get_inx(x, image_width, target_width, coordinate_transformation_mode, start_x=0, end_x=-1, use_int_div=False): 通过多种坐标变换方法从输出x反推输入x

tvm.topi.image.get_pad_tuple(padding, kernel)

获取填充选项的通用代码

Parameters:

padding (int 或 str) – 填充大小，或 [‘VALID’, ‘SAME’]
kernel (tuple of int) – 卷积核大小

Returns:

pad_top (int) – 顶部填充大小
pad_left (int) – 左侧填充大小
pad_down (int) – 底部填充大小
pad_right (int) – 右侧填充大小

tvm.topi.image.grid_sample(data, grid, method='bilinear', layout='NCHW', padding_mode='zeros', align_corners=True)

对输入特征图应用网格采样。

给定 \(data\) 和 \(grid\)，对于4维情况，输出通过以下方式计算

\[x_{src} = grid[batch, 0, y_{dst}, x_{dst}] \ y_{src} = grid[batch, 1, y_{dst}, x_{dst}] \ output[batch, channel, y_{dst}, x_{dst}] = G(data[batch, channel, y_{src}, x_{src}])\]

\(x_{dst}\), \(y_{dst}\) 枚举了\(output\)中的所有空间位置， \(G()\) 表示插值函数。

如果padding_mode为“zeros”，则边界外点将用零填充；如果padding_mode为“border”，则使用边界像素值；如果padding_mode为“reflection”，则使用内部像素值。

网格中的左上角(-1, -1)和右下角(1, 1)将被映射到数据的(0, 0)和(h - 1, w - 1)（如果align_corners为"True"），或数据的(-0.5, -0.5)和(h - 0.5, w - 0.5)（如果align_corners为"False"）。

输出的形状将是 4维 (data.shape[0], data.shape[1], grid.shape[2], grid.shape[3])，或 5维 (data.shape[0], data.shape[1], grid.shape[2], grid.shape[3], grid.shape[4])。

该算子假设\(grid\)已被归一化到[-1, 1]区间。

grid_sample 通常与 affine_grid 配合使用，后者为 grid_sample 生成采样网格。

Parameters:

data (tvm.Tensor) – 4维张量，形状为[batch, in_channel, in_height, in_width]，或 5维张量，形状为[batch, in_channel, in_depth, in_height, in_width]
grid (tvm.Tensor) – 4维张量，形状为 [batch, 2, out_height, out_width]，或 5维张量，形状为 [batch, 3, out_depth, out_height, out_width]
method (str) – 插值方法，支持4-D的"nearest"、"bilinear"、"bicubic"和5-D的"nearest"、"bilinear"("trilinear")。
layout (str) – 输入数据和输出的布局方式。
padding_mode (str) – 外部网格值的填充模式，支持"zeros"、"border"、"reflection"。
align_corners (bool) – 从几何角度而言，我们将输入像素视为方块而非点。若设为"True"，极值("-1"和"1")将被视为指向输入角像素的中心点。若设为"False"，则被视为指向输入角像素的角点，从而使采样过程与分辨率无关。

Returns:

输出 – 4维形状 [batch, in_channel, out_height, out_width]，或 5维形状 [batch, in_channel, out_depth, out_height, out_width]

Return type:

tvm.Tensor

tvm.topi.image.nchw_pack_layout(layout_info): 检查布局类型是否为NCHWinic

tvm.topi.image.nchw_xc_layout(layout_info): 检查布局类型是否为NCHWxc

tvm.topi.image.pad(data, pad_before, pad_after=None, pad_value=0.0, name='PadInput', attrs=None)

用零填充输入。

Parameters:

data (tvm.te.Tensor) – n维输入，可以是任意布局。
pad_before (list / tuple of n ints) – 在每个维度上填充的宽度，用于在轴开始前进行填充。
pad_after (list / tuple of n ints, optional) – 在每个维度上指定填充宽度，用于在轴末端之后进行填充。
pad_value (float, optional) – 用于填充的值。
name (str, optional) – 生成运算符的名称前缀

Returns:

输出 – n维，与输入保持相同的布局。

Return type:

tvm.te.Tensor

tvm.topi.image.resize1d(data, roi, size, layout='NCW', method='linear', coordinate_transformation_mode='half_pixel', rounding_method='', bicubic_alpha=-0.5, bicubic_exclude=0, extrapolation_value=0.0, out_dtype=None, output_shape=None)

对数据执行调整大小操作。

Parameters:

data (tvm.te.Tensor) – 输入是一个三维张量，形状为 [batch, channel in_width] 或 [batch in_width, channel]
roi (Tuple of Float or Expr) – 用于裁剪输入图像的兴趣区域。预期大小为2，格式为[start_w, end_w]。仅在coordinate_transformation_mode为tf_crop_and_resize时使用。
size (Tuple) – 输出分辨率缩放至
layout (string, optional) – "NCW", "NWC", 或 "NCWc"。
coordinate_transformation_mode (string, optional) – 描述如何将调整大小后的张量中的坐标转换为原始张量中的坐标。详情请参考ONNX Resize操作符规范。可用选项包括"half_pixel"、"align_corners"和"asymmetric"。
method (string, optional) – 插值方法（"nearest", "linear", "bicubic"）
coordinate_transformation_mode - 描述如何将调整大小后的张量中的坐标转换为原始张量中的坐标。 [half_pixel, align_corners, asymmetric, pytorch_half_pixel, tf_half_pixel_for_nn, 和 tf_crop_and_resize]。
rounding_method – 坐标位置舍入方法
bicubic_alpha (float, optional) – 双三次样条系数
bicubic_exclude (bool, optional:) – 排除图像外部的值以进行双三次插值
extrapolation_value (float, optional) - 用于外推的值（如适用时）。
out_dtype (string, optional) – 返回类型。如果留空则与输入类型相同。
output_shape (tvm.tir.container.Array, optional) – 返回的形状。如果留空则会自动推断 (如果形状是动态确定的，请将out_dtype.shape作为output_shape传递)

Returns:

输出 – 4维张量，形状为 [批次, 通道数, 输入宽度*缩放比例] 或 [批次, 输入宽度*缩放比例, 通道数] 或 5维张量，形状为 [批次, 主通道, 输入宽度*缩放比例, 次通道]

Return type:

tvm.te.Tensor

tvm.topi.image.resize2d(data, roi, size, layout='NCHW', method='linear', coordinate_transformation_mode='half_pixel', rounding_method='', bicubic_alpha=-0.5, bicubic_exclude=0, extrapolation_value=0.0, out_dtype=None, output_shape=None)

对数据执行调整大小操作。

Parameters:

data (tvm.te.Tensor) – 输入是一个4维张量，形状为 [batch, channel, in_height, in_width] 或 [batch, in_height, in_width, channel]
roi (Tuple of Float or Expr) – 用于裁剪输入图像的兴趣区域。预期大小为4，格式为[start_h, start_w, end_h, end_w]。仅当coordinate_transformation_mode为tf_crop_and_resize时使用。
size (Tuple) – 输出分辨率缩放至
layout (string, optional) - "NCHW"、"NHWC"或"NCHWc"。
method (string, optional) – 插值方法（"nearest"、"linear"、"bicubic"）
coordinate_transformation_mode (string, optional) – 描述如何将调整大小后的张量中的坐标转换为原始张量中的坐标。 [half_pixel, align_corners, asymmetric, pytorch_half_pixel, tf_half_pixel_for_nn, and tf_crop_and_resize].
rounding_method – 坐标位置舍入方法
bicubic_alpha (float, optional) – 双三次样条系数
bicubic_exclude (bool, 可选参数:) – 在双三次插值时排除图像外的值
extrapolation_value (float, optional) - 用于外推的值（如适用时）。
out_dtype (string, optional) – 返回类型。如果留空则与输入类型相同。
output_shape (tvm.tir.container.Array, optional) – 返回的形状。如果留空则会自动推断 (如果形状是动态确定的，请将out_dtype.shape作为output_shape传递)

Returns:

输出 – 4维形状 [batch, channel, in_height*scale, in_width*scale] 或 [batch, in_height*scale, in_width*scale, channel] 或 5维形状 [batch, channel-major, in_height*scale, in_width*scale, channel-minor]

Return type:

tvm.te.Tensor

tvm.topi.image.resize3d(data, roi, size, layout='NCDHW', method='linear', coordinate_transformation_mode='half_pixel', rounding_method='', bicubic_alpha=-0.5, bicubic_exclude=0, extrapolation_value=0.0, out_dtype=None, output_shape=None)

对数据执行调整大小操作。

Parameters:

data (tvm.te.Tensor) – 输入是一个5维张量，形状为 [batch, channel, in_depth, in_height, in_width] 或 [batch, in_depth, in_height, in_width, channel]
roi (Tuple of Float or Expr) – 用于裁剪输入图像的兴趣区域。预期大小为6，格式为[start_d, start_h, start_w, end_d, end_h, end_w]。仅在coordinate_transformation_mode为tf_crop_and_resize时使用。
size (Tuple) – 输出分辨率缩放至
layout (string, optional) - "NCDHW"、"NDHWC"或"NCDHWc"。
method (string, optional) – 插值方法（"nearest", "linear", "bicubic"）
coordinate_transformation_mode (string, optional) – 描述如何将调整大小后的张量中的坐标转换为原始张量中的坐标。 [half_pixel, align_corners, asymmetric, pytorch_half_pixel, tf_half_pixel_for_nn, and tf_crop_and_resize].
rounding_method – 坐标位置舍入方法
bicubic_alpha (float, optional) – 双三次样条系数
bicubic_exclude (bool, 可选参数:) – 在双三次插值时排除图像外部的值
extrapolation_value (float, optional) - 用于外推的值（如适用时）。
out_dtype (string, optional) – 返回类型。如果留空则与输入类型相同。
output_shape (tvm.tir.container.Array, optional) – 返回的形状。如果留空则会自动推断 (如果形状是动态确定的，请将out_dtype.shape作为output_shape传递)

Returns:

输出 – 4维张量，形状为 [批次, 通道, 输入深度*缩放比例, 输入高度*缩放比例, 输入宽度*缩放比例] 或 [批次, 输入深度*缩放比例, 输入高度*缩放比例, 输入宽度*缩放比例, 通道] 或 5维张量，形状为 [批次, 主通道, 输入深度*缩放比例, 输入高度*缩放比例, 输入宽度*缩放比例, 次通道]

Return type:

tvm.te.Tensor

tvm.topi.image.simplify(expr)

如果是Expr类型则简化表达式，如果是int类型则直接返回。

Parameters:: expr (Expr 或 int) - 输入参数。
Returns:: out – 简化后的输出
Return type:: 表达式或int