[翻译]relay核心张量算子— tvm 0.7.dev0文档

本页面包含tvm.relay中预定义的核心张量算子原语的列表。核心张量算子原语涵盖深度学习中的典型工作量。它们可以代表前端框架中的工作负载，并提供用于优化的基本构建块。由于深度学习是一个快速发展的领域，因此可能会有不在这里的算子。
注意
本文档将直接在python前端中列出这些算子的功能签名。

算子概述

1级：基本算子
此级别可实现完全连接的多层感知器。

第2级：卷积
此级别启用典型的convnet模型。

级别3：附加的数学和变换算子
此级别启用了其他数学算子和转换算子。

级别4：广播和缩减

5级：视觉/图像算子

第6级：算法算子

10级：临时算子
此级别支持广播运营商的反向传播。这是暂时的。

11级：方言算子
此级别支持方言算子。

1级定义

tvm.relay.log（数据）
计算数据的逐元素日志。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.sqrt（数据）
计算数据的逐元素sqrt。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.rsqrt（数据）
计算数据的逐元素rsqrt。
1/sqrt(x)
1/sqrt(x)
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.exp（数据）
计算数据的逐元素表达式。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.sigmoid（数据）
计算数据的元素S形。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.add（lhs，rhs ）
加上numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
例子
x = relay.Var(“a”) # shape is [2, 3]
y = relay.Var(“b”) # shape is [2, 1]
z = relay.add(x, y) # result shape is [2, 3]
tvm.relay.subtract（lhs，rhs ）
用numpy风格的广播进行减法。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.multiply（lhs，rhs ）
与numpy风格的广播相乘。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.divide（lhs，rhs ）
划分为numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.floor_divide（lhs，rhs ）
楼层划分，采用numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.mod（lhs，rhs ）
Mod具有Numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.floor_mod（lhs，rhs ）
Floor numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.tanh（数据）
计算数据的逐元素tanh。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.concatenate（数据，轴）
沿给定轴连接输入张量。
参量

• data（Union （List （列表[ relay.Expr ] ，Tuple [ relay.Expr ]] ））–张量的列表。
  
• axis（int）–张量的连接轴。
  

退货
结果 –级联张量。
返回类型
relay.expr
tvm.relay.expand_dims（data，axis，num_newaxis = 1 ）
在axis指定的位置插入num_newaxis 轴。
参量

• data（relay.Expr）–算子的输入数据。
  
• axis（int）–扩展输入数组的轴。应该在[-data.ndim-1，data.ndim]范围内。如果axis <0，则为第一个插入的轴；否则为0。如果axis> = 0，则它是Python负索引中插入的最后一个轴。
  
• num_newaxis（int）–要插入的轴数。应该> = 0。
  

退货
结果 –重塑的结果。
返回类型
relay.expr
tvm.relay.nn.softmax（data，axis = -1 ）
计算softmax。
softmax(x)i=exp(xi)∑jexp(xj)
softmax(x)i=exp(xi)∑jexp(xj)
注意
可以对该算子进行优化以进行推理。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• axis（int，可选）–计算softmax时求和的轴
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.log_softmax（data，axis = -1 ）
计算日志softmax。
log_softmax(x)i=logexp(xi)∑jexp(xj)
log_softmax(x)i=log⁡exp(xi)∑jexp(xj)
注意
可以对该算子进行优化以进行推理。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• axis（int）–计算softmax时求和的轴
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.relu（数据）
整流线性单元。
out=max(x,0)
out=max(x,0)
参量
data（tvm.relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.dropout（data，rate = 0.5 ）
将dropout操作应用于输入数组。
在训练期间，输入的每个元素均以概率设置为零**p**。整个数组将按比例缩放，**1/(1-p)** 以保持输入的预期总和不变。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• rate（float，可选（默认= 0.5 ））–元素重置为0的概率。
  

退货
结果 –辍学的结果
返回类型
tvm.relay.Expr
tvm.relay.nn.batch_norm（data，gamma，beta，moving_mean，moving_var，axis = 1，epsilon = 1e-05，center = True，scale = True ）
批次归一化层（Ioffe和Szegedy，2014年）。标准化每个批次的输入，即应用转换以将平均激活保持在接近0并将激活标准偏差保持在1附近。
datamean[i]=mean(data[:,i,:,…])datavar[i]=var(data[:,i,:,…])
datamean[i]=mean(data[:,i,:,…])datavar[i]=var(data[:,i,:,…])
然后计算归一化的输出，该输出具有与输入相同的形状，如下所示：
out[:,i,:,…]=data[:,i,:,…]−datamean[i]datavar[i]+ϵ−−−−−−−−−−−−√∗gamma[i]+beta[i]
out[:,i,:,…]=data[:,i,:,…]−datamean[i]datavar[i]+ϵ∗gamma[i]+beta[i]
两个平均和变种返回通过处理输入作为向量标量。
假设输入具有大小__ķ上轴1，则两个**gamma**和**beta** 具有形状（K） 。
除了输入和输出之外，该算子还接受两个辅助状态**moving_mean**和**moving_var**，它们是__k个长度的向量。它们是整个数据集的全局统计信息，通过以下方式更新：
moving_mean = Moving_mean 动量+ data_mean （1-动量）Moving_var = Moving_var 动量+ data_var （1-动量）
该参数**axis**指定输入形状的哪条轴表示“通道”（分别归一化的组）。默认值为1。指定-1会将通道轴设置为输入形状中的最后一项。
注意
可以对该算子进行优化以进行推理。
参量

• 数据（tvm.relay.Expr）–将batch_norm应用到的输入。
  
• gamma（tvm.relay.Expr）–伽玛比例因子。
  
• beta（tvm.relay.Expr）– Beta偏移因子。
  
• moving_mean（tvm.relay.Expr）–输入的运行平均值，
  
• moving_var（tvm.relay.Expr）–输入的运行方差。
  
• axis（int，optional ，default = 1__）–指定沿哪个形状轴指定通道。
  
• epsilon（double ，可选的，默认值= 1e-5__）–将小浮点数添加到方差以避免被零除。
  
• center（boolean ，optional ，default = True）–如果为True，则将beta的偏移量添加到标准化张量；如果为False，则忽略beta。
  
• scale（boolean ，optional ，default = True）–如果为true，则乘以gamma。如果为False，则不使用伽玛。当下一层是分段线性的（也例如nn.relu）时，可以禁用此功能，因为缩放将由下一层完成。
  

退货
结果 –标准数据元组（与输入形状相同），新的运行均值（k长度向量）和新的运行方差（k长度向量）
返回类型
relay.Tuple（[tvm.relay.Expr，tvm.relay.Expr，tvm.relay.Expr]）
tvm.relay.nn.bias_add（data，bias，axis = 1 ）
add_bias算子。
向数据轴添加一维偏移。此功能是加法的一种特殊情况，它允许从数据推断偏差的形状。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• bias（tvm.relay.Expr）–要添加的偏差。
  
• axis（int，可选）–要添加偏差的轴。
  

退货
结果 –最终结果。
返回类型
tvm.relay.Expr

2级定义

tvm.relay.nn.conv2d（数据，重量，步幅=（1，1） ，填充=（0，0） ，扩张=（1，1） ，基团= 1，通道=无，kernel_size =无，data_layout = ‘NCHW’ ，kernel_layout =” OIHW’，out_layout =’’，out_dtype =’’ ） [源代码）
2D卷积。
该算子将权重作为卷积内核，并将其与数据卷积以产生输出。
在默认情况下，data_layout为NCHW 且kernel_layout为OIHW，conv2d接收形状为（batch_size，in_channels，height，width）的数据Tensor ，以及形状为（channels，in_channels，kernel_size [0]，kernel_size的权重Tensor [1]） 产生具有以下规则的输出张量：
out[b,c,y,x]=∑dy,dx,kdata[b,k,strides[0]∗y+dy,strides[1]∗x+dx]∗weight[c,k,dy,dx]
out[b,c,y,x]=∑dy,dx,kdata[b,k,strides[0]∗y+dy,strides[1]∗x+dx]∗weight[c,k,dy,dx]
在计算之前，分别对数据和权重应用填充和扩展。该算子接受数据布局规范。语义上，操作者将布局转换成规范的布局（NCHW用于数据和OIHW为重量），执行计算，然后转换为out_layout。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 重量（tvm.relay.Expr）–重量表达式。
  
• 步幅（可选[ int，Tuple [ int ] ]__）–卷积的步幅。
  
• padding（可选[ int，Tuple [ int ] ]__）–卷积之前在输入两侧的卷积填充。
  
• dilation（可选[ int，Tuple [ int ] ]__）–指定用于卷积卷积的膨胀率。
  
• groups（可选[ int ]__）–分组卷积的组数。
  
• 通道（可选[ int ]__）–此卷积的输出通道数。
  
• kernel_size（可选[ int，Tuple [ int ] ]__）–卷积内核的空间。
  
• data_layout（可选[ str ]__）–输入的布局。
  
• kernel_layout（可选[ str ]__）–权重的布局。
  
• out_layout（可选[ str ]__）–输出的布局，默认情况下，out_layout与data_layout相同
  
• out_dtype（可选[ str ]__）–指定混合精度conv2d的输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.conv2d_transpose（数据，重量，步幅=（1，1） ，填充=（0，0） ，扩张=（1，1） ，基团= 1，通道=无，kernel_size =无，data_layout = ‘NCHW’ ，kernel_layout =” OIHW”，out_layout = ‘’ ，output_padding =（0，0） ，out_dtype = ‘’ ）
二维转置卷积算符。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 重量（tvm.relay.Expr）–重量表达式。
  
• 步幅（Tuple [ int ] ，可选__）–卷积的步幅。
  
• padding（Tuple [ int ] ，可选__）–输入两侧的卷积填充。
  
• dilation（Tuple [ int ] ，可选__）–指定用于扩张卷积的扩张率。
  
• 通道（int，可选）–此卷积的输出通道数。
  
• kernel_size（int的元组，可选）–卷积内核的空间。
  
• groups（int，可选）–分组卷积的组数。
  
• data_layout（str，optional）–输入的布局。
  
• kernel_layout（str，optional）–权重的布局。
  
• out_layout（可选[ str ]__）–输出的布局，默认情况下，out_layout与data_layout相同
  
• output_padding（Tuple [ int ] ，可选__）–附加零填充将添加到输出的一侧。
  
• out_dtype（str，可选）–指定混合精度conv2d的输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.dense（data，weight，units = None，out_dtype =’’ ）
密集算子。应用线性变换
Y = X W
*参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 重量（tvm.relay.Expr）–重量表达式。
  
• 单位（整数，可选）–密集转换的隐藏单位数。
  
• out_dtype（str，可选）–指定混合精度密集型的输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.max_pool2d（数据，pool_size =（1，1） ，步幅=（1，1） ，填充=（0，0） ，布局= ‘NCHW’ ，ceil_mode =假）
二维最大池化算子。
此算子将数据作为输入，并通过stride定义的跨度在pool_size大小的窗口中进行2D最大值计算
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据Tensor 生成具有以下规则的输出Tensor：
具有形状（b，c，h，w）和pool_size（kh，kw）的数据
out(b,c,y,x)=maxm=0,…,kh−1maxn=0,…,kw−1data(b,c,stride[0]∗y+m,stride[1]∗x+n)
out(b,c,y,x)=maxm=0,…,kh−1maxn=0,…,kw−1data(b,c,stride[0]∗y+m,stride[1]∗x+n)
在计算之前将填充应用于数据。ceil_mode用于在计算形状时取下天花板或地板。该算子接受数据布局规范。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 跨步（int的元组，可选）–合并的跨步。
  
• padding（int的元组，可选）–池的填充。
  
• layout（str，optional）–输入的布局。
  
• ceil_mode（bool，可选）–在池化时启用或禁用ceil。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.max_pool3d（数据，pool_size =（1，1，1） ，步幅=（1，1，1） ，填充=（0，0，0） ，布局= ‘NCDHW’ ，ceil_mode =假）
3D最大池化算子。
该算子将数据作为输入，并通过stride定义的跨度在pool_size大小的窗口中进行3D最大值计算。
在默认情况下，data_layout为NCDHW时 ，形状为（batch_size，channels，depth，height，width）的数据Tensor 会生成输出Tensor。
ceil_mode用于在计算形状时获取天花板或地板。count_include_pad指示在计算中包括或排除填充的输入值。该算子接受数据布局规范。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 跨步（int的元组，可选）–合并的跨步。
  
• padding（int的元组，可选）–池的填充。
  
• layout（str，optional）–输入的布局。
  
• ceil_mode（bool，可选）–在池化时启用或禁用ceil。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.avg_pool2d（数据，pool_size =（1，1） ，步幅=（1，1） ，填充=（0，0） ，布局= ‘NCHW’ ，ceil_mode = FALSE，count_include_pad =假）
2D平均池化算子。
该算子将数据作为输入，并通过stride定义的跨度在pool_size大小的窗口中进行2D平均值计算
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据Tensor 生成具有以下规则的输出Tensor：
具有形状（b，c，h，w），pool_size（kh，kw）的数据
out(b,c,y,x)=1kh∗kw∑m=0kh−1∑n=0kw−1data(b,c,stride[0]∗y+m,stride[1]∗x+n)
out(b,c,y,x)=1kh∗kw∑m=0kh−1∑n=0kw−1data(b,c,stride[0]∗y+m,stride[1]∗x+n)
在计算之前将填充应用于数据。ceil_mode用于在计算形状时取下天花板或地板。count_include_pad指示在计算中包括或排除填充的输入值。该算子接受数据布局规范。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 跨步（int的元组，可选）–合并的跨步。
  
• padding（int的元组，可选）–池的填充。
  
• layout（str，optional）–输入的布局。
  
• ceil_mode（bool，可选）–在池化时启用或禁用ceil。
  
• count_include_pad（bool，可选）–包括填充以计算平均值。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.avg_pool3d（数据，pool_size =（1，1，1） ，步幅=（1，1，1） ，填充=（0，0，0） ，布局= ‘NCDHW’ ，ceil_mode =假，count_include_pad =假）
3D平均池化算子。
该算子将数据作为输入，并通过stride定义的跨度在pool_size大小的窗口中进行3D平均值计算
在默认情况下，data_layout为NCDHW时 ，形状为（batch_size，channels，depth，height，width）的数据Tensor 会生成输出Tensor。
ceil_mode用于在计算形状时获取天花板或地板。count_include_pad指示在计算中包括或排除填充的输入值。该算子接受数据布局规范。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 跨步（int的元组，可选）–合并的跨步。
  
• padding（int的元组，可选）–池的填充。
  
• layout（str，optional）–输入的布局。
  
• ceil_mode（bool，可选）–在池化时启用或禁用ceil。
  
• count_include_pad（bool，可选）–包括填充以计算平均值。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.global_max_pool2d（data，layout =’NCHW’ ）
二维全局最大池化算子。
该算子将数据作为输入，并跨WxH表示的每个窗口进行2D最大值计算。
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据Tensor 生成具有以下规则的输出Tensor：
具有形状（b，c，h，w）的数据
out(b,c,1,1)=maxm=0,…,hmaxn=0,…,wdata(b,c,m,n)
out(b,c,1,1)=maxm=0,…,hmaxn=0,…,wdata(b,c,m,n)
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• layout（str，optional）–输入的布局。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.global_avg_pool2d（data，layout =’NCHW’ ）
二维全球平均池化算子。
该算子将数据作为输入，并跨WxH表示的每个窗口进行2D平均值计算。
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据Tensor 生成具有以下规则的输出Tensor：
具有形状（b，c，h，w）的数据
out(b,c,1,1)=1h∗w∑m=0h−1∑n=0w−1data(b,c,m,n)
out(b,c,1,1)=1h∗w∑m=0h−1∑n=0w−1data(b,c,m,n)
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• layout（str，optional）–输入的布局。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.upsampling（data，scale_h = 1，scale_w = 1，layout =’NCHW’，method =’nearest_neighbor’，align_corners = False ）
上采样。
该算子将数据作为输入，并按2D比例缩放到给定的比例因子。在默认情况下，如果data_layout为NCHW ，且形状为（n，c，h，w）的数据将具有形状（n，c，h scale_h，w scale_w）
method表示在计算out值时要使用的算法，并且method可以是（“ bilinear”，“ nearest_neighbor”，“ bicubic”）之一
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• scale_h（tvm.relay.Expr）–高度采样的比例因子。
  
• scale_w（tvm.relay.Expr）–宽度上采样的比例因子。
  
• layout（str，optional）–输入的布局。
  
• method（str，optional）–使用的缩放方法[nearest_neighbor，双线性，双三次]。
  
• align_corners（bool，可选）–是否将角保持在适当的位置。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.upsampling3d（data，scale_d = 1，scale_h = 1，scale_w = 1，layout =’NCDHW’，method =’nearest_neighbor’，坐标_transformation_mode =’half_pixel’ ）
3D升采样。
该算子将数据作为输入，并进行3D缩放到给定的缩放因子。在默认情况下，如果data_layout是NCDHW ，且形状为（n，c，d，h，w）的数据将具有形状（n，c，d scale_d，h scale_h，w scale_w）
method表示在计算out值时要使用的算法，并且method可以是（“ trilinear”，“ nearest_neighbor”）之一
*参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• scale_d（tvm.relay.Expr）–深度上采样的比例因子。
  
• scale_h（tvm.relay.Expr）–高度采样的比例因子。
  
• scale_w（tvm.relay.Expr）–宽度上采样的比例因子。
  
• layout（str，optional）–输入的布局。
  
• method（str，optional）–使用的缩放方法[nearest_neighbor，trilinear]。
  
• ordinate_transformation_mode（字符串，可选）–描述如何将调整后的张量中的坐标转换为原始张量中的坐标。有关详细信息，请参阅ONNX Resize算子规范。可用选项为“ half_pixel”，“ align_corners”和“ asymmetric”。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.batch_flatten（数据）
BatchFlatten。
此算子将展平除批次尺寸外的所有尺寸。结果是2D输出。
对于具有形状的数据， batchflatten（data）返回shape的重塑输出。(d1, d2, …, dk)(d1, d2…dk)
参量
data（tvm.relay.Expr）–算子的输入数据。
退货
结果 –拼合结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.pad（data，pad_width，pad_value = 0.0，pad_mode =’constant’_ ）
填充
该算子输入一个张量，并使用指定的值将每个轴按指定的宽度填充。
参量

• data（tvm.relay.Expr）–算子的输入数据
  
• pad_width（>的<tuple的元组，必需的）–填充到每个轴的边缘的值的数量，格式为（（before_1，after_1），…，（before_N，after_N））
  
• pad_value（float，optional ，default = 0.0__）–用于填充的值
  
• pad_mode（‘constant’ ，‘edge’ ，‘reflect’）–具有常数值的’constant’焊盘pad_value’edge’焊盘，使用输入数组的边缘值，通过反射与边缘有关的值来使用
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.lrn（data，size = 5，axis = 1，bias = 2，alpha = 1e-05，beta = 0.75 ）
该算子将数据作为输入并进行本地响应归一化。
在特征地图之间或内部的本地区域中对输入进行标准化。每个输入值除以（data /（bias +（alpha sum_data ^ 2 / size））^ beta），其中n是每个局部区域的大小，总和取于以该值为中心的区域（零填充）在必要时添加）。
(data/(bias+(alpha∗sumdata2/size))beta)
(data/(bias+(alpha∗sumdata2/size))beta)
*参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• size（int，optional）–要进行标准化的本地区域的大小。
  
• axis（int，可选）–输入数据布局通道轴。NCHW格式的默认值为1
  
• bias（float，optional）–避免被0除的offset参数。
  
• alpha（float，可选）–缩放参数。
  
• beta（float，可选）–指数参数。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.l2_normalize（data，eps，axis = None ）
对输入数据执行L2归一化
y(i,j)=x(i,j)/sqrt(max(sum(x2),eps))
y(i,j)=x(i,j)/sqrt(max(sum(x2),eps))
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• eps（浮点数）– epsilon值
  
• 轴（int的列表，可选）–超过所应用规范化的轴
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.contrib_conv2d_winograd_without_weight_transform（数据，重量，TILE_SIZE，步幅=（1，1） ，填充=（0，0） ，扩张=（1，1） ，基团= 1，通道=无，kernel_size =无，data_layout = ‘NCHW’ ，kernel_layout =’OIHW’，out_layout =’’，out_dtype =’’ ）
使用winograd算法进行2D卷积。
基本参数与vanilla conv2d中的基本参数相同。假设权重已由nn.contrib_conv2d_winograd_weight_transform预先转换
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 重量（tvm.relay.Expr）–重量表达式。
  
• tile_size（int）– winograd的Tile大小。例如，对于F（2x2，3x3）为2，对于F（4x4，3x3）为4
  
• 步幅（int元组，可选）–卷积的步幅。
  
• padding（int的元组，可选）–卷积之前在输入两侧的卷积填充。
  
• dilation（int的元组，可选）–指定用于扩张卷积的扩张率。
  
• groups（int，可选）–分组卷积的组数。
  
• 通道（int，可选）–此卷积的输出通道数。
  
• kernel_size（int的元组，可选）–卷积内核的空间。
  
• data_layout（str，optional）–输入的布局。
  
• kernel_layout（str，optional）–权重的布局。
  
• out_layout（str，可选）–输出的布局，默认情况下，out_layout与data_layout相同
  
• out_dtype（str，可选）–指定混合精度conv2d的输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.contrib_conv2d_winograd_weight_transform（weight，tile_size ）
使用winograd算法进行2D卷积的权重变换部分。
我们将其作为一个单独的操作进行分离，以启用推理的预计算。与nn.contrib_conv2d_winograd_without_weight_transform一起使用
参量

• 重量（tvm.relay.Expr）–重量表达式。
  
• tile_size（int）– winograd的Tile大小。例如，对于F（2x2，3x3）为2，对于F（4x4，3x3）为4
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr

3级定义

tvm.relay.nn.leaky_relu（数据，alpha ）
该算子将数据作为输入，并执行泄漏线性整流器版本。
‘y=x>0?x:alpha∗x‘
‘y=x>0?x:alpha∗x‘
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• alpha（float）–负半轴的斜率系数。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.nn.prelu（data，alpha，axis = 1 ）
该算子将数据作为输入，并执行泄漏线性整流器版本。
‘y=x>0?x:alpha∗x‘
‘y=x>0?x:alpha∗x‘
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• alpha（tvm.relay.Expr）–负半轴的斜率系数。
  
• axis（int，可选）–指定要指定通道的形状轴。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.reshape（数据，newshape ）
调整输入数组的形状。
例：
为了在不进行手动形状推断的情况下为用户提供更多便利，形状的某些尺寸可以采用{0，-1，-2，-3，-4}中的特殊值。每种的含义如下：

• **0** 将此尺寸从输入复制到输出形状。
  

例：
- data.shape = (2,3,4), newshape = (4,0,2), result.shape = (4,3,2)
- data.shape = (2,3,4), newshape = (2,0,0), result.shape = (2,3,4)

• **-1** 通过使用其余输入尺寸来推断输出形状的尺寸
  

保持新数组的大小与输入数组的大小相同。形状的最大一维可以是-1。
例：
- data.shape = (2,3,4), newshape = (6,1,-1), result.shape = (6,1,4)
- data.shape = (2,3,4), newshape = (3,-1,8), result.shape = (3,1,8)
- data.shape = (2,3,4), newshape = (-1,), result.shape = (24,)

• **-2** 将所有/其余输入尺寸复制到输出形状。
  

例：
- data.shape = (2,3,4), newshape = (-2,), result.shape = (2,3,4)
- data.shape = (2,3,4), newshape = (2,-2), result.shape = (2,3,4)
- data.shape = (2,3,4), newshape = (-2,1,1), result.shape = (2,3,4,1,1)

• **-3** 使用输入形状的两个连续尺寸的乘积
  

作为输出尺寸。
例：
- data.shape = (2,3,4), newshape = (-3,4), result.shape = (6,4)
- data.shape = (2,3,4,5), newshape = (-3,-3), result.shape = (6,20)
- data.shape = (2,3,4), newshape = (0,-3), result.shape = (2,12)
- data.shape = (2,3,4), newshape = (-3,-2), result.shape = (6,4)

• **-4** 将输入的一维拆分为随后传递的二维
  

到-4的形状（可以包含-1）。
例：
- data.shape = (2,3,4), newshape = (-4,1,2,-2), result.shape = (1,2,3,4)
- data.shape = (2,3,4), newshape = (2,-4,-1,3,-2), result.shape = (2,1,3,4)
参量

• data（relay.Expr）–算子的输入数据。
  
• newshape（Union [ int，Tuple [ int ] ，List [ int ] ]__）–新形状。应与原始形状兼容。
  

退货
结果 –重塑的结果。
返回类型
relay.expr
tvm.relay.reshape_like（data，shape_like ）
通过另一个数组的大小来调整输入数组的形状。对于具有shape的输入数组，reshape_like操作会将输入数组重整形为具有与第二个输入数组相同形状的输出数组。(d1, d2, …, dk)
注意
两个数组的大小应兼容。
参量

• data（relay.Expr）–算子的输入数据。
  
• shape_like（int的元组）–新形状。应与原始形状兼容。
  

退货
ret –计算结果。
返回类型
relay.expr
tvm.relay.copy（数据）
复制张量。
参量
数据（relay.Expr）–要复制的张量。
退货
结果 –复制的结果。
返回类型
relay.expr
tvm.relay.transpose（data，axes = None ）
排列数组的尺寸。
参量

• data（relay.Expr）–算子的输入数据。
  
• 轴（无或列表[ int ]__）–目标轴顺序，如果未指定，则相反。
  

退货
结果 –转置结果。
返回类型
relay.expr
tvm.relay.squeeze（data，axis = None ）
挤压阵列中的轴。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 轴（无或列表[ int ]__）–要删除的轴集。如果axis = None，则删除所有尺寸为1的轴。如果任何指定的轴的尺寸不等于1，则为错误。
  

退货
结果 –压缩的结果。
返回类型
tvm.relay.Expr
tvm.relay.floor（数据）
计算元素逐层的数据。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.ceil（数据）
计算按元素的数据上限。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.sign（数据）
计算元素的元素绝对值。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.trunc（数据）
计算数据的逐元素截断。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.clip（a，a_min，a_max ）
剪辑中的元素一个之间a_min和a_max。 a_min和a_max被转换为一的D型。
参量

• a（relay.Expr）–输入张量。
  
• a_min（float）–最小片段。
  
• a_max（float）–片段最大值。
  

退货
结果 – a，其中元素夹在amin和a_max之间。
返回类型
relay.expr
例子
tvm.relay.round（数据）
计算逐元素的数据回合。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.abs（数据）
计算元素的元素绝对值。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.negative（数据）
计算元素的元素负数。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.take（data，index，axis = None，mode =’clip’ ） [源代码_）
沿轴从数组中获取元素。
参量

• data（relay.Expr）–源数组。
  
• 指数（rely.Expr） -的值，以提取物的索引。
  
• axis（int，可选）–要在其上选择值的轴。默认情况下，使用扁平化的输入数组。
  
• 模式（str，可选）–指定越界索引的行为[clip，wrap，fast]。剪辑：剪辑到范围（默认）。wrap：环绕索引。快速：无片段或环绕（用户必须确保索引是入站的）。
  

退货
ret –计算结果。
返回类型
relay.expr
tvm.relay.zeros（shape，dtype ）
用零填充数组。
参量

• shape（int的元组）–目标的形状。
  
• dtype（数据类型）–目标的数据类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.zeros_like（数据）
返回零数组，其类型和形状与输入相同。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.ones（shape，dtype ）
用1填充数组。
参量

• shape（int的元组）–目标的形状。
  
• dtype（数据类型）–目标的数据类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.ones_like（数据）
返回一个由1组成的数组，其类型和形状与输入相同。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.gather_nd（数据，索引）
从数据中收集元素或切片，并将其存储到张量，张量的形状由索引定义。
参量

• data（relay.Expr）–算子的输入数据。
  
• 指数（relay.Expr） -输出张量的形状。
  

退货
ret –计算结果。
返回类型
relay.expr
例子
data = [[0, 1], [2, 3]]
indices = [[1, 1, 0], [0, 1, 0]]
relay.gather_nd(data, indices) = [2, 3, 0]

data = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
indices = [[0, 1], [1, 0]]
relay.gathernd(data, indices) = [[3, 4], [5, 6]]
tvm.relay.full（fill_value，shape =（），dtype =’’_ ）
用标量值填充数组。
参量

• fill_value（relay.Expr）–要填充的值。必须是标量。
  
• shape（int的元组）–目标的形状。
  
• dtype（数据类型，可选（默认为填充值的数据类型））–目标的数据类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.full_like（data，fill_value ）
返回形状和类型与输入数组相同的标量值数组。
参量

• data（relay.Expr）–输入张量。
  
• fill_value（relay.Expr）–要填充的标量值。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.cast（data，dtype ）
将输入张量转换为数据类型。
参量

• data（relay.Expr）–算子的输入数据。
  
• dtype（str）–目标数据类型
  

退货
结果 –强制结果。
返回类型
relay.expr
tvm.relay.reinterpret（data，dtype ）
将输入张量重新解释为数据类型。
参量

• data（relay.Expr）–算子的输入数据。
  
• dtype（str）–目标数据类型
  

退货
结果 –重新解释的结果。
返回类型
relay.expr
tvm.relay.split(data, indices_or_sections, axis=0)
Split input tensor along axis by sections or indices.
If indices_or_sections is an integer, the input will be divided equally along given axis. If such a split is not possible, an error is raised.
If indices_or_sections is a tuple of sorted integers, the entries indicate where along axis the array is split.
Parameters

• data (relay.Expr) – The source array.
  
• indices_or_sections (int or tuple of int) – Indices or sections to split into. Accepts an int or a tuple
  
• axis (int, optional) – The axis over which to split.
  

Returns
ret –计算结果。
返回类型
relay.Tuple（[relay.Expr，relay.Expr]）
tvm.relay.arange（start，stop = None，step = None，dtype =’float32’ ）
返回给定间隔内的均匀间隔的值。
注意
与相似**numpy.arange**，当仅给出一个参数时，它用作stop而不是start，而start的默认值为0。
警告：dtype与开始/停止/步骤不兼容时，行为不确定。与numpy，MXNet，pytorch等相比，它可能导致不同的结果。
参量

• start（tvm.Expr ，可选__）–间隔的开始。间隔包括该值。默认起始值为0。
  
• stop（tvm.Expr）–间隔停止。间隔不包括此值。
  
• step（tvm.Expr ，可选__）–值之间的间距。默认步长为1。
  
• dtype（str，可选）–目标数据类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
例子
relay.arange(5) = [0, 1, 2, 3, 4]
relay.arange(1, 5) = [1, 2, 3, 4]
relay.arange(1, 5, 1.5) = [1, 2.5, 4]
tvm.relay.stack（数据，轴）
沿新轴连接一系列数组。
参量

• data（Union （List （列表[ relay.Expr ] ，Tuple（relay.Expr ））__））–张量列表。
  
• axis（int）–结果数组中输入数组沿其堆叠的轴。
  

退货
ret –堆叠的张量。
返回类型
relay.expr
tvm.relay.repeat（数据，重复，轴）
重复数组的元素。默认情况下，重复将输入数组展平为一维，然后重复元素。
重复int
每个元素的重复次数。
轴：整数
重复值所沿的轴。负数从倒数开始进行解释。默认情况下，使用展平的输入数组，并返回展平的输出数组。
退货
ret –计算结果。
返回类型
relay.expr
例子
x = [[1, 2], [3, 4]]
relay.repeat(x, repeats=2) = [1., 1., 2., 2., 3., 3., 4., 4.]

relay.repeat(x, repeats=2, axis=1) = [[1., 1., 2., 2.],
[3., 3., 4., 4.]]
tvm.relay.tile（数据，代表）
重复整个数组多次。
参量

• data（relay.Expr）–算子的输入数据。
  
• reps（int元组）–重复张量数据的次数。
  
• 注意：:（。）–代表的每个暗淡大小必须为正整数。如果代表的长度为d，则结果的尺寸为max（d，data.ndim）; 如果data.ndim = d，则通过在其前面加上1来将代表提升为a.ndim。
  

退货
ret –计算结果。
返回类型
relay.expr
例子
x = [[1, 2], [3, 4]]
relay.tile(x, reps=(2,3)) = [[1., 2., 1., 2., 1., 2.],
[3., 4., 3., 4., 3., 4.],
[1., 2., 1., 2., 1., 2.],
[3., 4., 3., 4., 3., 4.]]

relay.tile(x, reps=(2,)) = [[1., 2., 1., 2.],
[3., 4., 3., 4.]]
tvm.relay.reverse（数据，轴）
在保留数组形状的同时，反转元素沿给定轴的顺序。默认情况下，重复将输入数组展平为一维，然后重复元素。
参量

• data（relay.Expr）–算子的输入数据。
  
• axis（int）–反转元素的轴。
  

退货
ret –计算结果。
返回类型
relay.expr
例子
x = [[1., 2.], [3., 4.]]
relay.reverse(x, axis=0) = [[3., 4.], [1., 2.]]

relay.reverse(x, axis=1) = [[2., 1.], [4., 3.]]

4级定义

tvm.relay.right_shift（lhs，rhs ）
右移和numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.left_shift（lhs，rhs ）
左移和numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.equal（lhs，rhs ）
（lhs == rhs）的广播元素测试。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.not_equal（lhs，rhs ）
（lhs！= rhs）的广播元素测试。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.greater（lhs，rhs ）
广播元素测试（lhs> rhs）。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.greater_equal（lhs，rhs ）
广播元素测试（lhs> = rhs）。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.less（lhs，rhs ）
广播元素测试（lhs 参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.less_equal（lhs，rhs ）
广播元素测试（lhs <= rhs）。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.all（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上布尔数组元素的逻辑与。
参量

• data（relay.Expr）–输入的布尔张量
  
• 轴（无或INT或INT的元组） -轴或轴沿着该总和被执行。默认值axis = None将对输入数组的所有元素求和。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
例子
数据= relay.Constant（tvm.nd.array（[[[True，True，True]，

[正确，正确，正确]，[错误，正确，错误]]，

[[正确，错误，错误]，
[True，True，False]，[False，True，True]]]））
relay.all（数据，轴= 1）＃[[False，True，False]，＃[False，False，False]]
relay.all（data，axis = 0）＃[[True，False，False]，＃[True，True，False]，＃[False，True，False]]
tvm.relay.any（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上布尔数组元素的逻辑或。
参量

• data（relay.Expr）–输入的布尔张量
  
• 轴（无或INT或INT的元组） -轴或轴沿着该总和被执行。默认值axis = None将对输入数组的所有元素求和。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
例子
数据= relay.Constant（tvm.nd.array（[[[True，True，True]，

[正确，正确，正确]，[错误，正确，错误]]，

[[正确，错误，错误]，
[True，True，False]，[False，True，True]]]））
relay.any（数据，轴= 1）＃[[True，True，True]，＃[True，True，True]]
relay.any（data，axis = 0）＃[[True，True，True]，＃[True，True，True]，＃[False，True，True]]
tvm.relay.logical_and（lhs，rhs ）
与numpy风格的广播进行逻辑与。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.logical_or（lhs，rhs ）
与numpy样式的广播进行逻辑或。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.logical_not（数据）
计算元素逻辑非数据。
参量
data（relay.Expr）–输入数据
退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.maximum（lhs，rhs ）
numpy风格的广播最大。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.minimum（lhs，rhs ）
最少用于numpy风格的广播。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.power（lhs，rhs ）
numpy风格广播的强大功能。
参量

• lhs（relay.Expr）–左侧输入数据
  
• rhs（relay.Expr）–右侧输入数据
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.where（condition，x，y ）
根据条件的值从x或y中选择元素。
注意
条件x和y的形状必须相同。
参量

• condition（relay.Expr）–条件数组。当条件数组中的第n个值为零时，选择y中的第n个元素。否则，将选择x中的相应元素。
  
• x（relay.Expr）–第一个要选择的数组。
  
• y（relay.Expr）–要选择的第二个数组。
  

退货
结果 –选定的数组。
返回类型
relay.expr
例子
x = [[1, 2], [3, 4]]
y = [[5, 6], [7, 8]]
condition = [[0, 1], [-1, 0]]
relay.where(conditon, x, y) = [[5, 2], [3, 8]]

condition = [1, 0]
relay.where(conditon, x, y) = [[1, 2], [7, 8]]
tvm.relay.argmax（data，axis = None，keepdims = False，exclude = False ）
返回沿轴的最大值的索引。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其中执行argmax操作。默认值axis = None将查找输入数组中元素的最大元素的索引。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.argmin（data，axis = None，keepdims = False，exclude = False ）
返回沿轴的最小值的索引。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其中执行argmin操作。默认值axis = None将找到输入数组中所有元素的最小元素的索引。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.sum（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上的数组元素之和。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿着该总和被执行。默认值axis = None将对输入数组的所有元素求和。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.max（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上的数组元素的最大值。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其上执行最大运算。默认值axis = None将从输入数组的所有元素中找到max元素。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.min（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上的数组元素的最小值。
参量

• data（relay.Expr）–输入数据
  
• axis (None or int or tuple of int) – Axis or axes along which a minimum operation is performed. The default, axis=None, will find the minimum element from all of the elements of the input array. If axis is negative it counts from the last to the first axis.
  
• keepdims (bool) – If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array.
  
• exclude (bool) – If exclude is true, reduction will be performed on the axes that are NOT in axis instead.
  

Returns
result – The computed result.
Return type
relay.Expr
tvm.relay.mean（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数组元素的平均值。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其上执行平均操作。默认值axis = None将计算输入数组中所有元素的平均值。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.variance（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数据的方差。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其中执行方差操作。默认值axis = None将计算输入数组中所有元素的方差。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.std（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数据的标准偏差。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其上执行的标准偏差的操作。默认值axis = None将计算输入数组中所有元素的标准偏差。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.mean_variance（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数据的均值和方差。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其上执行一个的均值和方差的操作。默认值axis = None将计算输入数组中所有元素的均值和方差。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.mean_std（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数据的平均值和标准偏差。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿其中执行平均值和标准偏差的操作。默认值axis = None将计算输入数组中所有元素的均值和标准差。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.prod（data，axis = None，keepdims = False，exclude = False ）
计算给定轴上数组元素的乘积。
参量

• data（relay.Expr）–输入数据
  
• 轴（无或INT或INT的元组） -轴或轴沿着该产品被执行。默认值axis = None将找到输入数组中所有元素的最小元素的索引。如果轴为负，则从最后一个轴开始计数。
  
• keepdims（bool）–如果将其设置为True，则缩小的轴将保留为尺寸为1的尺寸。使用此选项，结果将针对输入数组正确广播。
  
• exclude（bool）–如果exclude为true，则将在不在轴中的轴上执行缩小。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.strided_slice（data，begin，end，strides = None ）
数组的交叉切片。
参量

• data（relay.Expr）–要切片的源数组。
  
• begin（int的列表）–在切片中开始的索引。
  
• end（int列表）–指示切片结束的索引。
  
• 步幅（int列表，可选）–指定步幅值，在这种情况下可以为负，输入张量将在该特定轴上反转。
  

退货
ret –计算结果。
返回类型
relay.expr
tvm.relay.broadcast_to（数据，形状）
返回具有相同类型的标量值数组，并广播到提供的形状。
参量

• data（relay.Expr）–输入张量。
  
• 形状（shape）–提供要广播的形状。
  

退货
结果 –结果张量。
返回类型
relay.expr

5级定义

tvm.relay.image.resize（data，size，layout =’NCHW’，method =’bilinear’，ordinate_transformation_mode =’half_pixel’，out_dtype = None ）
图像调整大小算子。
该算子将数据作为输入，并按2D比例缩放到给定的比例因子。在默认情况下，data_layout为NCHW 且形状为（n，c，h，w）的数据将具有形状（n，c，size [0]，size [1]）
method表示在计算out值时要使用的算法，并且method可以是（“ bilinear”，“ nearest_neighbor”，“ bicubic”）之一
参量

• data（relay.Expr）–算子的输入数据。
  
• size（Expr的Tuple）–图像将被调整为的out大小。
  
• layout（str，optional）–输入的布局。
  
• method（str，optional）–使用的缩放方法[nearest_neighbor，双线性，双三次]。
  
• ordinate_transformation_mode（字符串，可选）–描述如何将调整后的张量中的坐标转换为原始张量中的坐标。有关详细信息，请参阅ONNX Resize算子规范。[half_pixel，align_corners，不对称]
  
• out_dtype（str，可选）–要返回的类型。如果保留为空，则返回与输入相同的类型。
  

退货
结果 –调整大小的结果。
返回类型
relay.expr
tvm.relay.image.crop_and_resize（数据，盒子，box_indices，crop_size，布局，method =’bilinear’，extrapolation_value = 0，out_dtype = None ）
裁剪输入图像并调整其大小。
method表示计算出值时要使用的算法，方法可以是“双线性”或“ nearest_neighbor”。
参量

• data（relay.Expr）–算子的输入数据。
  
• box（relay.Expr）–形状为[num_boxes，4]的二维张量。张量的每一行都指定一个框的坐标。
  
• box_indices（relay.Expr）–形状为[num_boxes]的一维张量，box_ind [i]指定第i个Box引用的数据。
  
• crop_size（Expr的Tuple）–每个框将调整为的目标大小。
  
• layout（str，optional）–输入的布局。
  
• method（str，optional）–缩放方法，可以是“ nearest_neighbor”或“ bilinear”。
  
• extrapolation_value（float，optional）–适用时用于外推的值。
  
• out_dtype（str，可选）–要返回的类型。如果保留为空，则返回与输入相同的类型。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.vision.multibox_prior（数据，大小=（1.0，），比率=（1.0，），步骤=（ - 1.0，-1.0） ，偏移=（0.5，0.5） ，夹= FALSE ）
根据数据，大小和比率生成先验（锚定）框。
参量

• data（relay.Expr）–输入数据张量。
  
• 大小（float的元组，可选）–锚定框的大小的元组。
  
• 比率（float的元组，可选）–锚框比率的元组。
  
• 步数（float的元组，可选）– y和x，-1的Priorbox步数，用于自动计算。
  
• 偏移量（int的元组，可选）–先验盒中心偏移量y和x。
  
• clip（boolean ，可选__）–是否裁剪边界框。
  

退货
out –形状为[1，hin w_in （num_sizes + num_ratios-1），4]的3D张量
返回类型
relay.expr
tvm.relay.vision.multibox_transform_loc（cls_prob，loc_pred，锚，夹=真，阈值= 0.01，方差=（0.1，0.1，0.2，0.2）_ ）
用于多盒检测的位置转换
参量

• cls_prob（tvm.relay.Expr）–类概率。
  
• loc_pred（tvm.relay.Expr）–位置回归预测。
  
• 锚（tvm.relay.Expr）–先前的锚框。
  
• clip（boolean ，可选__）–是否裁剪边界框。
  
• 阈值（双精度，可选）–阈值是一个正预测。
  
• 方差（float的Tuple ，可选__）–要从框回归输出中解码的方差。
  

退货
退回
返回类型
tvm.relay.Expr的元组
tvm.relay.vision.nms（）
非最大抑制操作。
tvm.relay.vision.yolo_reorg（数据，步幅）
Darknet模型中使用的Yolo reorg操作。该层根据步幅值对输入张量值进行混洗。与混洗一起进行形状变换。如果’（n，c，h，w）’是数据形状而’s’是步幅，则输出形状为’（n，c s s，h / s，w / s）’示例：data（1 ，4，2，2）= [[[[0 1] [2 3]]

[[4 5] [6 7]] [[8 9] [10 11]] [[12 13] [14 15]]]] 步幅= 2 ret（1，16，1，1）= [[[[0]] [[2]] [[8]] [[10]] [[1]] [[3]] [[9]] [[11]] [[4]] [[6]] [[12]] [[14]] [[5]] [[7]] [[13]] [[15]]]

注意：stride = 1对重组操作没有任何意义。
参量

• data（relay.Expr）–输入数据张量。
  
• 跨度（int）–重组的跨度值。
  

退货
ret –计算结果。
返回类型
relay.expr

6级定义

tvm.relay.argsort（data，axis = -1，is_ascend = 1，dtype =’int32’ ）
沿给定的轴执行排序，并返回一个索引数组，该索引数组的形状与按排序顺序对数据进行索引的输入数组相同。
参量

• data（relay.Expr）–输入数据张量。
  
• valid_count（tvm.Tensor）–要排序的有效元素的数量。
  
• axis（int，optional）–排序输入张量的轴长。
  
• is_ascend（boolean ，optional__）–是按升序还是降序排序。
  
• dtype（字符串，可选）–输出索引的数据类型。
  

退货
out –与数据形状相同的张量。
返回类型
relay.expr
tvm.relay.topk（数据，k = 1，轴= -1，ret_type =’both’，is_ascend = False，dtype =’int32’ ）
沿给定轴获取输入张量中的前k个元素。
ret_type指定返回类型，可以是（“ both”，“ values”，“ indices”）之一。
参量

• data（relay.Expr）–输入数据张量。
  
• k（int，可选）–要选择的顶部元素数。如果k <1，则返回所有元素。
  
• axis（int，optional）–排序输入张量的轴长。
  
• ret_type（str，可选）–返回类型[值，索引]。“ both”：同时返回前k个数据和索引。“值”：仅返回前k个数据。“索引”：仅返回前k个索引。
  
• is_ascend（boolean ，optional__）–是按升序还是降序排序。
  
• dtype（字符串，可选）–索引输出的数据类型。
  

退货
out –计算结果。
返回类型
relay.Expr或List [relay.Expr]

10级定义

tvm.relay.broadcast_to_like（data，broadcast_type ）
返回形状和类型与输入数组相同的标量值数组。
参量

• data（relay.Expr）–输入张量。
  
• broadcast_type（relay.Expr）–提供要广播的类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.collapse_sum_like（data，crash_type ）
返回形状和类型与输入数组相同的标量值数组。
参量

• data（relay.Expr）–输入张量。
  
• collapse_type（relay.Expr） -提供折叠的类型。
  

退货
结果 –结果张量。
返回类型
relay.expr
tvm.relay.slice_like（data，shape_like，axes = None ）
相对于第二输入，对第一输入进行切片。
对于具有shape的输入数组，slice_like操作将与第二数组对应的大小切入输入数组。默认情况下将在所有轴上切片。(d1, d2, …, dk)
参量

• data（tvm.relay.Expr）–源数组。
  
• shape_like（tvm.relay.Expr）–新形状。
  
• axes（可选[ Tuple [ int ] ]__）–根据第二个输入的相应大小在其上切片输入数据的轴的列表。默认情况下将在所有轴上切片。负轴表示反向计数。
  

退货
结果 –计算结果。
返回类型
relay.expr
tvm.relay.shape_of（data，dtype =’int32’ ）
获取张量的形状。
参量

• data（tvm.relay.Expr）–输入张量。
  
• dtype（str，可选）–目标数据类型。
  

退货
结果 –形状张量。
返回类型
tvm.relay.Expr
tvm.relay.contrib.ndarray_size（data，dtype =’int32’ ）
获取输入张量的元素数量。
参量

• data（tvm.relay.Expr）–输入张量。
  
• dtype（str，可选）–目标数据类型。
  

退货
结果 –输入张量的元素数量。
返回类型
tvm.relay.Expr
tvm.relay.layout_transform（data，src_layout，dst_layout ）
变换张量的布局
参量

• data（relay.Expr）–要转换的源张量
  
• src_layout（str）–源布局。（例如NCHW）
  
• dst_layout（str）–目标布局。（例如NCHW16c）
  

退货
ret –变换后的张量。
返回类型
relay.expr
tvm.relay.device_copy（data，src_dev，dst_dev ）
将数据从源设备复制到目标设备。该算子有助于在不同上下文之间进行数据传输以实现异构执行。
参量

• 数据（tvm.relay.Expr）–要复制的张量。
  
• src_dev（Union [ **TVMContext**，str]）–复制数据的源设备。
  
• dst_dev（Union [ **TVMContext**，str]）–将数据复制到的目标设备。
  

退货
结果 –复制的结果。
返回类型
tvm.relay.Expr
tvm.relay.annotation.on_device（数据，设备）
用某种设备类型注释表达式。
参量

• data（tvm.relay.Expr）–要注释的表达式。
  
• device（Union [ **TVMContext**，str]）–要注释的设备类型。
  

退货
结果 –带注释的表达式。
返回类型
tvm.relay.Expr
tvm.relay.reverse_reshape（数据，newshape ）
重塑输入数组的形状，从右向左推断特殊值。
例：
特殊值的语义与相同[tvm.relay.reshape](https://docs.tvm.ai/langref/relay_op.html#tvm.relay.reshape)。不同之处在于，从右向左推断特殊值。可以在下面的示例中进行解释：
- data.shape = (10,5,4), newshape = (-1,0), reshape results in (40,5)
- data.shape = (10,5,4), newshape = (-1,0), reverse_reshape results in (40,5)
参量

• data（relay.Expr）–算子的输入数据。
  
• newshape（Union [ int，Tuple [ int ] ，List [ int ] ]__）–新形状。应与原始形状兼容。
  

退货
结果 –重塑的结果。
返回类型
relay.expr
tvm.relay.sequence_mask（data，valid_length，mask_value = 0，axis = 0 ）
将序列预期长度以外的所有元素设置为恒定值。
此函数采用[MAX_LENGTH，batch_size，…]或[batch_size，MAX_LENGTH，…]形式的n维输入数组，并返回相同形状的数组。
参量

• data（relay.Expr）–输入数据。
  
• valid_length（relay.Expr）–张量中每个序列的预期（有效）长度。
  
• mask_value（float）–掩码值。
  
• axis（int）–长度尺寸的轴。
  

退货
ret –计算结果。
返回类型
relay.expr
例子
x = [[[ 1., 2., 3.], [ 4., 5., 6.]],
[[ 7., 8., 9.], [ 10., 11., 12.]],
[[ 13., 14., 15.], [ 16., 17., 18.]]]

relay.sequence_mask(x, valid_length=[1, 1]) =
[[[ 1., 2., 3.], [ 4., 5., 6.]],
[[ 0., 0., 0.], [ 0., 0., 0.]],
[[ 0., 0., 0.], [ 0., 0., 0.]]]

relay.sequencemask(x, valid_length=[2, 3], mask_value=0.1) =
[[[ 1., 2., 3.], [ 4., 5., 6.]],
[[ 7., 8., 9.], [ 10., 11., 12.]],
[[ 0.1, 0.1, 0.1], [ 16., 17., 18.]]]
tvm.relay.nn.batch_matmul（x，y_ ）
当x和y是批处理数据时，计算x和y的批处理矩阵乘法。
batch_matmul(x,y)[i,:,:]=matmul(x[i,:,:],y[i,:,:]T)
batch_matmul(x,y)[i,:,:]=matmul(x[i,:,:],y[i,:,:]T)
参量

• x（tvm.relay.Expr）–第一个输入。
  
• y（tvm.relay.Expr）–第二个输入。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.contrib.adaptive_max_pool2d（data，output_size = None，layout =’NCHW’ ）
2D自适应最大池化算子。该算子是实验性的。
该算子将数据作为输入，并跨WxH表示的每个窗口进行2D最大值计算。
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据张量，以生成形状为（batch_size，in_channels，output_height，output_width）的输出张量。
自动为所需的输出大小选择池内核和步幅大小。
对于output_size：
如果未提供此参数，则将输入高度和宽度用作输出高度和宽度。
如果为output_size提供单个整数，则任何输入（NCHW）的输出大小为（N x C x output_size x output_size）。
如果为output_size提供了整数（高度，宽度）元组，则任何输入（NCHW）的输出大小为（N x C x高度x宽度）。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• output_size（整数元组，可选）-输出高度和宽度。
  
• layout（str，optional）–输入的布局。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.contrib.adaptive_avg_pool2d（data，output_size = None，layout =’NCHW’ ）
2D自适应平均池算子。该算子是实验性的。
该算子将数据作为输入，并跨WxH表示的每个窗口进行2D平均值计算。
在默认情况下，data_layout为NCHW时 ，形状为（batch_size，in_channels，height，width）的数据张量，以生成形状为（batch_size，in_channels，output_height，output_width）的输出张量。
自动为所需的输出大小选择池内核和步幅大小。
对于output_size：
如果未提供此参数，则将输入高度和宽度用作输出高度和宽度。
如果为output_size提供单个整数，则任何输入（NCHW）的输出大小为（N x C x output_size x output_size）。
如果为output_size提供了整数（高度，宽度）元组，则任何输入（NCHW）的输出大小为（N x C x高度x宽度）。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• output_size（整数元组，可选）-输出高度和宽度。
  
• layout（str，optional）–输入的布局。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.one_hot（索引，on_value，off_value，depth，axis，dtype ）
返回一个单张量张量，其中索引代表的位置取值on_value，其他位置取值off_value。最终尺寸为<指标外部尺寸> x深度x <指标内部尺寸>。
参量

• 指数（relay.Expr） -位置设置为on_value。
  
• on_value（relay.Expr）–填充索引的值。
  
• off_value（relay.Expr）–在索引以外的所有其他位置填充的值。
  
• depth（int）-一维尺寸的深度。
  
• axis（int）–要填充的轴。
  
• dtype（str）–输出张量的数据类型。
  

退货
ret –一热张量。
返回类型
relay.expr
例子
indices = [0, 1, 2]

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

11级定义

tvm.relay.qnn.op.requantize（data，input_scale，input_zero_point，output_scale，output_zero_point，axis = -1，取整=’ UPWARD ‘，out_dtype =’int8’ ）
重新量化的算子。
重新量化算子将一个量化的张量表示转换为另一量化的张量表示。对于输出张量，我们提供了输出比例和零点。计算如下
Q_output = zp_output +（scale_input）/（scale_output）（Q_input-zp_input）
*参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• input_scale（tvm.relay.Expr）–输入张量的量化比例。
  
• input_zero_point（tvm.relay.Expr）–输入张量的零点。
  
• output_scale（tvm.relay.Expr）–输出张量的量化比例。
  
• output_zero_point（tvm.relay.Expr）–输出张量的零点。
  
• axis（int）–量化的通道轴。默认值为-1，它对应于最后一个轴。
  
• 舍入（字符串，可选）–定义值在两个可表示值之间的中间值时的舍入方向。
  
• out_dtype（str，可选）–指定输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr
tvm.relay.qnn.op.conv2d（数据，内核，input_zero_point，kernel_zero_point，input_scale，kernel_scale，步幅=（1，1） ，填充=（0，0） ，扩张=（1，1） ，基团= 1，通道=无，kernel_size =无，data_layout =’NCHW’，kernel_layout =’OIHW’，out_layout =’’，out_dtype =’int32’ ）
量化的2D卷积
该算子将量化数据与量化内核进行卷积。输出量化张量的标度是输入量化张量的kernel_scale和input_scale的乘积。输出量化张量的零点为0。默认情况下，输出的dtype为int32。另请参阅重新量化算子，以了解如何将int32输出缩减为（u）int8。
参量

• data（tvm.relay.Expr）–算子的输入数据。
  
• 内核（tvm.relay.Expr）–内核表达式。
  
• input_zero_point（tvm.relay.Expr）–数据分发的零点。
  
• kernel_zero_point（tvm.relay.Expr）–量化内核分布的零点。
  
• input_scale（tvm.relay.Expr）–输入张量的比例。输入张量的比例尺纯粹是为了方便在这里存储。请参阅下面的更多评论。
  
• kernel_scale（tvm.relay.Expr）–权重张量的比例。存储重量张量的标度，以便在relay期间访问它。将qnn.conv2d降低到nn.conv2d中的步骤序列后，在传递管道中不需要此信息。另请参阅“重新量化”中的input_scale。
  
• 步幅（int元组，可选）–卷积的步幅。
  
• padding（int的元组，可选）–卷积之前在输入两侧的卷积填充。
  
• dilation（int的元组，可选）–指定用于扩张卷积的扩张率。
  
• groups（int，可选）–分组卷积的组数。
  
• 通道（int，可选）–此卷积的输出通道数。
  
• kernel_size（int的元组，可选）–卷积内核的空间。
  
• data_layout（str，optional）–输入的布局。
  
• kernel_layout（str，optional）–内核的布局。
  
• out_layout（str，可选）–输出的布局，默认情况下，out_layout与data_layout相同
  
• out_dtype（str，可选）–指定混合精度conv2d的输出数据类型。
  

退货
结果 –计算结果。
返回类型
tvm.relay.Expr