onnx-mlir | ONNX 模型在 MLIR 编译器基础设施中的表示和参考级降低

`onnx.Abs` (ONNXAbsOp)

ONNX Abs 操作

Absolute 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中对张量逐元素应用绝对值，即 y = abs(x)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Acos` (ONNXAcosOp)

ONNX Acos 操作

计算给定输入张量的反余弦 (余弦的逆运算)，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Acosh` (ONNXAcoshOp)

ONNX Acosh 操作

计算给定输入张量的双曲反余弦，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Adagrad` (ONNXAdagradOp)

ONNX Adagrad 操作

计算 ADAGRAD（一种基于随机梯度的优化算法）的一次迭代。此操作符可以对多个张量变量进行优化。

Let's define the behavior of this operator. As you can imagine, ADAGRAD requires
some parameters:

 - The initial learning-rate \"R\".
 - The update count \"T\". That is, the number of training iterations conducted.
 - A L2-norm regularization coefficient \"norm_coefficient\".
 - A learning-rate decay factor \"decay_factor\".
 - A small constant \"epsilon\" to avoid dividing-by-zero.

At each ADAGRAD iteration, the optimized tensors are moved along a direction
computed based on their estimated gradient and accumulated squared gradient. Assume
that only a single tensor \"X\" is updated by this operator. We need the value of \"X\",
its gradient \"G\", and its accumulated squared gradient \"H\". Therefore, variables in
this operator's input list are sequentially \"R\", \"T\", \"X\", \"G\", and \"H\". Other
parameters are given as attributes because they are usually constants. Also, the
corresponding output tensors are the new value of \"X\" (called \"X_new\"), and then
the new accumulated squared gradient (called \"H_new\"). Those outputs are computed
from the given inputs following the pseudo code below.

Let \"+\", \"-\", \"*\", and \"/\" are all element-wise arithmetic operations with
numpy-style broadcasting support. The pseudo code to compute those outputs is:

  // Compute a scalar learning-rate factor. At the first update of X, T is generally
  // 0 (0-based update index) or 1 (1-based update index).
  r = R / (1 + T * decay_factor);

  // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
  G_regularized = norm_coefficient * X + G;

  // Compute new accumulated squared gradient.
  H_new = H + G_regularized * G_regularized;

  // Compute the adaptive part of per-coordinate learning rate. Note that Sqrt(...)
  // computes element-wise square-root.
  H_adaptive = Sqrt(H_new) + epsilon

  // Compute the new value of \"X\".
  X_new = X - r * G_regularized / H_adaptive;

If one assign this operators to optimize multiple inputs, for example, \"X_1\" and \"X_2\", the same
pseudo code may be extended to handle all tensors jointly. More specifically, we can view \"X\" as a
concatenation of \"X_1\" and \"X_2\" (of course, their gradient and accumulate gradient should
be concatenated too) and then just reuse the entire pseudo code.

Note that ADAGRAD was first proposed in http://jmlr.org/papers/volume12/duchi11a/duchi11a.pdf.
In that reference paper, this operator is a special case of the Figure 1's composite mirror
descent update.

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`decay_factor`	::mlir::FloatAttr	32位浮点属性
`epsilon`	::mlir::FloatAttr	32位浮点属性
`norm_coefficient`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`R`	32位浮点数值的张量或64位浮点数值的张量
`T`	64位整型值的张量
`输入`	可变数量的32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	可变数量的32位浮点数值的张量或64位浮点数值的张量

`onnx.Adam` (ONNXAdamOp)

ONNX Adam 操作

计算 Adam（一种基于随机梯度的优化算法）的一次迭代。此操作符可以对多个张量变量进行优化。

Let's define the behavior of this operator. First of all, Adam requires
some parameters:

 - The learning-rate \"R\".
 - The update count \"T\". That is, the number of training iterations conducted.
 - A L2-norm regularization coefficient \"norm_coefficient\".
 - A small constant \"epsilon\" to avoid dividing-by-zero.
 - Two coefficients, \"alpha\" and \"beta\".

At each Adam iteration, the optimized tensors are moved along a direction
computed based on their exponentially-averaged historical gradient and
exponentially-averaged historical squared gradient. Assume that only a tensor
\"X\" is being optimized. The rest of required information is

 - the value of \"X\",
 - \"X\"'s gradient (denoted by \"G\"),
 - \"X\"'s exponentially-averaged historical gradient (denoted by \"V\"), and
 - \"X\"'s exponentially-averaged historical squared gradient (denoted by \"H\").

Some of those parameters are passed into this operator as input tensors and others
are stored as this operator's attributes. Specifically, this operator's input tensor
list is [\"R\", \"T\", \"X\", \"G\", \"V\", \"H\"]. That is, \"R\" is the first input, \"T\" is
the second input, and so on. Other parameters are given as attributes because they
are constants. Moreover, the corresponding output tensors are

 - the new value of \"X\" (called \"X_new\"),
 - the new exponentially-averaged historical gradient (denoted by \"V_new\"), and
 - the new exponentially-averaged historical squared gradient (denoted by \"H_new\").

Those outputs are computed following the pseudo code below.

Let \"+\", \"-\", \"*\", and \"/\" are all element-wise arithmetic operations with
numpy-style broadcasting support. The pseudo code to compute those outputs is:

  // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
  G_regularized = norm_coefficient * X + G

  // Update exponentially-averaged historical gradient.
  V_new = alpha * V + (1 - alpha) * G_regularized

  // Update exponentially-averaged historical squared gradient.
  H_new = beta * H + (1 - beta) * G_regularized * G_regularized

  // Compute the element-wise square-root of H_new. V_new will be element-wisely
  // divided by H_sqrt for a better update direction.
  H_sqrt = Sqrt(H_new) + epsilon

  // Compute learning-rate. Note that \"alpha**T\"/\"beta**T\" is alpha's/beta's T-th power.
  R_adjusted = T > 0 ? R * Sqrt(1 - beta**T) / (1 - alpha**T) : R

  // Compute new value of \"X\".
  X_new = X - R_adjusted * V_new / H_sqrt

  // Post-update regularization.
  X_final = (1 - norm_coefficient_post) * X_new

If there are multiple inputs to be optimized, the pseudo code will be applied
independently to each of them.

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`beta`	::mlir::FloatAttr	32位浮点属性
`epsilon`	::mlir::FloatAttr	32位浮点属性
`norm_coefficient`	::mlir::FloatAttr	32位浮点属性
`norm_coefficient_post`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`R`	32位浮点数值的张量或64位浮点数值的张量
`T`	64位整型值的张量
`输入`	可变数量的32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	可变数量的32位浮点数值的张量或64位浮点数值的张量

`onnx.Add` (ONNXAddOp)

ONNX Add 操作

执行逐元素的二元加法 (支持 Numpy 风格的广播)。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

(Opset 14 变更): 扩展支持的类型，包含 uint8, int8, uint16 和 int16。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.And` (ONNXAndOp)

ONNX And 操作

对输入张量 A 和 B 逐元素执行 and 逻辑操作 (支持 Numpy 风格的广播) 后返回结果张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	1位整型值的张量
`B`	1位整型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.ArgMax` (ONNXArgMaxOp)

ONNX ArgMax 操作

计算输入张量沿给定轴的最大元素的索引。如果 keepdims 等于 1，结果张量具有与输入相同的秩。如果 keepdims 等于 0，则结果张量被裁剪掉缩减的维度。如果 select_last_index 为 True (默认为 False)，则当最大值在输入中出现多次时，选择最后一次出现的索引。否则选择第一次出现的索引。输出张量的类型为整型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`select_last_index`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	64位整型值的张量

`onnx.ArgMin` (ONNXArgMinOp)

ONNX ArgMin 操作

计算输入张量沿给定轴的最小元素的索引。如果 keepdims 等于 1，结果张量具有与输入相同的秩。如果 keepdims 等于 0，则结果张量被裁剪掉缩减的维度。如果 select_last_index 为 True (默认为 False)，则当最小值在输入中出现多次时，选择最后一次出现的索引。否则选择第一次出现的索引。输出张量的类型为整型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`select_last_index`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	64位整型值的张量

`onnx.ArrayFeatureExtractor` (ONNXArrayFeatureExtractorOp)

ONNX ArrayFeatureExtractor 操作

根据传入的索引选择输入张量的元素。
索引应用于张量的最后一个轴。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量或字符串类型值的张量
`Y`	64位整型值的张量

结果

结果	描述
`Z`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量或字符串类型值的张量

`onnx.Asin` (ONNXAsinOp)

ONNX Asin 操作

计算给定输入张量的反正弦 (正弦的逆运算)，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Asinh` (ONNXAsinhOp)

ONNX Asinh 操作

计算给定输入张量的双曲反正弦，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Atan` (ONNXAtanOp)

ONNX Atan 操作

计算给定输入张量的反正切 (正切的逆运算)，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Atanh` (ONNXAtanhOp)

ONNX Atanh 操作

计算给定输入张量的双曲反正切，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.AveragePool` (ONNXAveragePoolOp)

ONNX AveragePool 操作

AveragePool 接受输入张量 X，并根据核大小、步长大小和填充长度对张量应用平均池化。平均池化是指根据核大小计算输入张量子集所有值的平均值，并将数据下采样到输出张量 Y 中以进行进一步处理。输出空间形状的计算方式有所不同，取决于是否使用显式填充 (使用 pads) 或自动填充 (使用 auto_pad)。使用显式填充时 (https://pytorch.ac.cn/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d)

 output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

或

 output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

如果启用了 ceil_mode。pad_shape[i] 是沿轴 i 的填充总和。从右侧填充区域开始的滑动窗口将被忽略。

auto_pad 是一个已弃用的属性。如果您当前正在使用它们，当启用 ceil_mode 时，输出空间形状将如下所示

 VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
 SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])

或禁用 ceil_mode 时 (https://tensorflowcn.cn/api_docs/python/tf/keras/layers/AveragePooling2D)

 VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
 SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1

并且如果 SAME_UPPER 或 SAME_LOWER，填充形状将如下所示

 pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]

每个池化窗口的输出除以元素数量 (当属性 count_include_pad 为零时，不包括填充)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`ceil_mode`	::mlir::IntegerAttr	64位有符号整数属性
`count_include_pad`	::mlir::IntegerAttr	64位有符号整数属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.BatchNormalizationInferenceMode` (ONNXBatchNormalizationInferenceModeOp)

测试模式下的 ONNX BatchNormalization 操作

执行批量归一化，如论文 https://arxiv.org/abs/1502.03167 中所述。根据运行模式，输出数量有多种情况，列举如下

输出情况 #1: Y, mean, var, saved_mean, saved_var (训练模式) 输出情况 #2: Y (测试模式)”

对于以前 (已弃用) 的非空间情况，建议实现在 BatchNormalization Op 之前将输入形状展平为 (N x C*D1*D2 ..*Dn)。此操作符具有**可选**输入/输出。有关可选参数表示的更多详细信息，请参阅文档。可以使用空字符串代替实际参数名称来指示缺失的参数。末尾的可选参数 (后没有紧随存在参数的参数) 也可以简单省略。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`epsilon`	::mlir::FloatAttr	32位浮点属性
`momentum`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	任意类型值的 memref 或任意类型值的张量
`scale`	任意类型值的 memref 或任意类型值的张量
`B`	任意类型值的 memref 或任意类型值的张量
`mean`	任意类型值的 memref 或任意类型值的张量
`var`	任意类型值的 memref 或任意类型值的张量

结果

结果	描述
`o_Y`	任意类型值的 memref 或任意类型值的张量

`onnx.BatchNormalization` (ONNXBatchNormalizationOp)

ONNX BatchNormalization 操作

执行批量归一化，如论文 https://arxiv.org/abs/1502.03167 中所述。根据运行模式，有五个必需的输入 ‘X’、‘scale’、‘B’、‘input_mean’ 和 ‘input_var’。请注意，‘input_mean’ 和 ‘input_var’ 在推理模式下 (training_mode=False，默认) 预期为估计统计量，在训练模式下 (training_mode=True) 预期为运行统计量。输出数量有多种情况，列举如下

输出情况 #1: Y, running_mean, running_var (training_mode=True)
输出情况 #2: Y (training_mode=False)

当 training_mode=False 时，额外输出无效。当 training_mode=True 时，输出按如下方式更新

running_mean = input_mean * momentum + current_mean * (1 - momentum)
running_var = input_var * momentum + current_var * (1 - momentum)

Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B

其中

current_mean = ReduceMean(X, axis=all_except_channel_index)
current_var =  ReduceVar(X, axis=all_except_channel_index)

请注意，ReduceVar 指的是总体方差，它等于 sum(sqrd(x_i - x_avg)) / N，其中 N 是总体大小 (此公式不使用样本大小 N - 1)。

ReduceMean 和 ReduceVar 的计算使用浮点数，以避免 float16 输入溢出。

当 training_mode=False 时

Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B

对于以前 (已弃用) 的非空间情况，建议实现在 BatchNormalization Op 之前将输入形状展平为 (N x C * D1 * D2 * … * Dn)。此操作符具有**可选**输入/输出。有关可选参数表示的更多详细信息，请参阅文档。可以使用空字符串代替实际参数名称来指示缺失的参数。末尾的可选参数 (后没有紧随存在参数的参数) 也可以简单省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`epsilon`	::mlir::FloatAttr	32位浮点属性
`momentum`	::mlir::FloatAttr	32位浮点属性
`training_mode`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`scale`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`input_mean`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`input_var`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`running_mean`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型
`running_var`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

`onnx.Bernoulli` (ONNXBernoulliOp)

ONNX Bernoulli 操作

从伯努利分布中抽取二元随机数 (0 或 1)。输入张量应该包含用于抽取二元随机数的概率 p (范围 [0,1] 中的值)，其中以概率 p 生成输出 1，以概率 (1-p) 生成输出 0。

此操作符是非确定性的，在不同实现中可能不会产生相同的值 (即使指定了种子)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`seed`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或1位整型值的张量

`onnx.Binarizer` (ONNXBinarizerOp)

ONNX Binarizer 操作

根据与阈值的比较结果，逐元素将输入张量的值映射到 0 或 1。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`threshold`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

`onnx.BitShift` (ONNXBitShiftOp)

ONNX BitShift 操作

逐位移位操作符执行逐元素操作。对于每个输入元素，如果属性 "direction" 是 "RIGHT"，则此操作符将其二进制表示向右移动，从而有效减小输入值。如果属性 "direction" 是 "LEFT"，则二进制表示的位向左移动，从而增加其实际值。输入 X 是要移位的张量，另一个输入 Y 指定移位量。例如，如果 "direction" 是 "Right"，X 是 [1, 4]，S 是 [1, 1]，则对应的输出 Z 将是 [0, 2]。如果 "direction" 是 "LEFT"，X=[1, 2]，S=[1, 2]，则对应的输出 Y 将是 [2, 8]。

由于此操作符支持 Numpy 风格的广播，X 和 Y 的形状不一定相同。此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`direction`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量

结果

结果	描述
`Z`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量

`onnx.BitwiseAnd` (ONNXBitwiseAndOp)

ONNX BitwiseAnd 操作

对输入张量 A 和 B 逐元素执行逐位 and 操作 (支持 Numpy 风格的广播) 后返回结果张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

`onnx.BitwiseNot` (ONNXBitwiseNotOp)

ONNX BitwiseNot 操作

逐元素返回输入张量的逐位 not。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

`onnx.BitwiseOr` (ONNXBitwiseOrOp)

ONNX BitwiseOr 操作

对输入张量 A 和 B 逐元素执行逐位 or 操作 (支持 Numpy 风格的广播) 后返回结果张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

`onnx.BitwiseXor` (ONNXBitwiseXorOp)

ONNX BitwiseXor 操作

对输入张量 A 和 B 逐元素执行逐位 xor 操作 (支持 Numpy 风格的广播) 后返回结果张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量

`onnx.BlackmanWindow` (ONNXBlackmanWindowOp)

ONNX BlackmanWindow 操作

生成一个 Blackman 窗，如论文 https://ieeexplore.ieee.org/document/1455106 中所述。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`output_datatype`	::mlir::IntegerAttr	64位有符号整数属性
`periodic`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`size`	32位整型值的张量或64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.CastLike` (ONNXCastLikeOp)

ONNX CastLike 操作

此操作符将给定输入张量 (第一个输入) 的元素强制转换为与第二个输入张量的元素相同的数据类型。更多详情请参阅 Cast 操作符的文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`saturate`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

输入 16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或字符串类型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

target_type 16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或字符串类型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或字符串类型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

`onnx.CastMap` (ONNXCastMapOp)

ONNX CastMap 操作

将映射转换为张量。
映射键必须是 int64，并且值将根据此键按升序排序。
此操作符支持密集打包或稀疏打包。如果使用稀疏打包，键不能超过 max_map-1 的值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`cast_to`	::mlir::StringAttr	字符串属性
`map_form`	::mlir::StringAttr	字符串属性
`max_map`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	包含64位整型或字符串类型值任意组合的元组，或包含64位整型或字符串类型值任意组合的元组，或包含64位整型或32位浮点数值任意组合的元组，或包含64位整型或64位浮点数值任意组合的元组，或包含字符串类型或32位浮点数值任意组合的元组，或包含字符串类型或64位浮点数值任意组合的元组

结果

结果	描述
`Y`	字符串类型值的张量或32位浮点数值的张量或64位整型值的张量

`onnx.Cast` (ONNXCastOp)

ONNX Cast 操作

此操作符将给定输入张量的元素强制转换为由 ‘to’ 参数指定的数据类型，并返回转换类型下具有相同大小的输出张量。‘to’ 参数必须是 TensorProto 消息中 ‘DataType’ 枚举字段指定的某种数据类型。

支持将字符串张量从普通 (例如 "3.14" 和 "1000") 和科学计数法 (例如 "1e-5" 和 "1E8") 转换为浮点类型。例如，将字符串 "100.5" 转换为整数可能得到结果 100。有一些字符串字面量保留用于特殊的浮点值；"+INF" (和 "INF")、"-INF" 和 "NaN" 分别表示正无穷大、负无穷大和非数字。任何能够不区分大小写地精确匹配 "+INF" 的字符串都将被映射到正无穷大。类似地，此不区分大小写规则也适用于 "INF" 和 "NaN"。将数字张量转换为字符串张量时，将使用普通浮点表示 (例如 "314.15926")。转换非数字字面量字符串（例如 "Hello World!"）是未定义行为。将表示浮点数值（例如 "2.718"）的字符串转换为 INT 是未定义行为。

数值类型之间的转换始终允许。用户必须注意由于两种类型之间的范围差异而导致的精度损失和值改变。例如，64位浮点数 3.1415926459 可能四舍五入为 32位浮点数 3.141592。类似地，将整数 36 转换为布尔值可能产生 1，因为我们截断了无法存储在目标类型中的位。

更详细地说，如果目标类型不是 float 8 类型，数值类型之间的转换应遵循以下规则。

将浮点数转换为
- 浮点数: 如果 OOR (超出范围)，则为 +/- 无穷大。
- 定点数: 如果 OOR，则未定义。
- 布尔值: +/- 0.0 为 False；其他均为 True。
将定点数转换为
- 浮点数: 如果 OOR，则为 +/- 无穷大。(uint 情况下的 + 无穷大)
- 定点数: 当 OOR 时，丢弃高位并重新解释 (对于有符号类型，参考二进制补码表示)。例如，200 (int16) -> -56 (int8)。
- 布尔值: 零为 False；非零为 True。
将布尔值转换为
- 浮点数: {1.0, 0.0}。
- 定点数: {1, 0}。
- 布尔值: 不变。

引入 Float 8 类型是为了加速深度模型的训练。默认情况下，浮点数 *x* 的转换遵循以下规则。[x] 表示四舍五入到目标尾数宽度的值。

x	E4M3FN	E4M3FNUZ	E5M2	E5M2FNUZ
0	0	0	0	0
-0	-0	0	-0	0
NaN	NaN	NaN	NaN	NaN
+/- Inf	+/- FLT_MAX	NaN	FLT_MAX	NaN
[x] > FLT_MAX	FLT_MAX	FLT_MAX	FLT_MAX	FLT_MAX
[x] < -FLT_MAX	-FLT_MAX	-FLT_MAX	-FLT_MAX	-FLT_MAX
否则	RNE	RNE	RNE	RNE

如果参数 ‘saturate’ 设置为 False，行为会改变。规则变为

x	E4M3FN	E4M3FNUZ	E5M2	E5M2FNUZ
0	0	0	0	0
-0	-0	0	-0	0
NaN	NaN	NaN	NaN	NaN
+/- Inf	NaN	NaN	+/- Inf	NaN
[x] > FLT_MAX	NaN	NaN	Inf	NaN
[x] < -FLT_MAX	NaN	NaN	-Inf	NaN
否则	RNE	RNE	RNE	RNE

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`saturate`	::mlir::IntegerAttr	64位有符号整数属性
`to`	::mlir::TypeAttr	任意类型属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或字符串类型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或字符串类型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.CategoryMapper` (ONNXCategoryMapperOp)

ONNX CategoryMapper 操作

将字符串转换为整数，反之亦然。
使用两个长度相等的序列在整数和字符串之间进行映射，相同索引处的字符串和整数详细说明了映射关系。
每个操作符根据提供的默认值属性，将整数转换为字符串或将字符串转换为整数。只能定义一个默认值属性。
如果设置了字符串默认值，它将把整数转换为字符串。如果设置了 int 默认值，它将把字符串转换为整数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`cats_int64s`	::mlir::ArrayAttr	64位整型数组属性
`cats_strings`	::mlir::ArrayAttr	字符串数组属性
`default_int64`	::mlir::IntegerAttr	64位有符号整数属性
`default_string`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	字符串类型值的张量或64位整型值的张量

结果

结果	描述
`Y`	字符串类型值的张量或64位整型值的张量

`onnx.Ceil` (ONNXCeilOp)

ONNX Ceil 操作

Ceil 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中对张量逐元素应用向上取整 (ceil)，即 y = ceil(x)。如果 x 是整数、+0、-0、NaN 或无穷大，则返回 x 本身。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Celu` (ONNXCeluOp)

ONNX Celu 操作

连续可微指数线性单元: 使用公式对输入张量 X 逐元素执行线性单元操作

max(0,x) + min(0,alpha*(exp(x/alpha)-1))

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	32位浮点数值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.CenterCropPad` (ONNXCenterCropPadOp)

ONNX CenterCropPad 操作

将输入在给定维度上进行中心裁剪或填充。

可以为 axes 的子集指定裁剪/填充维度。未指定的维度不会被裁剪或填充。

如果输入维度大于裁剪形状，则从输入中提取一个居中裁剪窗口。如果输入维度小于裁剪形状，则输入在两侧等量填充，以便输入在输出中居中。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数描述

输入数据 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

形状 32位整型值的张量或64位整型值的张量

结果

结果描述

输出数据 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Clip` (ONNXClipOp)

ONNX Clip 操作

Clip 操作符将给定输入限制在一个区间内。区间由输入 ‘min’ 和 ‘max’ 指定。它们分别默认为 numeric_limits::lowest() 和 numeric_limits::max()。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`min`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型
`max`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ClipV11` (ONNXClipV11Op)

ONNX Clip 操作

Clip 操作符将给定输入限制在一个区间内。区间由输入 ‘min’ 和 ‘max’ 指定。它们分别默认为 numeric_limits::lowest() 和 numeric_limits::max()。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`min`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`max`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.ClipV12` (ONNXClipV12Op)

ONNX Clip 操作

Clip 操作符将给定输入限制在一个区间内。区间由输入 ‘min’ 和 ‘max’ 指定。它们分别默认为 numeric_limits::lowest() 和 numeric_limits::max()。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`min`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`max`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.ClipV6` (ONNXClipV6Op)

ONNX Clip 操作

Clip 操作符将给定输入限制在一个区间内。区间由参数 ‘min’ 和 ‘max’ 指定。它们分别默认为 numeric_limits::lowest() 和 numeric_limits::max()。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`max`	::mlir::FloatAttr	32位浮点属性
`min`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Col2Im` (ONNXCol2ImOp)

ONNX Col2Im 操作

此操作符将列块重新排列回多维图像

Col2Im 的行为类似于 PyTorch 的 fold https://pytorch.ac.cn/docs/stable/generated/torch.nn.Fold.html，但它仅支持 *批量* 多维图像张量。另一个支持 N 维度的 Python 实现可以在 https://github.com/f-dangel/unfoldNd/ 找到。

注意: 虽然指定 image_shape 看起来是冗余的，因为它可以通过卷积公式计算出来，但正如 PyTorch 的实现 (https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Col2Im.cpp#L10) 中所解释的，在更高级的场景中，它是必需的输入。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`image_shape`	64位整型值的张量
`block_shape`	64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Compress` (ONNXCompressOp)

ONNX Compress 操作

沿给定轴从输入张量中选择切片，其中 condition 对于每个轴索引评估为 True。如果未提供 axis，则在选择元素之前先将输入展平。Compress 的行为类似于 numpy.compress: https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.compress.html

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

输入 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

condition 1位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ConcatFromSequence` (ONNXConcatFromSequenceOp)

ONNX ConcatFromSequence 操作

将一系列张量连接成一个单一张量。除要连接的轴的维度大小外，所有输入张量必须具有相同的形状。默认情况下，‘new_axis’ 为 0，行为类似于 numpy.concatenate。当 ‘new_axis’ 为 1 时，行为类似于 numpy.stack。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`new_axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

input_sequence 8位无符号整型值的张量序列类型或16位无符号整型值的张量序列类型或32位无符号整型值的张量序列类型或64位无符号整型值的张量序列类型或8位整型值的张量序列类型或16位整型值的张量序列类型或32位整型值的张量序列类型或64位整型值的张量序列类型或16位浮点数值的张量序列类型或32位浮点数值的张量序列类型或64位浮点数值的张量序列类型或字符串类型值的张量序列类型或1位整型值的张量序列类型或包含32位浮点元素的复数类型张量序列类型或包含64位浮点元素的复数类型张量序列类型

结果

结果描述

concat_result 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Concat` (ONNXConcatOp)

ONNX Concat 操作

将张量列表连接成一个单一张量。除要连接的轴的维度大小外，所有输入张量必须具有相同的形状。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	可变数量的8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果描述

concat_result 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ConcatShapeTranspose` (ONNXConcatShapeTransposeOp)

ONNX 合并操作

将以下操作序列合并为一个操作 v1 = onnx.concat v2 = onnx.shape(v1) v3 = onnx.transpose(v1)

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`end`	::mlir::IntegerAttr	64位有符号整数属性
`start`	::mlir::IntegerAttr	64位有符号整数属性
`perm`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`输入`	可变数量的8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果描述

形状 64位整型值的张量

转置后的 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ConstantOfShape` (ONNXConstantOfShapeOp)

ONNX ConstantOfShape 操作

生成具有给定值和形状的张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`value`	::mlir::Attribute	任意属性

操作数

操作数	描述
`输入`	64位整型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或1位整型值的张量或bfloat16类型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

`onnx.Constant` (ONNXConstantOp)

ONNX Constant 操作

此操作符产生一个常量张量。必须准确指定提供的属性中的一个，即 value、sparse_value 或 value_*。

特性: AlwaysSpeculatableImplTrait, ConstantLike

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`sparse_value`	::mlir::Attribute	任意属性
`value`	::mlir::Attribute	任意属性
`value_float`	::mlir::FloatAttr	32位浮点属性
`value_floats`	::mlir::ArrayAttr	32位浮点数组属性
`value_int`	::mlir::IntegerAttr	64位有符号整数属性
`value_ints`	::mlir::ArrayAttr	64位整型数组属性
`value_string`	::mlir::StringAttr	字符串属性
`value_strings`	::mlir::ArrayAttr	字符串数组属性

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

`onnx.ConvInteger` (ONNXConvIntegerOp)

ONNX ConvInteger 操作

整数卷积操作符接受一个输入张量、其零点、一个滤波器及其零点，并计算输出。生产过程绝不能溢出。累积只有在 32 位时才可能溢出。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`group`	::mlir::IntegerAttr	64位有符号整数属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`x`	8位整型值的张量或8位无符号整型值的张量
`w`	8位整型值的张量或8位无符号整型值的张量
`x_zero_point`	8位整型值的张量或8位无符号整型值的张量或none类型
`w_zero_point`	8位整型值的张量或8位无符号整型值的张量或none类型

结果

结果	描述
`y`	32位整型值的张量

`onnx.Conv` (ONNXConvOp)

ONNX Conv 操作

卷积操作符接受一个输入张量和一个滤波器，并计算输出。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`group`	::mlir::IntegerAttr	64位有符号整数属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.ConvTranspose` (ONNXConvTransposeOp)

ONNX ConvTranspose 操作

转置卷积操作符接受一个输入张量和一个滤波器，并计算输出。

如果提供了 pads 参数，输出的形状通过以下公式计算

output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]

output_shape 也可以显式指定，在这种情况下，pads 值使用这些公式自动生成

total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i] 如果 (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2) 否则: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`group`	::mlir::IntegerAttr	64位有符号整数属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`output_padding`	::mlir::ArrayAttr	64位整型数组属性
`output_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Cos` (ONNXCosOp)

ONNX Cos 操作

计算给定输入张量的余弦，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Cosh` (ONNXCoshOp)

ONNX Cosh 操作

计算给定输入张量的双曲余弦，逐元素进行。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.CumSum` (ONNXCumSumOp)

ONNX CumSum 操作

沿给定轴执行输入元素的累积和。默认情况下，它将执行包含性求和，即第一个元素按原样复制。通过 exclusive 属性，可以将此行为更改为排除第一个元素。它还可以沿轴的反方向执行求和。为此，将 reverse 属性设置为 1。

示例

input_x = [1, 2, 3]
axis=0
output = [1, 3, 6]
exclusive=1
output = [0, 1, 3]
exclusive=0
reverse=1
output = [6, 5, 3]
exclusive=1
reverse=1
output = [5, 3, 0]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`exclusive`	::mlir::IntegerAttr	64位有符号整数属性
`reverse`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`x`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axis`	32位整型值的张量或64位整型值的张量

结果

结果	描述
`y`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Custom` (ONNXCustomOp)

ONNX Custom 操作

CustomOp 不是 ONNX 标准中定义的操作，添加它是为了支持可转换或最终调用用户定义的外部函数的扩展操作。”

它允许调用用户定义的操作，其中一个必需属性是命名该操作的字符串。其他输入传递给用户操作。

输入和输出的数量可以变化。

输入和输出都允许 NoneType，因为 CustomOp 可能需要固定数量的输入/输出来调用外部函数。

除了传递给用户定义操作的值之外，还引入了一些属性来方便 CustomOp 的分析和转换。

由于编译器未定义 CustomOp 的语义，onnx-mlir 无法推断其输出形状。因此，引入了特定属性来指定如何在 CustomOp 上执行形状推断。这些属性包括：‘inputs_for_infer’：可选。用于形状推断的输入索引。索引值应在 [0, 输入数量) 范围内。如果未指定，则 CustomOp 的所有输入都将用于形状推断。‘shape_infer_pattern’：可选。指定如何将形状信息从输入 (可能受限于 inputs_for_infer) 传播到输出。当前支持的模式有 SameAs、MDBroadcast。‘output_element_type’：可选。输出张量的元素类型。如果未指定，则遵循形状推断模式的行为。通常使用第一个输入的元素类型。CustomOp 的每个实例都可以拥有自己的形状推断属性，允许自定义。但是，具有相同 function_name 的 CustomOps 通常在形状推断方面表现类似，因此具有相同的属性。

ONNX 操作现有的形状推断模式被重用于 CustomOp，形状推断的多态性基于其属性值。由于当前 ONNX Ops 的实现，具有指定形状推断属性的 CustomOp 仅支持单个输出，而不是可变数量的输出。

如果未提供形状推断属性，则 CustomOp 的形状推断将简单地穿透过去。

所有这些额外属性都是可选的，旨在减少侵扰性。添加新属性时，.mlir 文件可以保持不变。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`function_name`	::mlir::StringAttr	字符串属性
`output_element_type`	::mlir::TypeAttr	任意类型属性
`shape_infer_pattern`	::mlir::StringAttr	字符串属性
`inputs_for_infer`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`输入`	可变数量的任意类型值的张量或任意类型值的 memref 或 none类型

结果

结果	描述
`输出`	可变数量的任意类型值的张量或任意类型值的 memref 或 none类型

`onnx.DFT` (ONNXDFTOp)

ONNX DFT 操作

计算输入的离散傅里叶变换 (DFT)。

假设输入形状为 [M, N]，其中 N 是计算 DFT 的维度，M 表示概念上的 "所有其他维度"，形状为 [M, N] 的 DFT y[m, k] 定义为

\[y[m, k] = \sum_{n=0}^{N-1} e^{-2 \pi j \frac{k n}{N} } x[m, n] ,\]

其逆变换定义为

\[x[m, n] = \frac{1}{N} \sum_{k=0}^{N-1} e^{2 \pi j \frac{k n}{N} } y[m, k] ,\]

其中 $j$ 是虚数单位。

输出的实际形状在 "output" 部分指定。

参考: https://docs.scipy.org.cn/doc/scipy/tutorial/fft.html

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`inverse`	::mlir::IntegerAttr	64位有符号整数属性
`onesided`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`dft_length`	32位整型值的张量或64位整型值的张量或none类型
`axis`	64位整型值的张量或none类型

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.DFTV17` (ONNXDFTV17Op)

ONNX DFT 操作

计算输入的离散傅里叶变换。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`inverse`	::mlir::IntegerAttr	64位有符号整数属性
`onesided`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`dft_length`	32位整型值的张量或64位整型值的张量或none类型

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.DeformConv` (ONNXDeformConvOp)

ONNX DeformConv 操作

执行可变形卷积，如 https://arxiv.org/abs/1703.06211 和 https://arxiv.org/abs/1811.11168 中所述。此操作符规范支持通用的 N 维情况。请注意，最常见的用例是 2D 或 3D 数据。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`group`	::mlir::IntegerAttr	64位有符号整数属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`offset_group`	::mlir::IntegerAttr	64位有符号整数属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`offset`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`mask`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.DepthToSpace` (ONNXDepthToSpaceOp)

ONNX DepthToSpace 操作

DepthToSpace 将数据从深度重新排列 (置换) 到空间数据块中。这是 SpaceToDepth 的逆变换。更具体地说，此操作符输出输入张量的副本，其中来自深度维度的值被移动到空间块中的高度和宽度维度。默认情况下，mode = DCR。在 DCR 模式下，来自输入张量沿深度维度的元素按以下顺序重新排列：深度、列，然后是行。输出 y 从输入 x 计算如下

b, c, h, w = x.shape
tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])

在 CRD 模式下，来自输入张量沿深度维度的元素按以下顺序重新排列：列、行，然后是深度。输出 y 从输入 x 计算如下

b, c, h, w = x.shape
tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`blocksize`	::mlir::IntegerAttr	64位有符号整数属性
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.DequantizeLinear` (ONNXDequantizeLinearOp)

ONNX DequantizeLinear 操作

线性反量化操作符。它接受一个量化张量、一个比例因子和一个零点来计算全精度张量。反量化公式为 y = (x - x_zero_point) * x_scale。 x_scale 和 x_zero_point 必须具有相同的形状，并且可以是用于逐张量/逐层量化的标量，也可以是用于逐轴量化的 1-D 张量。x_zero_point 和 x 必须具有相同的类型。x 和 y 必须具有相同的形状。在对 int32 进行反量化的情况下，没有零点 (零点应为 0)。zero-point 在 float8e4m3fn、float8e4m3fnuz、float8e5m2、float8e5m2fnuz 量化的情况下通常不使用，但反量化公式保持不变以保持一致性，并且 ‘x_scale’ 仍然确定输出类型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`x`	8位整型值的张量或8位无符号整型值的张量或32位整型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量
`x_scale`	32位浮点数值的张量或16位浮点数值的张量或bfloat16类型值的张量
`x_zero_point`	8位整型值的张量或8位无符号整型值的张量或32位整型值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或none类型

结果

结果	描述
`y`	32位浮点数值的张量或16位浮点数值的张量或bfloat16类型值的张量

`onnx.Det` (ONNXDetOp)

ONNX Det 操作

Det 计算方阵或一批方阵的行列式。Det 接受一个形状为 [*, M, M] 的输入张量，其中 * 是零个或多个批量维度，最里面的 2 个维度形成方阵。输出是形状为 [*] 的张量，包含所有输入子矩阵的行列式。例如，当输入是 2-D 时，输出是一个标量 (形状为空: [])。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.DictVectorizer` (ONNXDictVectorizerOp)

ONNX DictVectorizer 操作

使用索引映射将字典转换为数组。
给定一个字典，每个键在与键类型对应的词汇属性中查找。找到键在词汇数组中的索引，然后用于索引输出一维张量 ‘Y’，并将字典 ‘X’ 中找到的值插入其中。
输入映射的键类型必须与定义的词汇属性的元素类型相对应。因此，输出数组的长度将等于索引映射向量参数的长度。输入字典中的所有键必须存在于索引映射向量中。对于输入字典中的每个项，将其值插入到输出数组中。输入字典中不存在的任何键在输出数组中将为零。
例如: 如果 string_vocabulary 参数设置为 ["a", "c", "b", "z"]，则输入 {"a": 4, "c": 8} 将产生输出 [4, 8, 0, 0]。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`int64_vocabulary`	::mlir::ArrayAttr	64位整型数组属性
`string_vocabulary`	::mlir::ArrayAttr	字符串数组属性

操作数

操作数	描述
`X`	包含字符串类型或64位整型值任意组合的元组，或包含64位整型或字符串类型值任意组合的元组，或包含64位整型或32位浮点数值任意组合的元组，或包含64位整型或64位浮点数值任意组合的元组，或包含字符串类型或32位浮点数值任意组合的元组，或包含字符串类型或64位浮点数值任意组合的元组

结果

结果	描述
`Y`	64位整型值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量

`onnx.DimGroup` (ONNXDimGroupOp)

ONNX 维度组操作。

此操作用于将张量的编译时未知维度链接到组 ID。具有相同组 ID 的两个维度预期在运行时相等。

"onnx.DimGroup"(%tensor) {axis = 0 : si64, group_id = 1: si64} : (tensor<?x3x5xf32>) -> ()

axis 标识张量中的维度位置。

group_id 标识维度的组 ID。它是非负数。group_id 的值 -1 表示该维度不属于任何组。

此操作当前用于 --onnx-dim-analysis pass，以测试未知维度分析类。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`group_id`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Dim` (ONNXDimOp)

ONNX 维度操作。

此操作用于获取张量的维度；

"onnx.Dim"(%tensor) {axis = 0 : si64} : (tensor<?x3x5xf32>) -> tensor<1xi64>

axis 标识形状中将要获取的维度。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`dim`	64位整型值的张量

`onnx.Div` (ONNXDivOp)

ONNX Div 操作

执行逐元素的二元除法 (支持 Numpy 风格的广播)。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

(Opset 14 变更): 扩展支持的类型，包含 uint8, int8, uint16 和 int16。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Dropout` (ONNXDropoutOp)

ONNX Dropout 操作

Dropout 接受一个浮点张量输入、一个可选的输入比例 (浮点标量) 和一个可选的输入 training_mode (布尔标量)。它产生两个张量输出，output (浮点张量) 和 mask (可选 Tensor<bool>)。如果 training_mode 为 true，则输出 Y 将是随机丢弃；请注意，此 Dropout 通过以下公式缩放被遮罩的输入数据，因此要将训练好的模型转换为推理模式，用户只需不传递 training_mode 输入或将其设置为 false 即可。

output = scale * data * mask,

其中

scale = 1. / (1. - ratio).

此操作符具有**可选**输入/输出。有关可选参数表示的更多详细信息，请参阅文档。可以使用空字符串代替实际参数名称来指示缺失的参数。末尾的可选参数 (后没有紧随存在参数的参数) 也可以简单省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`seed`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量
`ratio`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或none类型
`training_mode`	1位整型值的张量或none类型

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量
`mask`	1位整型值的张量或none类型

`onnx.DynamicQuantizeLinear` (ONNXDynamicQuantizeLinearOp)

ONNX DynamicQuantizeLinear 操作

一个函数，用于融合 FP32 输入数据的比例因子、零点和 FP32->8位转换的计算。对于给定的 FP32 输入，输出比例因子、零点和量化输入。比例因子计算如下

y_scale = (maximum(0, max(x)) - minimum(0, min(x))) / (qmax - qmin)

其中 qmax 和 qmin 是量化范围的最大值和最小值，即 uint8 的情况下为 [0, 255]
数据范围调整为包含 0。

零点计算如下

intermediate_zero_point = qmin - min(x)/y_scale
y_zero_point = cast(round(saturate(itermediate_zero_point)))

其中 qmax 和 qmin 是量化范围的最大值和最小值，即 uint8 的情况下为 [0, 255]
对于饱和，如果是 uint8，则饱和到 [0, 255]，如果是 int8，则饱和到 [-127, 127]。目前仅支持 uint8。
四舍五入到最近的偶数。

数据量化公式为

y = saturate (round (x / y_scale) + y_zero_point)

对于饱和，如果是 uint8，则饱和到 [0, 255]，如果是 int8，则饱和到 [-127, 127]。目前仅支持 uint8。
四舍五入到最近的偶数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`x`	32位浮点数值的张量

结果

结果	描述
`y`	8位无符号整型值的张量
`y_scale`	32位浮点数值的张量
`y_zero_point`	8位无符号整型值的张量

`onnx.Einsum` (ONNXEinsumOp)

ONNX Einsum 操作

形式为 term1, term2 -> output-term 的 einsum 使用以下公式产生输出张量

output[output-term] = reduce-sum( input1[term1] * input2[term2] )

其中 reduce-sum 对输入项 (term1, term2) 中出现但在 output-term 中不出现的所有索引执行求和。

Einsum 操作符使用爱因斯坦求和约定，在一系列张量上评估代数张量操作。方程字符串包含一个逗号分隔的小写字母序列。每个项对应一个操作数张量，项中的字符对应操作数维度。

此序列后可跟 "->"，以分隔方程的左侧和右侧。如果方程包含 "->"，后跟右侧，则执行显式 (非经典) 形式的爱因斯坦求和，右侧索引指示输出张量维度。在其他情况下，输出索引 (隐式) 设置为方程中恰好出现一次的索引按字母顺序排序的序列。

当维度字符在左侧重复时，它表示沿该维度的求和。

方程可以包含省略号 ("...") 以启用广播。省略号必须表示固定数量的维度。具体来说，方程中省略号的每次出现必须代表相同数量的维度。右侧可以包含且仅包含一个省略号。在隐式模式下，省略号维度设置在输出的开头。方程字符串可以包含空格 (U+0020) 字符。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`equation`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`输入`	可变数量的8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Elu` (ONNXEluOp)

ONNX Elu 操作

Elu 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中函数 f(x) = alpha * (exp(x) - 1.) (当 x < 0), f(x) = x (当 x >= 0)，被逐元素应用于张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.EntryPoint` (ONNXEntryPointOp)

指示 ONNX 入口点

“onnx.EntryPoint” 函数指示 ONNX 模型的主入口点。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

属性

属性	MLIR 类型	描述
`func`	::mlir::SymbolRefAttr	符号引用属性

`onnx.Equal` (ONNXEqualOp)

ONNX Equal 操作

对输入张量 A 和 B 逐元素执行 equal 逻辑操作 (支持 Numpy 风格的广播) 后返回结果张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

A 1位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或字符串类型值的张量

B 1位整型值的张量或8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或字符串类型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.Erf` (ONNXErfOp)

ONNX Erf 操作

逐元素计算给定输入张量的误差函数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Exp` (ONNXExpOp)

ONNX Exp 操作

逐元素计算给定输入张量的指数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Expand` (ONNXExpandOp)

ONNX Expand 操作

根据给定的形状和广播规则广播输入张量。广播规则类似于 numpy.array(input) * numpy.ones(shape)：维度右对齐；两个对应维度必须具有相同的值，或其中一个等于 1。此外，此操作符类似于 numpy.broadcast_to(input, shape)，但主要区别在于 numpy.broadcast_to() 不允许 shape 小于 input.size()。当 shape 中的某些维度等于 1，或 shape.ndim < input.shape.ndim 时，output.shape 可能不等于 shape。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

输入 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

形状 64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.EyeLike` (ONNXEyeLikeOp)

ONNX EyeLike 操作

生成一个二维张量 (矩阵)，对角线上为 1，其他位置为 0。仅支持二维张量，即输入 T1 必须是秩为 2 的张量。输出张量的形状与输入张量相同。数据类型可以通过 ‘dtype’ 参数指定。如果未指定 ‘dtype’，则使用输入张量的类型。默认情况下，主对角线上填充 1，但可以使用属性 ‘k’ 来填充上对角线或下对角线。‘dtype’ 参数必须是 TensorProto 消息中 ‘DataType’ 枚举字段中指定的数据类型之一，并且必须是有效的输出类型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`k`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或1位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或1位整型值的张量

`onnx.FeatureVectorizer` (ONNXFeatureVectorizerOp)

ONNX FeatureVectorizer 操作

将输入张量连接成一个连续的输出。
所有输入的形状都是二维的，并沿第二维连接。一维张量被视为 [1,C]。输入按输入参数的顺序复制到输出。
所有输入必须是整数或浮点数，而输出将全部是浮点值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`inputdimensions`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	可变数量的32位整型值的张量或64位整型值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Flatten` (ONNXFlattenOp)

ONNX Flatten 操作

将输入张量展平为二维矩阵。如果输入张量的形状为 (d_0, d_1, … d_n)，则输出形状将为 (d_0 X d_1 … d_(axis-1), d_axis X d_(axis+1) … X dn)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.Floor` (ONNXFloorOp)

ONNX Floor 操作

Floor 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中对张量逐元素应用向下取整 (floor)，即 y = floor(x)。如果 x 是整数、+0、-0、NaN 或无穷大，则返回 x 本身。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.GRU` (ONNXGRUOp)

ONNX GRU 操作

计算一层 GRU。此操作符通常通过一些自定义实现（例如 CuDNN）来支持。

记号

X - 输入张量
z - 更新门
r - 重置门
h - 隐门
t - 时间步 (t-1 表示上一个时间步)
W[zrh] - 用于更新门、重置门和隐门的 W 参数权重矩阵
R[zrh] - 用于更新门、重置门和隐门的 R 循环权重矩阵
Wb[zrh] - 用于更新门、重置门和隐门的 W 偏置向量
Rb[zrh] - 用于更新门、重置门和隐门的 R 偏置向量
WB[zrh] - 用于反向更新门、重置门和隐门的 W 参数权重矩阵
RB[zrh] - 用于反向更新门、重置门和隐门的 R 循环权重矩阵
WBb[zrh] - 用于反向更新门、重置门和隐门的 W 偏置向量
RBb[zrh] - 用于反向更新门、重置门和隐门的 R 偏置向量
H - 隐藏状态
num_directions - 如果 direction == bidirectional 则为 2，否则为 1

激活函数

Relu(x) - max(0, x)
Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x})
Sigmoid(x) - 1/(1 + e^{-x})

注意: 以下是可选的

Affine(x) - alpha * x + beta
LeakyRelu(x) - x (如果 x >= 0) 否则 alpha * x
ThresholdedRelu(x) - x (如果 x >= alpha) 否则 0
ScaledTanh(x) - alpha * Tanh(beta * x)
HardSigmoid(x) - min(max(alpha * x + beta, 0), 1)
Elu(x) - x (如果 x >= 0) 否则 alpha * (e^x - 1)
Softsign(x) - x/(1 + x )
Softplus(x) - log(1 + e^x)

公式 (默认: f=Sigmoid, g=Tanh)

zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # 默认，当 linear_before_reset = 0
ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # 当 linear_before_reset != 0
Ht = (1 - zt) (.) ht + zt (.) Ht-1 此操作符具有**可选**输入/输出。有关可选参数表示的更多详细信息，请参阅文档。可以使用空字符串代替实际参数名称来指示缺失的参数。末尾的可选参数 (后没有紧随存在参数的参数) 也可以简单省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`activation_alpha`	::mlir::ArrayAttr	32位浮点数组属性
`activation_beta`	::mlir::ArrayAttr	32位浮点数组属性
`activations`	::mlir::ArrayAttr	字符串数组属性
`clip`	::mlir::FloatAttr	32位浮点属性
`direction`	::mlir::StringAttr	字符串属性
`hidden_size`	::mlir::IntegerAttr	64位有符号整数属性
`layout`	::mlir::IntegerAttr	64位有符号整数属性
`linear_before_reset`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`R`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`sequence_lens`	32位整型值的张量或none类型
`initial_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`Y_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

`onnx.GatherElements` (ONNXGatherElementsOp)

ONNX GatherElements 操作

GatherElements 接受两个具有相同秩 r >= 1 的输入 data 和 indices，以及一个可选属性 axis，该属性标识 data 的一个轴 (默认情况下是外层轴，即轴 0)。它是一个索引操作，通过在输入数据张量中由 indices 张量元素确定的索引位置进行索引来产生输出。其输出形状与 indices 的形状相同，并且包含从 data 中收集的与 indices 中的每个元素对应的一个值。

例如，在三维情况下 (r = 3)，产生的输出由以下公式确定

out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,

此操作符也是 ScatterElements 的逆运算。它类似于 Torch 的 gather 操作。

示例 1

data = [
    [1, 2],
    [3, 4],
]
indices = [
    [0, 0],
    [1, 0],
]
axis = 1
output = [
    [1, 1],
    [4, 3],
]

示例 2

data = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
indices = [
    [1, 2, 0],
    [2, 0, 0],
]
axis = 0
output = [
    [4, 8, 3],
    [7, 2, 3],
]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

数据 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

indices 32位整型值的张量或64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.GatherND` (ONNXGatherNDOp)

ONNX GatherND 操作

给定秩为 r >= 1 的 data 张量，秩为 q >= 1 的 indices 张量，以及 batch_dims 整数 b，此操作符将 data 的切片收集到秩为 q + r - indices_shape[-1] - 1 - b 的输出张量中。

indices 是一个 q 维整数张量，最好将其视为一个 (q-1) 维张量，其中包含指向 data 的索引元组，每个元素定义了 data 的一个切片

batch_dims（表示为 b）是一个整数，表示批量维度的数量，即 data 张量和 indices 的前 b 个维度代表批量，收集（gather）从 b+1 维度开始。

关于输入的秩和形状的一些突出要点

1) 必须满足 r >= 1 且 q >= 1。秩 r 和 q 之间没有需要满足的依赖条件

2) indices 张量和 data 张量形状的前 b 个维度必须相等。

3) 必须满足 b < min(q, r)。

4) indices_shape[-1] 的值应在 1（包含）到秩 r-b（包含）之间

5) indices 中的所有值沿大小为 s 的轴应在界限 [-s, s-1] 内（即 -data_shape[i] <= indices[...,i] <= data_shape[i] - 1）。任何索引值越界都是错误。

输出计算如下

通过将 indices 张量中的每个索引元组映射到输入 data 的相应切片来获得输出张量。

1) 如果 indices_shape[-1] > r-b => 错误条件

2) 如果 indices_shape[-1] == r-b，由于 indices 的秩为 q，indices 可以被视为 N 个 (q-b-1) 维张量，其中包含维度为 r-b 的 1 维张量，N 是一个等于 1 乘以 indices_shape 中批量维度的所有元素乘积的整数。我们将每个这样的 r-b 秩张量视为 indices_slice。与 data[0:b-1,indices_slice] 对应的每个*标量值*被填充到 (q-b-1) 维张量的相应位置，形成 output 张量（见下面的示例 1）

3) 如果 indices_shape[-1] < r-b，由于 indices 的秩为 q，indices 可以被视为 N 个 (q-b-1) 维张量，其中包含维度为 < r-b 的 1 维张量。我们将每个这样的张量视为 indices_slice。与 data[0:b-1, indices_slice , :] 对应的每个*张量切片*被填充到 (q-b-1) 维张量的相应位置，形成 output 张量（见下面的示例 2、3、4 和 5）

此运算符是 ScatterND 的逆运算。

示例 1

batch_dims = 0
data    = [[0,1],[2,3]]   # data_shape    = [2, 2]
indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
output  = [0,3]           # output_shape  = [2]

示例 2

batch_dims = 0
data    = [[0,1],[2,3]]  # data_shape    = [2, 2]
indices = [[1],[0]]      # indices_shape = [2, 1]
output  = [[2,3],[0,1]]  # output_shape  = [2, 2]

示例 3

batch_dims = 0
data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]

示例 4

batch_dims = 0
data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
output  = [[[2,3]],[[4,5]]]             # output_shape  = [2, 1, 2]

示例 5

batch_dims = 1
data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
indices = [[1],[0]]                     # indices_shape = [2, 1]
output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`batch_dims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

indices 64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Gather` (ONNXGatherOp)

ONNX Gather 操作

给定秩 r >= 1 的 data 张量和秩 q 的 indices 张量，收集 data 的轴维度（默认为最外层维度，axis=0）中由 indices 索引的条目，并将它们拼接成秩为 q + (r - 1) 的输出张量。

如果 axis = 0，令 k = indices[i_{0}, ..., i_{q-1\}] 则 output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2\}] = input[k , j_{0}, ..., j_{r-2\}]

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]
indices = [
    [0, 1],
    [1, 2],
]
output = [
    [
        [1.0, 1.2],
        [2.3, 3.4],
    ],
    [
        [2.3, 3.4],
        [4.5, 5.7],
    ],
]

如果 axis = 1，令 k = indices[i_{0}, ..., i_{q-1\}] 则 output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2\}] = input[j_{0}, k, j_{1}, ..., j_{r-2\}]

data = [
    [1.0, 1.2, 1.9],
    [2.3, 3.4, 3.9],
    [4.5, 5.7, 5.9],
]
indices = [
    [0, 2],
]
axis = 1,
output = [
        [[1.0, 1.9]],
        [[2.3, 3.9]],
        [[4.5, 5.9]],
]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

indices 32位整型值的张量或64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Gelu` (ONNXGeluOp)

ONNX Gelu 操作

Gelu 接受一个输入数据（张量) 并产生一个输出数据 (张量），并对张量按元素应用高斯误差线性单元函数 $y = 0.5 * x * (1 + erf(x/sqrt(2)))$。如果属性 "approximate" 设置为 "tanh"，则使用函数估计 $y = 0.5 * x * (1 + Tanh(sqrt(2/\pi) * (x + 0.044715 * x^3)))$ 并按元素应用于张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`approximate`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Gemm` (ONNXGemmOp)

ONNX Gemm 操作

通用矩阵乘法：https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3

A’ = transpose(A) if transA else A
B’ = transpose(B) if transB else B

计算 Y = alpha * A’ * B’ + beta * C，其中输入张量 A 的形状为 (M, K) 或 (K, M)，输入张量 B 的形状为 (K, N) 或 (N, K)，输入张量 C 可广播到形状 (M, N)，输出张量 Y 的形状为 (M, N)。如果属性 transA 非零，A 将在计算前被转置，B 和 transB 也一样。此运算符支持单向广播（张量 C 应能单向广播到张量 A * B）；更多详情请查阅文档。此运算符具有可选输入/输出。有关可选参数表示的更多详情，请查阅文档。可以使用空字符串代替实际参数名称来表示缺失参数。末尾的可选参数（后跟的参数不存在的）也可以简单地省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`beta`	::mlir::FloatAttr	32位浮点属性
`transA`	::mlir::IntegerAttr	64位有符号整数属性
`transB`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`A`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量
`B`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量
`C`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 none 类型

结果

结果	描述
`Y`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量

`onnx.GlobalAveragePool` (ONNXGlobalAveragePoolOp)

ONNX GlobalAveragePool 操作

GlobalAveragePool 接受输入张量 X 并在同一通道的值上应用平均池化。这等同于使用与输入张量空间维度相同的核心尺寸的 AveragePool。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.GlobalLpPool` (ONNXGlobalLpPoolOp)

ONNX GlobalLpPool 操作

GlobalLpPool 接受输入张量 X 并在同一通道的值上应用 Lp 范数池化。这等同于使用与输入张量空间维度相同的核心尺寸的 LpPool。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`p`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.GlobalMaxPool` (ONNXGlobalMaxPoolOp)

ONNX GlobalMaxPool 操作

GlobalMaxPool 接受输入张量 X 并在同一通道的值上应用最大池化。这等同于使用与输入张量空间维度相同的核心尺寸的 MaxPool。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Gradient` (ONNXGradientOp)

ONNX Gradient 操作

Gradient 运算符计算特定张量关于其他一些张量的偏导数。此运算符广泛应用于基于梯度的训练算法。为了说明其用法，考虑一个计算图，

X -----.
       |
       v
W --> Conv --> H --> Gemm --> Y
                      ^
                      |
                      Z

，其中 W 和 Z 是可训练张量。请注意，为了简洁起见，省略了运算符的属性。令 dY/dW (dY/dZ) 为 Y 关于 W (Z) 的梯度。用户可以通过插入 Gradient 运算符来计算梯度，形成下图所示的另一个图。

W --> Conv --> H --> Gemm --> Y
|      ^              ^
|      |              |
|      X              Z
|      |              |
|      |   .----------'
|      |   |  (W/Z/X is the 1st/2nd/3rd input of Gradient as shown in
|      |   |   \"xs\" followed by \"zs\")
|      v   v
'---> Gradient(xs=[\"W\", \"Z\"], zs=[\"X\"], y=\"Y\")
       |   |
       |   '-----------------------------------> dY/dW (1st output of Gradient)
       |
       '---------------------------------------> dY/dZ (2nd output of Gradient)

根据定义，张量“y”是“xs”和“zs”中的自变量的函数。由于我们仅计算“y”关于“xs”中可微分变量的梯度，因此此 Gradient 仅输出 dY/dW 和 dY/dZ。请注意，“H”不能出现在“xs”和“zs”中。原因在于“H”可以由张量“W”和“X”确定，因此“H”不是一个自变量。

所有输出都是可选的。如果需要，例如，用户可以将空字符串分配给 Gradient 的第一个输出名称，以跳过 dY/dW 的生成。请注意，可选输出的概念也可在 ONNX 的 RNN、GRU 和 LSTM 中找到。

Gradient 运算符可以计算关于中间张量的导数。例如，Y 关于 H 的梯度可以通过以下方式完成：

W --> Conv --> H --> Gemm --> Y
       ^       |      ^
       |       |      |
       X       |      Z
       .-------'      |
       |   .----------'
       |   | (H/Z is the 1st/2nd input of Gradient as shown in \"xs\")
       v   v
      Gradient(xs=[\"H\", \"Z\"], y=\"Y\")
       |   |
       |   '-----------------------------------> dY/dH (1st output of Gradient)
       |
       '---------------------------------------> dY/dZ (2nd output of Gradient)

可以使用 Gradient 运算符表示高阶微分。例如，给定以下线性模型

W --> Gemm --> Y --> Loss --> O
       ^              ^
       |              |
       X              L

要计算 O 关于 W 的二阶导数（表示为 d^2O/dW^2），可以执行以下操作：

W --> Gemm --> Y --> Loss --> O
|      ^              ^
|      |              |
|      X .------------L
|      | |            |
|      | |            v
+------+-+> Gradient(xs=[\"X\", \"W\"], zs=[\"L\"], y=\"O\") ---> dO/dX (1st output of Gradient)
|      | |    |
|      | |    '---> dO/dW (2nd output of Gradient)
|      v v
'---> Gradient(xs=[\"X\", \"W\"], zs=[\"L\"], y=\"dO/dW\") ---> d(dO/dW)dX (1st output of
       |                                                  Gradient)
       |
       |
       '---> d^2O/dW^2 (2nd output of Gradient)

属性“xs”、“zs”和“y”中命名的张量定义了微分计算图，而 Gradient 节点的输入定义了计算梯度的值。我们可以将不同的张量馈送到已识别的图中。例如，可以通过将 H 的特定值 H_1 作为输入提供给 Gradient 节点来计算 Y 关于 H 在该特定值 H_1 处的梯度。

W --> Conv --> H --> Gemm --> Y
       ^              ^
       |              |
       X              Z

          Z_1 (2nd input of Gradient)
           |
           v
H_1 --> Gradient(xs=[\"H\", \"Z\"], y=\"Y\") ---> dY/dH when H = H_1 and Y = Y_1.
           |
           '------------------------------> dY/dZ (2nd output of Gradient)

当 Gradient 的输入是“xs”和“zs”中命名的张量时，计算可以得到优化。更具体地说，如果通过反向模式自动微分计算梯度，可以重用前向传播中的中间变量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`xs`	::mlir::ArrayAttr	字符串数组属性
`y`	::mlir::StringAttr	字符串属性
`zs`	::mlir::ArrayAttr	字符串数组属性

操作数

操作数	描述
`输入`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量

结果

结果	描述
`Outputs`	可变数量的 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量

`onnx.Greater` (ONNXGreaterOp)

ONNX Greater 操作

返回对输入张量 A 和 B 按元素执行 greater 逻辑运算（支持 Numpy 风格的广播）所得的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.GreaterOrEqual` (ONNXGreaterOrEqualOp)

ONNX GreaterOrEqual 操作

返回对输入张量 A 和 B 按元素执行 greater_equal 逻辑运算（支持 Numpy 风格的广播）所得的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.GridSample` (ONNXGridSampleOp)

ONNX GridSample 操作

给定输入 X 和流场 grid，使用 X 值和 grid 中的像素位置计算输出 Y。对于形状为 (N, C, H, W) 的空间输入 X，grid 的形状将为 (N, H_out, W_out, 2)，输出 Y 的形状将为 (N, C, H_out, W_out)。对于形状为 (N, C, D, H, W) 的体积输入 X，grid 的形状将为 (N, D_out, H_out, W_out, 3)，输出 Y 的形状将为 (N, C, D_out, H_out, W_out)。更一般地，对于形状为 (N, C, d1, d2, …, dr) 的秩 r+2 输入 X，grid 的形状将为 (N, D1_out, D2_out, …, Dr_out, r)，输出 Y 的形状将为 (N, C, D1_out, D2_out, …, Dr_out)。

张量 X 包含方形像素（体素等）中心位置（如 (n, c, d1_in, d2_in, …, dr_in)）处的值。grid 张量中的 (n, d1_out, d2_out, …, dr_out, :) 值是用于插值输出张量 Y 中 (n, c, d1_out, d2_out, …, dr_out) 位置处值的归一化位置，使用指定的插值方法（mode）和填充模式（用于落到二维图像外部的 grid 位置）。

例如，grid[n, h_out, w_out, :] 中的值是尺寸为 2 的向量，指定了 X 二维空间中的归一化位置。它们用于插值 Y[n, c, h_out, w_out] 的输出值。

GridSample 运算符常用于空间变换网络中的网格生成器和采样器。另请参阅 torch.nn.functional.grid_sample。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`align_corners`	::mlir::IntegerAttr	64位有符号整数属性
`mode`	::mlir::StringAttr	字符串属性
`padding_mode`	::mlir::StringAttr	字符串属性

操作数

操作数描述

X 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

grid bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.GridSampleV16` (ONNXGridSampleV16Op)

ONNX GridSample 操作

给定输入 X 和流场 grid，使用 X 值和 grid 中的像素位置计算输出 Y。目前仅支持空间（4 维）输入。对于形状为 (N, C, H, W) 的输入 X 和形状为 (N, H_out, W_out, 2) 的 grid，输出 Y 的形状将为 (N, C, H_out, W_out)。

张量 X 包含 H x W 二维图像中方形像素中心处的值。张量 grid 描述了归一化位置，输出 Y 将在该位置使用指定的插值方法（mode）和填充模式（用于落到二维图像外部的网格位置）进行计算。

grid[N, H_out, W_out] 中的元素是尺寸为 2 的向量，指定了 X 二维空间中的位置。它们用于插值 Y[N, C, H_out, W_out] 的输出值。

GridSample 运算符常用于空间变换网络中的网格生成器和采样器。另请参阅 torch.nn.functional.grid_sample。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`align_corners`	::mlir::IntegerAttr	64位有符号整数属性
`mode`	::mlir::StringAttr	字符串属性
`padding_mode`	::mlir::StringAttr	字符串属性

操作数

操作数描述

X 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

grid 16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.GroupNormalization` (ONNXGroupNormalizationOp)

ONNX GroupNormalization 操作

组归一化函数。执行论文 https://arxiv.org/abs/1803.08494 中描述的组归一化。

此运算符根据以下公式转换输入：

y = scale * (x - mean) / sqrt(variance + epsilon) + bias,

其中均值和方差针对每组通道的每个实例计算，scale 和 bias 应为每组通道指定。num_groups 必须能整除通道数，以便每组拥有相同数量的通道。

整体计算分为两个阶段：第一阶段将元素标准化，使每组中每个实例的元素均值为零，方差为单位方差；第二阶段对第一阶段的结果进行缩放和偏移。第一阶段使用的浮点精度由 stash_type 属性确定。例如，如果 stash_type 为 1，运算符将所有输入变量转换为 32 位浮点数，执行计算，最后将归一化结果转换回 X 的原始类型。第二阶段不依赖于 stash_type。

当组数与通道数相同时，此运算符等同于 InstanceNormalization。当只有一组时，此运算符等同于 LayerNormalization。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`epsilon`	::mlir::FloatAttr	32位浮点属性
`num_groups`	::mlir::IntegerAttr	64位有符号整数属性
`stash_type`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`scale`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`bias`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.GroupNormalizationV18` (ONNXGroupNormalizationV18Op)

ONNX GroupNormalization 操作

组归一化函数。执行论文 https://arxiv.org/abs/1803.08494 中描述的组归一化。

此运算符根据以下公式转换输入：

y = scale * (x - mean) / sqrt(variance + epsilon) + bias,

其中均值和方差针对每组通道的每个实例计算，scale 和 bias 应为每组通道指定。num_groups 必须能整除通道数，以便每组拥有相同数量的通道。

当组数与通道数相同时，此运算符等同于 InstanceNormalization。当只有一组时，此运算符等同于 LayerNormalization。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`epsilon`	::mlir::FloatAttr	32位浮点属性
`num_groups`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`scale`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`bias`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.HammingWindow` (ONNXHammingWindowOp)

ONNX HammingWindow 操作

生成论文 https://ieeexplore.ieee.org/document/1455106 中描述的 Hamming 窗。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`output_datatype`	::mlir::IntegerAttr	64位有符号整数属性
`periodic`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`size`	32位整型值的张量或64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.HannWindow` (ONNXHannWindowOp)

ONNX HannWindow 操作

生成论文 https://ieeexplore.ieee.org/document/1455106 中描述的 Hann 窗。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`output_datatype`	::mlir::IntegerAttr	64位有符号整数属性
`periodic`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`size`	32位整型值的张量或64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.HardSigmoid` (ONNXHardSigmoidOp)

ONNX HardSigmoid 操作

HardSigmoid 接受一个输入数据（张量) 并产生一个输出数据 (张量），并对张量按元素应用 HardSigmoid 函数 y = max(0, min(1, alpha * x + beta))。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`beta`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.HardSwish` (ONNXHardSwishOp)

ONNX HardSwish 操作

HardSwish 接受一个输入数据（张量) 并产生一个输出数据 (张量），并对张量按元素应用 HardSwish 函数 y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid<alpha, beta>(x)，其中 alpha = 1/6 且 beta = 0.5。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Hardmax` (ONNXHardmaxOp)

ONNX Hardmax 操作

此运算符计算给定输入的 hardmax 值

Hardmax(input 中的元素, axis) = 1（如果该元素是沿指定轴的第一个最大值），否则为 0

“axis”属性指示将执行 Hardmax 的维度。输出张量具有相同的形状，并包含相应输入的 Hardmax 值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Identity` (ONNXIdentityOp)

ONNX Identity 操作

恒等运算符

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

输入 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 f8E4M3FN 类型值张量或 f8E4M3FNUZ 类型值张量或 f8E5M2 类型值张量或 f8E5M2FNUZ 类型值张量或 4 位无符号整数值张量或 4 位整数值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量或 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量

结果

结果描述

输出 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 f8E4M3FN 类型值张量或 f8E4M3FNUZ 类型值张量或 f8E5M2 类型值张量或 f8E5M2FNUZ 类型值张量或 4 位无符号整数值张量或 4 位整数值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量或 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量

`onnx.If` (ONNXIfOp)

ONNX If 操作

If 条件

特性: AlwaysSpeculatableImplTrait

接口：ConditionallySpeculatable, HasOnnxSubgraphOpInterface, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`cond`	1位整型值的张量

结果

结果描述

输出 可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 f8E4M3FN 类型值张量或 f8E4M3FNUZ 类型值张量或 f8E5M2 类型值张量或 f8E5M2FNUZ 类型值张量或 4 位无符号整数值张量或 4 位整数值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 bfloat16 类型值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量或 f8E4M3FN 类型值序列类型张量或 f8E4M3FNUZ 类型值序列类型张量或 f8E5M2 类型值序列类型张量或 f8E5M2FNUZ 类型值序列类型张量或 4 位无符号整数值序列类型张量或 4 位整数值序列类型张量或 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 bfloat16 类型值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 bfloat16 类型值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量或 f8E4M3FN 类型值可选类型张量或 f8E4M3FNUZ 类型值可选类型张量或 f8E5M2 类型值可选类型张量或 f8E5M2FNUZ 类型值可选类型张量或 4 位无符号整数值可选类型张量或 4 位整数值可选类型张量

`onnx.Imputer` (ONNXImputerOp)

ONNX Imputer 操作

将等于某个值的输入替换为另一个值，同时保持所有其他元素不变。
此运算符通常用于在缺失值具有规范表示（如 -1、0、NaN 或某个极端值）的情况下替换它们。
imputed_value_floats 和 imputed_value_int64s 必须且只能定义一个——如果输入张量保存浮点数则定义 floats，如果输入张量保存整数则定义 integers。被填充的值必须全部适合张量元素类型的宽度。replaced_value_float 和 replaced_value_int64 必须且只能定义一个，具体取决于处理的是浮点数还是整数。
imputed_value 属性的长度可以是 1 个元素，也可以是每个输入特征一个元素。
换句话说，如果输入张量的形状为 [*,F]，则属性数组的长度可以是 1 或 F。如果为 1，则沿最后一个维度广播并应用于每个特征。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`imputed_value_floats`	::mlir::ArrayAttr	32位浮点数组属性
`imputed_value_int64s`	::mlir::ArrayAttr	64位整型数组属性
`replaced_value_float`	::mlir::FloatAttr	32位浮点属性
`replaced_value_int64`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

`onnx.InstanceNormalization` (ONNXInstanceNormalizationOp)

ONNX InstanceNormalization 操作

执行论文 https://arxiv.org/abs/1607.08022 中描述的实例归一化。

y = scale * (x - mean) / sqrt(variance + epsilon) + B，其中均值和方差针对每个实例、每个通道计算。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`epsilon`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`scale`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.IsInf` (ONNXIsInfOp)

ONNX IsInf 操作

将无穷大映射为真，将其他值映射为假。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`detect_negative`	::mlir::IntegerAttr	64位有符号整数属性
`detect_positive`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

结果

结果	描述
`Y`	1位整型值的张量

`onnx.IsNaN` (ONNXIsNaNOp)

ONNX IsNaN 操作

返回输入中哪些元素是 NaN。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量

结果

结果	描述
`Y`	1位整型值的张量

`onnx.LRN` (ONNXLRNOp)

ONNX LRN 操作

AlexNet 论文中提出的局部响应归一化。它对局部输入区域进行归一化。局部区域跨通道定义。对于形状为 (N x C x D1 x D2, ..., Dk) 的张量中的元素 X[n, c, d1, ..., dk]，其区域为 {X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}。

square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2)，其中 max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))。

Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`beta`	::mlir::FloatAttr	32位浮点属性
`bias`	::mlir::FloatAttr	32位浮点属性
`size`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.LSTM` (ONNXLSTMOp)

ONNX LSTM 操作

计算单层 LSTM。此运算符通常通过 CuDNN 等自定义实现支持。

记号

X - 输入张量
i - 输入门
o - 输出门
f - 遗忘门
c - 单元门
t - 时间步 (t-1 表示上一个时间步)
W[iofc] - 输入、输出、遗忘和单元门的 W 参数权重矩阵
R[iofc] - 输入、输出、遗忘和单元门的 R 循环权重矩阵
Wb[iofc] - 输入、输出、遗忘和单元门的 W 偏置向量
Rb[iofc] - 输入、输出、遗忘和单元门的 R 偏置向量
P[iof] - 输入、输出和遗忘门的 P 窥孔权重向量
WB[iofc] - 反向输入、输出、遗忘和单元门的 W 参数权重矩阵
RB[iofc] - 反向输入、输出、遗忘和单元门的 R 循环权重矩阵
WBb[iofc] - 反向输入、输出、遗忘和单元门的 W 偏置向量
RBb[iofc] - 反向输入、输出、遗忘和单元门的 R 偏置向量
PB[iof] - 反向输入、输出和遗忘门的 P 窥孔权重向量
H - 隐藏状态
num_directions - 如果 direction == bidirectional 则为 2，否则为 1

激活函数

Relu(x) - max(0, x)
Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x})
Sigmoid(x) - 1/(1 + e^{-x})

注意: 以下是可选的

Affine(x) - alpha*x + beta
LeakyRelu(x) - x (如果 x >= 0) 否则 alpha * x
ThresholdedRelu(x) - x (如果 x >= alpha) 否则 0
ScaledTanh(x) - alphaTanh(betax)
HardSigmoid(x) - min(max(alpha*x + beta, 0), 1)
Elu(x) - x if x >= 0 else alpha*(e^x - 1)
Softsign(x) - x/(1 + x )
Softplus(x) - log(1 + e^x)

方程 (默认: f=Sigmoid, g=Tanh, h=Tanh)

it = f(Xt(Wi^T) + Ht-1(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
ft = f(Xt(Wf^T) + Ht-1(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
ct = g(Xt(Wc^T) + Ht-1(Rc^T) + Wbc + Rbc)
Ct = ft (.) Ct-1 + it (.) ct
ot = f(Xt(Wo^T) + Ht-1(Ro^T) + Po (.) Ct + Wbo + Rbo)
Ht = ot (.) h(Ct) 此运算符具有可选输入/输出。有关可选参数表示的更多详情，请查阅文档。可以使用空字符串代替实际参数名称来表示缺失参数。末尾的可选参数（后跟的参数不存在的）也可以简单地省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`activation_alpha`	::mlir::ArrayAttr	32位浮点数组属性
`activation_beta`	::mlir::ArrayAttr	32位浮点数组属性
`activations`	::mlir::ArrayAttr	字符串数组属性
`clip`	::mlir::FloatAttr	32位浮点属性
`direction`	::mlir::StringAttr	字符串属性
`hidden_size`	::mlir::IntegerAttr	64位有符号整数属性
`input_forget`	::mlir::IntegerAttr	64位有符号整数属性
`layout`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`R`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`sequence_lens`	32位整型值的张量或none类型
`initial_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`initial_c`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`P`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`Y_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`Y_c`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

`onnx.LabelEncoder` (ONNXLabelEncoderOp)

ONNX LabelEncoder 操作

将输入张量中的每个元素映射到另一个值。
映射由两个并行属性“keys_”和“values_”决定。指定的“keys_”属性中的第 i 个值将映射到指定的“values_”属性中的第 i 个值。这意味着输入元素类型和指定的“keys_”的元素类型应相同，而输出类型与指定的“values_”属性相同。如果在指定的“keys_”属性中找不到输入元素，则可以使用与指定的“values_”属性匹配的“default_”作为其输出值。
考虑一个将字符串张量映射到整数张量的示例。假设“keys_strings”为 ["Amy", "Sally"]，“values_int64s”为 [5, 6]，“default_int64”为 ‘-1’。输入 ["Dori", "Amy", "Amy", "Sally", "Sally"] 将被映射到 [-1, 5, 5, 6, 6]。
由于此运算符是一对一映射，因此其输入和输出形状相同。请注意，“keys_”/“values_”只能设置一个。
对于键查找，使用按位比较，因此即使是浮点 NaN 也可以映射到“values_”属性中的值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`default_float`	::mlir::FloatAttr	32位浮点属性
`default_int64`	::mlir::IntegerAttr	64位有符号整数属性
`default_string`	::mlir::StringAttr	字符串属性
`keys_floats`	::mlir::ArrayAttr	32位浮点数组属性
`keys_int64s`	::mlir::ArrayAttr	64位整型数组属性
`keys_strings`	::mlir::ArrayAttr	字符串数组属性
`values_floats`	::mlir::ArrayAttr	32位浮点数组属性
`values_int64s`	::mlir::ArrayAttr	64位整型数组属性
`values_strings`	::mlir::ArrayAttr	字符串数组属性

操作数

操作数	描述
`X`	字符串类型值张量或 64 位整数值张量或 32 位浮点值张量

结果

结果	描述
`Y`	字符串类型值张量或 64 位整数值张量或 32 位浮点值张量

`onnx.LayerNormalization` (ONNXLayerNormalizationOp)

ONNX LayerNormalization 操作

这是 ONNX 中作为函数定义的层归一化。整体计算可以分为两个阶段。第一阶段是标准化，使归一化后的元素具有零均值和单位方差。标准化所需的计算可以使用以下方程描述。 Mean = ReduceMean<axes=normalized_axes>(X) D = Sub(X, Mean) DD = Mul(D, D) Var = ReduceMean<axes=normalized_axes>(DD) VarEps = Add(Var, epsilon) StdDev = Sqrt(VarEps) InvStdDev = Reciprocal(StdDev) Normalized = Mul(D, InvStdDev) 其中 normalized_axes 是 [axis, ..., rank of X - 1]。变量 Var 和 StdDev 分别代表方差和标准差。第二个输出是 Mean，最后一个是 InvStdDev。根据 stash_type 属性，实际计算必须以不同的浮点精度进行。例如，如果 stash_type 为 1，此运算符将所有输入变量转换为 32 位浮点数，执行计算，最后将 Normalized 转换回 X 的原始类型。第二阶段然后使用 NormalizedScaled = Mul(Normalized, Scale) Y = Add(NormalizedScaled, B) 对第一阶段的结果进行缩放和偏移。第二阶段不依赖于 stash_type。所有方程都使用此语法。在上述方程和此运算符定义中，同一变量（即输入、输出和属性）使用相同的名称。令 d[i] 表示 X 的第 i 个维度。如果 X 的形状为 [d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]，则 Mean 和 InvStdDev 的形状为 [d[0], ..., d[axis-1], 1, ..., 1]。Y 和 X 具有相同的形状。此运算符支持单向广播（张量 Scale 和 B 应能单向广播到张量 X）；更多详情请查阅文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`epsilon`	::mlir::FloatAttr	32位浮点属性
`stash_type`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`Scale`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`Mean`	32 位浮点值张量或 bfloat16 类型值张量或 none 类型
`InvStdDev`	32 位浮点值张量或 bfloat16 类型值张量或 none 类型

`onnx.LayoutTransform` (ONNXLayoutTransformOp)

在不同布局格式之间转换数据的操作

将张量从一种布局转换为另一种布局的操作。布局由属性 target_layout 定义，这使得此操作可以与任意布局（例如用于加速器的布局）一起使用。

target_layout 是可选的。如果未给出，输入张量将被转换为不具有布局的普通张量。

如果 target_layout 与输入布局相同，此操作将通过规范化成为空操作。

输入和输出张量必须具有相同的形状。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`target_layout`	::mlir::Attribute	layout attribute

操作数

操作数	描述
`数据`	16 位浮点或 32 位浮点值张量

结果

结果	描述
`输出`	16 位浮点或 32 位浮点值张量

`onnx.LeakyRelu` (ONNXLeakyReluOp)

ONNX LeakyRelu 操作

LeakyRelu 接受输入数据（张量）和一个参数 alpha，并生成一个输出数据（张量），其中函数 `f(x) = alpha * x (当 x < 0)`，`f(x) = x (当 x >= 0)` 按元素应用于数据张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Less` (ONNXLessOp)

ONNX Less 操作

返回对输入张量 A 和 B 按元素执行 less 逻辑运算（支持 Numpy 风格的广播）所得的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.LessOrEqual` (ONNXLessOrEqualOp)

ONNX LessOrEqual 操作

返回对输入张量 A 和 B 按元素执行 less_equal 逻辑运算（支持 Numpy 风格的广播）所得的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.LinearClassifier` (ONNXLinearClassifierOp)

ONNX LinearClassifier 操作

线性分类器

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`classlabels_ints`	::mlir::ArrayAttr	64位整型数组属性
`classlabels_strings`	::mlir::ArrayAttr	字符串数组属性
`coefficients`	::mlir::ArrayAttr	32位浮点数组属性
`intercepts`	::mlir::ArrayAttr	32位浮点数组属性
`multi_class`	::mlir::IntegerAttr	64位有符号整数属性
`post_transform`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	字符串类型值的张量或64位整型值的张量
`Z`	32位浮点数值的张量

`onnx.LinearRegressor` (ONNXLinearRegressorOp)

ONNX LinearRegressor 操作

广义线性回归评估。
如果 targets 设置为 1（默认），则执行单变量回归。
如果 targets 设置为 M，则必须传入 M 组系数作为一个序列，并且对于 N 中的每个输入 n 将输出 M 个结果。
系数数组的长度为 n，每个目标的系数是连续的。截距是可选的，但如果提供，必须与目标的数量匹配。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`coefficients`	::mlir::ArrayAttr	32位浮点数组属性
`intercepts`	::mlir::ArrayAttr	32位浮点数组属性
`post_transform`	::mlir::StringAttr	字符串属性
`targets`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Log` (ONNXLogOp)

ONNX Log 操作

按元素计算给定输入张量的自然对数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.LogSoftmax` (ONNXLogSoftmaxOp)

ONNX LogSoftmax 操作

运算符计算给定输入的 softmax 值的对数

LogSoftmax(input, axis) = Log(Softmax(input, axis=axis))

“axis”属性指示将执行 LogSoftmax 的维度。输出张量具有相同的形状，并包含相应输入的 LogSoftmax 值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Loop` (ONNXLoopOp)

ONNX Loop 操作

通用循环构造。此循环有多个终止条件：

1) 循环次数（Trip count）。运行时指定的迭代次数。通过指定输入 M 设置。可选。设置为空字符串表示省略。请注意，静态循环次数（在图构建时指定）可以通过为输入 M 传入一个常量节点来指定。2) 循环终止条件。这是运算符的一个输入，它决定是否运行第一次迭代，也是主体图的循环携带依赖项。无论是否提供此输入，主体图都必须为条件变量生成一个值。

此表总结了此运算符的操作模式及其等效的 C 风格代码

运算符输入定义为 (max_trip_count, condition_var)。

输入 ("", ""): for (int i=0; ; ++i) { cond = … // 注意此值被忽略，但在主体中是必需的 }
输入 ("", cond) // 注意这类似于 while 循环 bool cond = …; for (int i=0; cond; ++i) { cond = …; }
输入 ("", 1) // 注意这类似于 do-while 循环 bool cond = true for (int i=0; cond; ++i) { cond = …; }
输入 (trip_count, "") // 注意这类似于 for 循环 int trip_count = … for (int i=0; i < trip_count; ++i) { cond = …; // 忽略 }
输入 (trip_count, cond) int trip_count = …; bool cond = …; for (int i=0; i < trip_count && cond; ++i) { cond = …; }

用法示例 - 条件和循环次数

graph predict-net {
  %a = Constant[value = <Scalar Tensor [3]>]()
  %b = Constant[value = <Scalar Tensor [6]>]()
  %keepgoing = Constant[value = <Scalar Tensor [1]>]()
  %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
  %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
  return
}

graph body-net (
  %i[INT32, scalar]           // iteration number
  %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
  %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
) {
  %my_local = Add(%a, %b_in)
  %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
  %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
  %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
  return %keepgoing_out, %b_out, %user_defined_val
}

等效 C 代码示例

{
  /* User-defined code (enclosing scope) */
  int a = 3, b = 6;
  bool keepgoing = true; // Analogous to input cond
  /* End user-defined code */

  /* Implicitly-defined code */
  const int max_trip_count = 10; // Analogous to input M
  int user_defined_vals[]; // Imagine this is resizable
  /* End implicitly-defined code */
  /* initialize loop-carried variables and scan-output variables */
  bool keepgoing_out = keepgoing
  int b_out = b

  for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
    /* Implicitly-defined code: bind actual parameter values
       to formal parameter variables of loop-body */
    bool keepgoing_in = keepgoing_out;
    bool b_in = b_out;

    /* User-defined code (loop body) */
    int my_local = a + b_in; // Reading value \"a\" from the enclosing scope is fine
    b_out = a - b_in;
    keepgoing_out = my_local > b_out;
    user_defined_val = b_in + b_in; // b_in and b_out are different variables
    /* End user-defined code */

    /* Implicitly defined-code */
    user_defined_vals[i] = user_defined_val // accumulate scan-output values
  }
  // int t = my_local; // Can't do this. my_local is not accessible here.

  // The values below are bound to the output variables of the loop and therefore accessible
  // b_out; user_defined_vals; keepgoing_out;
}

此代码片段有几点值得注意：

1) 来自外部作用域的值（即此处的变量“a”）在作用域内，可以在循环的输入中引用。2) 在循环主体中计算的、需要在后续迭代或循环结束后使用的任何值，使用主体图中的一对变量建模，包括一个输入变量（例如 b_in）和一个输出变量（例如 b_out）。这些被称为循环携带依赖项。循环操作节点提供第一次迭代的输入变量值，并返回最终迭代产生的输出变量的输出值。3) Scan_output 变量用于隐式拼接跨所有迭代计算的值。在上述示例中，跨所有迭代计算的 user_defined_val 值被拼接，并在循环后作为 user_defined_vals 的值返回。4) 在主体中创建的值不能在外部作用域中访问，除非使用上述机制。

请注意，此操作的语义支持“对角线”或“波前”执行。（有关示例，请参阅此处第 3 步：https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/）。前端应将多层 RNN 发出一系列 While 运算符（时间是内部循环维度），每个后续层消耗前一层的 scan_outputs，可能经过多个逐点运算符（例如 dropout、残差连接、线性层）。

子图（由循环节点生成）的输入/输出匹配基于顺序而不是名称。实现将根据此顺序确定名称。

特性: AlwaysSpeculatableImplTrait

接口：ConditionallySpeculatable, HasOnnxSubgraphOpInterface, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`M`	64位整型值的张量或none类型
`cond`	1位整型值的张量或none类型
`v_initial`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 f8E4M3FN 类型值张量或 f8E4M3FNUZ 类型值张量或 f8E5M2 类型值张量或 f8E5M2FNUZ 类型值张量或 4 位无符号整数值张量或 4 位整数值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 bfloat16 类型值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量或 f8E4M3FN 类型值序列类型张量或 f8E4M3FNUZ 类型值序列类型张量或 f8E5M2 类型值序列类型张量或 f8E5M2FNUZ 类型值序列类型张量或 4 位无符号整数值序列类型张量或 4 位整数值序列类型张量或 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 bfloat16 类型值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 bfloat16 类型值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量或 f8E4M3FN 类型值可选类型张量或 f8E4M3FNUZ 类型值可选类型张量或 f8E5M2 类型值可选类型张量或 f8E5M2FNUZ 类型值可选类型张量或 4 位无符号整数值可选类型张量或 4 位整数值可选类型张量

结果

结果描述

v_final_and_scan_outputs 可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 f8E4M3FN 类型值张量或 f8E4M3FNUZ 类型值张量或 f8E5M2 类型值张量或 f8E5M2FNUZ 类型值张量或 4 位无符号整数值张量或 4 位整数值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 bfloat16 类型值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量或 f8E4M3FN 类型值序列类型张量或 f8E4M3FNUZ 类型值序列类型张量或 f8E5M2 类型值序列类型张量或 f8E5M2FNUZ 类型值序列类型张量或 4 位无符号整数值序列类型张量或 4 位整数值序列类型张量或 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 bfloat16 类型值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 bfloat16 类型值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量或 f8E4M3FN 类型值可选类型张量或 f8E4M3FNUZ 类型值可选类型张量或 f8E5M2 类型值可选类型张量或 f8E5M2FNUZ 类型值可选类型张量或 4 位无符号整数值可选类型张量或 4 位整数值可选类型张量

`onnx.LpNormalization` (ONNXLpNormalizationOp)

ONNX LpNormalization 操作

给定矩阵，沿提供的轴应用 Lp 范数归一化。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`p`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.LpPool` (ONNXLpPoolOp)

ONNX LpPool 操作

LpPool 接受输入张量 X，并根据核心尺寸、步长尺寸和填充长度对张量应用 Lp 范数池化。Lp 范数池化包括根据核心尺寸计算输入张量子集所有值的 Lp 范数，并将数据下采样到输出张量 Y 以进行进一步处理。输出空间形状如下所示：

 output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)

或

 output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)

如果启用了 ceil_mode，pad_shape[i] 是沿轴 i 的填充总和。

auto_pad 是一个已弃用的属性。如果您目前正在使用它们，输出空间形状将如下所示：

 VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
 SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])

并且如果 SAME_UPPER 或 SAME_LOWER，填充形状将如下所示

 pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`ceil_mode`	::mlir::IntegerAttr	64位有符号整数属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`p`	::mlir::IntegerAttr	64位有符号整数属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.MatMulInteger` (ONNXMatMulIntegerOp)

ONNX MatMulInteger 操作

行为类似于 numpy.matmul 的矩阵乘积。乘法结果绝不能溢出。累加可能仅在 32 位时溢出。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位整型值的张量或8位无符号整型值的张量
`B`	8位整型值的张量或8位无符号整型值的张量
`a_zero_point`	8位整型值的张量或8位无符号整型值的张量或none类型
`b_zero_point`	8位整型值的张量或8位无符号整型值的张量或none类型

结果

结果	描述
`Y`	32位整型值的张量

`onnx.MatMul` (ONNXMatMulOp)

ONNX MatMul 操作

行为类似于 numpy.matmul 的矩阵乘积。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量
`B`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量

结果

结果	描述
`Y`	16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 32 位整数值张量或 64 位整数值张量或 bfloat16 类型值张量

`onnx.Max` (ONNXMaxOp)

ONNX Max 操作

对每个输入张量按元素取最大值（支持 Numpy 风格的广播）。所有输入和输出必须具有相同的数据类型。此运算符支持多方向（即 Numpy 风格）广播；更多详情请查阅文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`data_0`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`max`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.MaxPool` (ONNXMaxPoolOp)

ONNX MaxPool 操作

MaxPool 接受输入张量 X，并根据核心尺寸、步长尺寸和填充长度对张量应用最大池化。最大池化包括根据核心尺寸计算输入张量子集所有值的最大值，并将数据下采样到输出张量 Y 以进行进一步处理。输出空间形状的计算方式取决于使用的是显式填充（使用 pads）还是自动填充（使用 auto_pad）。使用显式填充 (https://pytorch.ac.cn/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d)

 output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

或

 output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

如果启用了 ceil_mode。pad_shape[i] 是沿轴 i 的填充总和。从右侧填充区域开始的滑动窗口将被忽略。

auto_pad 是一个已弃用的属性。如果您当前正在使用它们，当启用 ceil_mode 时，输出空间形状将如下所示

 VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
 SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])

或禁用 ceil_mode 时 (https://tensorflowcn.cn/api_docs/python/tf/keras/layers/AveragePooling2D)

 VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
 SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1

并且如果 SAME_UPPER 或 SAME_LOWER，填充形状将如下所示

 pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]

每个池化窗口的输出是排除填充后的最大元素数量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`ceil_mode`	::mlir::IntegerAttr	64位有符号整数属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`storage_order`	::mlir::IntegerAttr	64位有符号整数属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 8 位整数值张量或 8 位无符号整数值张量

结果

结果	描述
`Y`	bfloat16 类型值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 8 位整数值张量或 8 位无符号整数值张量
`Indices`	64位整型值的张量或none类型

`onnx.MaxPoolSingleOut` (ONNXMaxPoolSingleOutOp)

具有单个输出的 ONNX MaxPool 操作。

具有单个输出的 ONNX MaxPool 操作。有关 MaxPool 语义的完整描述，请参阅 ONNXMaxPoolOp。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`ceil_mode`	::mlir::IntegerAttr	64位有符号整数属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`storage_order`	::mlir::IntegerAttr	64位有符号整数属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	任意类型值的 memref 或任意类型值的张量

结果

结果	描述
`o_Y`	任意类型值的 memref 或任意类型值的张量

`onnx.MaxRoiPool` (ONNXMaxRoiPoolOp)

ONNX MaxRoiPool 操作

ROI 最大池化接受输入张量 X 和感兴趣区域 (RoIs)，并对每个 RoI 应用最大池化，以生成形状为 (num_rois, channels, pooled_shape[0], pooled_shape[1]) 的 4 维输出张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`pooled_shape`	::mlir::ArrayAttr	64位整型数组属性
`spatial_scale`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`rois`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.MaxUnpool` (ONNXMaxUnpoolOp)

ONNX MaxUnpool 操作

MaxUnpool 本质上计算 MaxPool 操作的部分逆运算。此操作的输入信息通常是 MaxPool 操作的输出信息。第一个输入张量 X 是需要反池化的张量，通常是 MaxPool 的池化张量（第一个输出）。第二个输入张量 I 包含指向与第一个输入张量 X 中的元素相对应的（局部最大）元素的索引。输入张量 I 通常是 MaxPool 操作的第二个输出。第三个（可选）输入是指定反池化操作输出尺寸的张量。

MaxUnpool 旨在进行 MaxPool 操作的“部分”逆运算。“部分”是因为 MaxPool 原始输入中所有非最大值在 MaxUnpool 操作的输出中被设置为零。对反池化操作的结果进行池化应该会返回反池化操作的原始输入。

MaxUnpool 可以为几个输入尺寸产生相同的输出尺寸，这使得反池化操作具有歧义性。第三个输入参数 output_size 用于消除操作的歧义，并生成已知/可预测尺寸的输出张量。

除了输入之外，MaxUnpool 还接受三个属性，即 kernel_shape、strides 和 pads，它们定义了精确的反池化操作。这些属性通常与反池化操作试图反转的相应池化操作具有相同的值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`I`	64位整型值的张量
`output_shape`	64位整型值的张量或none类型

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Mean` (ONNXMeanOp)

ONNX Mean 操作

对每个输入张量按元素取平均值（支持 Numpy 风格的广播）。所有输入和输出必须具有相同的数据类型。此运算符支持多方向（即 Numpy 风格）广播；更多详情请查阅文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`data_0`	可变数量的 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`mean`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.MeanVarianceNormalization` (ONNXMeanVarianceNormalizationOp)

ONNX MeanVarianceNormalization 操作

均值方差归一化函数：使用公式 (X-EX)/sqrt(E(X-EX)^2) 对输入张量 X 执行均值方差归一化。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.MelWeightMatrix` (ONNXMelWeightMatrixOp)

ONNX MelWeightMatrix 操作

生成一个 Mel 权重矩阵，该矩阵可用于将包含线性采样频率谱（来自 DFT 或 STFT）的张量，根据梅尔尺度上的 [lower_edge_hertz, upper_edge_hertz] 范围重新加权为 num_mel_bins 频率信息。此函数根据以下公式定义以赫兹为单位的频率表示的梅尔尺度：

mel(f) = 2595 * log10(1 + f/700)

在返回的矩阵中，所有三角形（滤波器组）的峰值都为 1.0。

返回的 MelWeightMatrix 可用于右乘一个线性尺度频谱值（例如 STFT 幅度）的频谱图 S（形状为 [frames, num_spectrogram_bins]），以生成形状为 [frames, num_mel_bins] 的“梅尔频谱图” M。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`output_datatype`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`num_mel_bins`	32位整型值的张量或64位整型值的张量
`dft_length`	32位整型值的张量或64位整型值的张量
`sample_rate`	32位整型值的张量或64位整型值的张量
`lower_edge_hertz`	32 位浮点值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量
`upper_edge_hertz`	32 位浮点值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Min` (ONNXMinOp)

ONNX Min 操作

对每个输入张量按元素取最小值（支持 Numpy 风格的广播）。所有输入和输出必须具有相同的数据类型。此运算符支持多方向（即 Numpy 风格）广播；更多详情请查阅文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`data_0`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`min`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Mish` (ONNXMishOp)

ONNX Mish 操作

Mish：一种自正则化的非单调神经激活函数。

使用公式按元素对输入张量 X 执行线性单元函数

mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x}))

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Mod` (ONNXModOp)

ONNX Mod 操作

执行按元素的二元模运算（支持 Numpy 风格的广播）。余数的符号与除数相同。

Mod 运算符也可以表现得像 C 的 fmod() 或 numpy.fmod。在这种情况下，余数的符号将与被除数相同（与整数模相反）。为了强制执行类似 numpy.fmod() 的行为，提供了“fmod”属性。此属性默认设置为 0，导致行为类似于整数模。将此属性设置为 1 会导致余数计算类似于 numpy.fmod()。

如果输入类型是浮点型，则 fmod 属性必须设置为 1。

如果被除数为零，结果将取决于平台。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`fmod`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Momentum` (ONNXMomentumOp)

ONNX Momentum 操作

计算一次带有动量的随机梯度更新迭代。此运算符可以对多个张量变量进行优化。

Let's define the behavior of this operator. As you can imagine, SG with momentum requires
several parameters:

 - The learning-rate \"R\".
 - The update count \"T\". That is, the number of conducted training iterations. It should
   be zero in the first training iteration.
 - A L2-norm regularization coefficient \"norm_coefficient\".
 - A decay coefficient of previous accumulated gradient (i.e., momentum) \"alpha\".
 - The scaling coefficient of current gradient \"beta\".
 - An attribute to choose either standard momentum or Nesterov's momentum \"mode\" should
   be used.

For the sake of simplicity, assume that there is only one tensor (called \"X\") to be optimized.
Other necessary inputs are \"X\"'s gradient (called \"G\") and \"X\"'s momentum (called \"V\"). This
Momentum operator maps all these inputs to the new value of \"X\" (called \"X_new\") and its new
momentum (called \"V_new\").

This operator supports two different momentum algorithms. Set the attribute \"mode\" to
\"nesterov\" if Nesterov's momentum is desired. Otherwise, set the attribute \"model\" to
\"standard\" to use standard momentum. Computation details are described subsequently.

Let \"+\", \"-\", \"*\", and \"/\" are all element-wise operations with numpy-style broadcasting.

Pseudo code for SG with standard momentum:

  // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
  // values of all elements in X.
  G_regularized = norm_coefficient * X + G

  // In the first training iteration, beta should always be 1.
  beta_adjusted = T > 0 ? beta : 1

  // Compute the current momentum based on previous momentum and the current gradient.
  V_new = alpha * V + beta_adjusted * G_regularized

  // Update X.
  X_new = X - R * V_new

Pseudo code for SG with Nesterov's momentum:

  // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
  // values of all elements in X.
  G_regularized = norm_coefficient * X + G;

  // In the first training iteration, beta should always be 1.
  beta_adjusted = T > 0 ? beta : 1

  // Compute the current momentum based on previous momentum and the current gradient.
  V_new = alpha * V + beta_adjusted * G_regularized;

  // Compute final update direction and then update X.
  X_new = X - R * (G_regularized + alpha * V_new)

If one assign this operators to optimize multiple inputs, for example, \"X_1\" and \"X_2\". The same
pseudo code would be extended to handle all tensors jointly. More specifically, we can view \"X\" as a
concatenation of \"X_1\" and \"X_2\" (of course, their gradient and accumulate gradient should
be concatenated too) and then our pseudo code becomes applicable.

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`beta`	::mlir::FloatAttr	32位浮点属性
`mode`	::mlir::StringAttr	字符串属性
`norm_coefficient`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`R`	32位浮点数值的张量或64位浮点数值的张量
`T`	64位整型值的张量
`输入`	可变数量的32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	可变数量的32位浮点数值的张量或64位浮点数值的张量

`onnx.Mul` (ONNXMulOp)

ONNX Mul 操作

执行按元素的二元乘法（支持 Numpy 风格的广播）。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

(Opset 14 变更): 扩展支持的类型，包含 uint8, int8, uint16 和 int16。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Multinomial` (ONNXMultinomialOp)

ONNX Multinomial 操作

根据每个可能结果的概率，从多项分布中生成样本张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`sample_size`	::mlir::IntegerAttr	64位有符号整数属性
`seed`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	32位整型值的张量或64位整型值的张量

`onnx.Neg` (ONNXNegOp)

ONNX Neg 操作

Neg 接受一个输入数据（张量) 并产生一个输出数据 (张量），并对张量按元素应用每个元素符号取反的运算，y = -x。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	32 位浮点值张量或 32 位整数值张量或 8 位整数值张量或 16 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`Y`	32 位浮点值张量或 32 位整数值张量或 8 位整数值张量或 16 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

`onnx.NegativeLogLikelihoodLoss` (ONNXNegativeLogLikelihoodLossOp)

ONNX NegativeLogLikelihoodLoss 操作

NegativeLogLikelihoodLoss 运算符计算（加权的）负对数似然损失。其“input”张量的形状为 (N, C, d1, d2, …, dk)，其中 k >= 0。“input”张量包含 input[n, :, d_1, d_2,…, d_k] 属于类别 [0, C) 的对数概率。运算符的“target”输入张量的形状为 (N, d1, d2, …, dk)。它编码类别标签（C 个类别之一），或者对于 N x d1 x d2 x … x dk 个样本可能包含特殊值（由属性 ignore_index 指示）。对于 input[n, :, d_1, d_2,…d_k] 被归类为类别 c = target[n][d_1][d_2]…[d_k] 的损失值计算为

loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].

当提供可选的“weight”时，样本损失计算为

loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].

当 target 值等于 ignore_index 时，损失为零。

loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index

如果“reduction”属性设置为“none”，则运算符的输出将是上述损失，形状为 (N, d1, d2, …, dk)。如果“reduction”属性设置为“mean”（默认属性值），则输出损失是（加权）平均值

mean(loss), if \"weight\" is not provided,

或者如果提供了 weight，则为

sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.

如果“reduction”属性设置为“sum”，则输出是标量：sum(loss)。

另请参阅 https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.NLLLoss。

示例 1

// negative log likelihood loss, \"none\" reduction
N, C, d1 = 2, 3, 2
input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
target = [[2, 1], [0, 2]]

loss = np.zeros((N, d1))
for n in range(N):
    for d_1 in range(d1):
        c = target[n][d_1]
        loss[n][d_1] = -input[n][c][d_1]

// print(loss)
// [[-3. -2.]
//  [-0. -2.]]

示例 2

// weighted negative log likelihood loss, sum reduction
N, C, d1 = 2, 3, 2
input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
        [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
target = [[2, 1], [0, 2]]
weight = [0.2, 0.3, 0.1]
loss = np.zeros((N, d1))
for n in range(N):
    for d_1 in range(d1):
        c = target[n][d_1]
        loss[n][d_1] = -input[n][c][d_1] * weight[c]

loss = np.sum(loss)
// print(loss)
// -1.1

示例 3

// weighted negative log likelihood loss, mean reduction
N, C, d1 = 2, 3, 2
input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
        [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
target = [[2, 1], [0, 2]]
weight = [0.2, 0.3, 0.1]
loss = np.zeros((N, d1))
weight_total = 0
for n in range(N):
    for d_1 in range(d1):
        c = target[n][d_1]
        loss[n][d_1] = -input[n][c][d_1] * weight[c]
        weight_total = weight_total + weight[c]

loss = np.sum(loss) / weight_total
// print(loss)
// -1.57

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`ignore_index`	::mlir::IntegerAttr	64位有符号整数属性
`reduction`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`target`	32位整型值的张量或64位整型值的张量
`weight`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`loss`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.NonMaxSuppression` (ONNXNonMaxSuppressionOp)

ONNX NonMaxSuppression 操作

过滤掉与先前选择的边界框具有高交并比 (IOU) 重叠的边界框。分数低于 score_threshold 的边界框将被移除。边界框格式由属性 center_point_box 指示。请注意，此算法与坐标系中的原点位置无关，更一般地说，对坐标系的正交变换和平移是不变的；因此，坐标系的平移或反射会导致算法选择相同的边界框。selected_indices 输出是一组整数，索引到输入边界框集合中，代表所选边界框。然后可以使用 Gather 或 GatherND 操作获取与所选索引对应的边界框坐标。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`center_point_box`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`boxes`	32位浮点数值的张量
`scores`	32位浮点数值的张量
`max_output_boxes_per_class`	64位整型值的张量或none类型
`iou_threshold`	32 位浮点值张量或 none 类型
`score_threshold`	32 位浮点值张量或 none 类型

结果

结果	描述
`selected_indices`	64位整型值的张量

`onnx.NonZero` (ONNXNonZeroOp)

ONNX NonZero 操作

返回非零元素的索引（按行主序 - 按维度）。NonZero 的行为类似于 numpy.nonzero：https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.nonzero.html，但对于标量输入，NonZero 生成形状 (0, N) 而不是 (1, N)，这与 Numpy 的行为不同。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`Y`	64位整型值的张量

`onnx.NoValue` (ONNXNoneOp)

表示值不存在的操作。

此操作可用于表示值不存在。它通常用作具有可选参数的运算符的参数。

示例

  %cst = "onnx.NoValue"() {value} : () -> none
  %0, %1 = "onnx.Split"(%arg0, %cst) { axis=1 : si64 } : (tensor<?xf32>, none) -> (tensor<*xf32>, tensor<*xf32>)

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait, ConstantLike

接口：ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`value`	::mlir::UnitAttr	unit attribute

结果

结果	描述
`none_val`	none 类型

`onnx.Normalizer` (ONNXNormalizerOp)

ONNX Normalizer 操作

归一化输入。有三种归一化模式，它们具有相应的公式，使用按元素的缀运算符“/”和“^”以及张量范围函数“max”和“sum”定义：

Max: Y = X / max(X)
L1: Y = X / sum(X)
L2: Y = sqrt(X^2 / sum(X^2))
在所有模式下，如果除数为零，则 Y == X。
对于批量，即 [N,C] 张量，沿 C 轴进行归一化。换句话说，批量的每一行都独立进行归一化。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`norm`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Not` (ONNXNotOp)

ONNX Not 操作

按元素返回输入张量的取反结果。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	1位整型值的张量

结果

结果	描述
`Y`	1位整型值的张量

`onnx.OneHotEncoder` (ONNXOneHotEncoderOp)

ONNX OneHotEncoder 操作

将每个输入元素替换为由一和零组成的数组，其中单个一放置在传入类别的索引处。总类别数将确定输出数组 Y 的额外维度的尺寸。
例如，如果我们传入一个值为 4 的单值张量，且类别数为 8，则输出将是一个张量，其值为 [0,0,0,0,1,0,0,0]。
此运算符假定每个输入特征来自同一类别集。
如果输入是浮点、int32 或 double 类型的张量，则数据将被转换为整数，并且 cats_int64s 类别列表将用于查找。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`cats_int64s`	::mlir::ArrayAttr	64位整型数组属性
`cats_strings`	::mlir::ArrayAttr	字符串数组属性
`zeros`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	字符串类型值张量或 64 位整数值张量或 32 位整数值张量或 32 位浮点值张量或 64 位浮点值张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.OneHot` (ONNXOneHotOp)

ONNX OneHot 操作

根据输入生成独热张量。‘indices’ 输入张量中索引值表示的位置将具有 ‘on_value’，其他位置将具有 ‘off_value’，其中 ‘on_value’ 和 ‘off_value’ 作为必需输入参数 ‘values’ 的一部分指定，‘values’ 是一个格式为 [off_value, on_value] 的双元素张量。输出张量的秩将比输入张量的秩大一。额外的维度用于独热表示。额外的维度将插入到 ‘axis’ 指定的位置。如果未指定 ‘axis’，则额外的维度将作为最内层维度插入，即 axis=-1。额外维度的尺寸由必需标量输入 ‘depth’ 指定。输出张量的类型与 ‘values’ 输入的类型相同。‘indices’ 输入张量中值超出范围 [-depth, depth-1] 的任何条目将导致输出张量中所有值为 ‘off_value’ 的独热表示。

when axis = 0:
output[input[i, j, k], i, j, k] = 1 for all i, j, k and 0 otherwise.

when axis = -1:
output[i, j, k, input[i, j, k]] = 1 for all i, j, k and 0 otherwise.

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`indices`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`depth`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`values`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.OptionalGetElement` (ONNXOptionalGetElementOp)

ONNX OptionalGetElement 操作

如果输入是张量或序列类型，则返回输入。如果输入是可选类型，则输出输入中的元素。如果输入是空的 optional 类型（即没有元素），则会出错，并且在此情况下行为未定义。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

输入 8 位无符号整数值可选类型序列类型张量或 16 位无符号整数值可选类型序列类型张量或 32 位无符号整数值可选类型序列类型张量或 64 位无符号整数值可选类型序列类型张量或 8 位整数值可选类型序列类型张量或 16 位整数值可选类型序列类型张量或 32 位整数值可选类型序列类型张量或 64 位整数值可选类型序列类型张量或 16 位浮点值可选类型序列类型张量或 32 位浮点值可选类型序列类型张量或 64 位浮点值可选类型序列类型张量或字符串类型值可选类型序列类型张量或 1 位整数值可选类型序列类型张量或元素为 32 位浮点数的复数类型值可选类型序列类型张量或元素为 64 位浮点数的复数类型值可选类型序列类型张量或 8 位无符号整数值可选类型张量或 16 位无符号整数值可选类型张量或 32 位无符号整数值可选类型张量或 64 位无符号整数值可选类型张量或 8 位整数值可选类型张量或 16 位整数值可选类型张量或 32 位整数值可选类型张量或 64 位整数值可选类型张量或 16 位浮点值可选类型张量或 32 位浮点值可选类型张量或 64 位浮点值可选类型张量或字符串类型值可选类型张量或 1 位整数值可选类型张量或元素为 32 位浮点数的复数类型值可选类型张量或元素为 64 位浮点数的复数类型值可选类型张量或 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量或 8 位无符号整数值序列类型张量或 16 位无符号整数值序列类型张量或 32 位无符号整数值序列类型张量或 64 位无符号整数值序列类型张量或 8 位整数值序列类型张量或 16 位整数值序列类型张量或 32 位整数值序列类型张量或 64 位整数值序列类型张量或 16 位浮点值序列类型张量或 32 位浮点值序列类型张量或 64 位浮点值序列类型张量或字符串类型值序列类型张量或 1 位整数值序列类型张量或元素为 32 位浮点数的复数类型值序列类型张量或元素为 64 位浮点数的复数类型值序列类型张量

结果

结果描述

输出 8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或16位浮点型值张量的序列类型值或32位浮点型值张量的序列类型值或64位浮点型值张量的序列类型值或字符串类型值张量的序列类型值或1位无符号整型值张量的序列类型值或包含32位浮点元素值的复数类型张量的序列类型值或包含64位浮点元素值的复数类型张量的序列类型值

`onnx.OptionalHasElement` (ONNXOptionalHasElementOp)

ONNX OptionalHasElement 操作

如果 (1) 输入是可选类型且包含元素，或者 (2) 输入是张量或序列类型，则返回 true。如果未提供输入或输入为空的可选类型，则此操作返回 false。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

输入 8位无符号整型值张量序列类型的可选类型值或16位无符号整型值张量序列类型的可选类型值或32位无符号整型值张量序列类型的可选类型值或64位无符号整型值张量序列类型的可选类型值或8位无符号整型值张量序列类型的可选类型值或16位无符号整型值张量序列类型的可选类型值或32位无符号整型值张量序列类型的可选类型值或64位无符号整型值张量序列类型的可选类型值或16位浮点型值张量序列类型的可选类型值或32位浮点型值张量序列类型的可选类型值或64位浮点型值张量序列类型的可选类型值或字符串类型值张量序列类型的可选类型值或1位无符号整型值张量序列类型的可选类型值或包含32位浮点元素值的复数类型张量序列类型的可选类型值或包含64位浮点元素值的复数类型张量序列类型的可选类型值或8位无符号整型值张量的可选类型值或16位无符号整型值张量的可选类型值或32位无符号整型值张量的可选类型值或64位无符号整型值张量的可选类型值或8位无符号整型值张量的可选类型值或16位无符号整型值张量的可选类型值或32位无符号整型值张量的可选类型值或64位无符号整型值张量的可选类型值或16位浮点型值张量的可选类型值或32位浮点型值张量的可选类型值或64位浮点型值张量的可选类型值或字符串类型值张量的可选类型值或1位无符号整型值张量的可选类型值或包含32位浮点元素值的复数类型张量的可选类型值或包含64位浮点元素值的复数类型张量的可选类型值或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或16位浮点型值张量的序列类型值或32位浮点型值张量的序列类型值或64位浮点型值张量的序列类型值或字符串类型值张量的序列类型值或1位无符号整型值张量的序列类型值或包含32位浮点元素值的复数类型张量的序列类型值或包含64位浮点元素值的复数类型张量的序列类型值或None类型

结果

结果	描述
`输出`	1位整型值的张量

`onnx.Optional` (ONNXOptionalOp)

ONNX Optional 操作

构造一个可选类型的值，该值包含属性指定类型的空可选，或者包含输入元素的非空值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`类型`	::mlir::TypeAttr	任意类型属性

操作数

操作数描述

输入 8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或8位无符号整型值张量的序列类型值或16位无符号整型值张量的序列类型值或32位无符号整型值张量的序列类型值或64位无符号整型值张量的序列类型值或16位浮点型值张量的序列类型值或32位浮点型值张量的序列类型值或64位浮点型值张量的序列类型值或字符串类型值张量的序列类型值或1位无符号整型值张量的序列类型值或包含32位浮点元素值的复数类型张量的序列类型值或包含64位浮点元素值的复数类型张量的序列类型值或None类型

结果

结果描述

输出 8位无符号整型值张量序列类型的可选类型值或16位无符号整型值张量序列类型的可选类型值或32位无符号整型值张量序列类型的可选类型值或64位无符号整型值张量序列类型的可选类型值或8位无符号整型值张量序列类型的可选类型值或16位无符号整型值张量序列类型的可选类型值或32位无符号整型值张量序列类型的可选类型值或64位无符号整型值张量序列类型的可选类型值或16位浮点型值张量序列类型的可选类型值或32位浮点型值张量序列类型的可选类型值或64位浮点型值张量序列类型的可选类型值或字符串类型值张量序列类型的可选类型值或1位无符号整型值张量序列类型的可选类型值或包含32位浮点元素值的复数类型张量序列类型的可选类型值或包含64位浮点元素值的复数类型张量序列类型的可选类型值或8位无符号整型值张量的可选类型值或16位无符号整型值张量的可选类型值或32位无符号整型值张量的可选类型值或64位无符号整型值张量的可选类型值或8位无符号整型值张量的可选类型值或16位无符号整型值张量的可选类型值或32位无符号整型值张量的可选类型值或64位无符号整型值张量的可选类型值或16位浮点型值张量的可选类型值或32位浮点型值张量的可选类型值或64位浮点型值张量的可选类型值或字符串类型值张量的可选类型值或1位无符号整型值张量的可选类型值或包含32位浮点元素值的复数类型张量的可选类型值或包含64位浮点元素值的复数类型张量的可选类型值

`onnx.Or` (ONNXOrOp)

ONNX Or 操作

返回对输入张量 A 和 B 逐元素执行 or 逻辑操作（支持 Numpy 风格广播）后得到的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	1位整型值的张量
`B`	1位整型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.PRelu` (ONNXPReluOp)

ONNX PRelu 操作

PRelu 将输入数据 (张量) 和斜率张量作为输入，并生成一个输出数据 (张量)，其中函数 `f(x) = slope * x for x < 0`，`f(x) = x for x >= 0` 对数据张量逐元素应用。此操作符支持 **单向广播** (斜率张量应该可以单向广播到输入张量 X)；有关更多详细信息，请查阅 [文档](Broadcasting.md)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量
`斜率`	bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量

结果

结果	描述
`Y`	bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量

`onnx.Pad` (ONNXPadOp)

ONNX Pad 操作

给定包含要填充数据 (data) 的张量，包含每个轴的起始和结束填充值数量 (pads) 的张量，(可选) 一个 mode，以及 (可选) constant_value，将生成一个填充后的张量 (output)。

支持的四种 modes (类似于 numpy.pad 支持的相应模式)

1) constant(默认) - 使用 constant_value 指定的给定常量值填充 (默认值为 0、空字符串或 False)

2) reflect - 沿每个轴使用向量在第一个和最后一个值上镜像的反射填充

3) edge - 使用数组的边缘值填充

4) wrap - 环绕填充，就像数据张量形成一个环面一样

示例 1 (constant 模式)

在第二维的开头插入 0 填充。

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'constant'

constant_value = 0.0

output = [
    [0.0, 0.0, 1.0, 1.2],
    [0.0, 0.0, 2.3, 3.4],
    [0.0, 0.0, 4.5, 5.7],
]

示例 2 (reflect 模式)

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'reflect'

output = [
    [1.0, 1.2, 1.0, 1.2],
    [2.3, 3.4, 2.3, 3.4],
    [4.5, 5.7, 4.5, 5.7],
]

示例 3 (edge 模式)

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'edge'

output = [
    [1.0, 1.0, 1.0, 1.2],
    [2.3, 2.3, 2.3, 3.4],
    [4.5, 4.5, 4.5, 5.7],
]

示例 4 (wrap 模式)

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [2, 1, 1, 1]

mode = 'wrap'

output = [
    [3.4, 2.3, 3.4, 2.3],
    [5.7, 4.5, 5.7, 4.5],
    [1.2, 1.0, 1.2, 1.0],
    [3.4, 2.3, 3.4, 2.3],
    [5.7, 4.5, 5.7, 4.5],
    [1.2, 1.0, 1.2, 1.0],
]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量
`pads`	64位整型值的张量
`常量值`	8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或f8E4M3FN 类型值张量或f8E4M3FNUZ 类型值张量或f8E5M2 类型值张量或f8E5M2FNUZ 类型值张量或4位无符号整型值张量或4位无符号整型值张量或None类型
`axes`	32位整型值的张量或64位整型值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.PadV11` (ONNXPadV11Op)

ONNX Pad 操作

支持的四种 modes (类似于 numpy.pad 支持的相应模式)

1) constant(默认) - 使用 constant_value 指定的给定常量值填充 (默认值为 0)

2) reflect - 沿每个轴使用向量在第一个和最后一个值上镜像的反射填充

3) edge - 使用数组的边缘值填充

示例 1 (constant 模式): 在第二维的开头插入 0 填充。

data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘constant’

constant_value = 0.0

output = [ [0.0, 0.0, 1.0, 1.2], [0.0, 0.0, 2.3, 3.4], [0.0, 0.0, 4.5, 5.7], ]

示例 2 (reflect 模式): data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘reflect’

output = [ [1.0, 1.2, 1.0, 1.2], [2.3, 3.4, 2.3, 3.4], [4.5, 5.7, 4.5, 5.7], ]

示例 3 (edge 模式): data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘edge’

output = [ [1.0, 1.0, 1.0, 1.2], [2.3, 2.3, 2.3, 3.4], [4.5, 4.5, 4.5, 5.7], ]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`pads`	64位整型值的张量
`常量值`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.PadV13` (ONNXPadV13Op)

ONNX Pad 操作

支持的四种 modes (类似于 numpy.pad 支持的相应模式)

1) constant(默认) - 使用 constant_value 指定的给定常量值填充 (默认值为 0、空字符串或 False)

2) reflect - 沿每个轴使用向量在第一个和最后一个值上镜像的反射填充

3) edge - 使用数组的边缘值填充

示例 1 (constant 模式): 在第二维的开头插入 0 填充。

data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘constant’

constant_value = 0.0

output = [ [0.0, 0.0, 1.0, 1.2], [0.0, 0.0, 2.3, 3.4], [0.0, 0.0, 4.5, 5.7], ]

示例 2 (reflect 模式): data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘reflect’

output = [ [1.0, 1.2, 1.0, 1.2], [2.3, 3.4, 2.3, 3.4], [4.5, 5.7, 4.5, 5.7], ]

示例 3 (edge 模式): data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ]

pads = [0, 2, 0, 0]

mode = ‘edge’

output = [ [1.0, 1.0, 1.0, 1.2], [2.3, 2.3, 2.3, 3.4], [4.5, 4.5, 4.5, 5.7], ]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`pads`	64位整型值的张量
`常量值`	8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或None类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.PadV18` (ONNXPadV18Op)

ONNX Pad 操作

支持的四种 modes (类似于 numpy.pad 支持的相应模式)

1) constant(默认) - 使用 constant_value 指定的给定常量值填充 (默认值为 0、空字符串或 False)

2) reflect - 沿每个轴使用向量在第一个和最后一个值上镜像的反射填充

3) edge - 使用数组的边缘值填充

示例 1 (constant 模式)

在第二维的开头插入 0 填充。

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'constant'

constant_value = 0.0

output = [
    [0.0, 0.0, 1.0, 1.2],
    [0.0, 0.0, 2.3, 3.4],
    [0.0, 0.0, 4.5, 5.7],
]

示例 2 (reflect 模式)

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'reflect'

output = [
    [1.0, 1.2, 1.0, 1.2],
    [2.3, 3.4, 2.3, 3.4],
    [4.5, 5.7, 4.5, 5.7],
]

示例 3 (edge 模式)

data = [
    [1.0, 1.2],
    [2.3, 3.4],
    [4.5, 5.7],
]

pads = [0, 2, 0, 0]

mode = 'edge'

output = [
    [1.0, 1.0, 1.0, 1.2],
    [2.3, 2.3, 2.3, 3.4],
    [4.5, 4.5, 4.5, 5.7],
]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`pads`	64位整型值的张量
`常量值`	8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或None类型
`axes`	32位整型值的张量或64位整型值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.PadV2` (ONNXPadV2Op)

ONNX Pad 操作

给定 data 张量、pads、mode 和 value。示例: 在第二维的开头插入 0 填充。 data = [ [1.0, 1.2], [2.3, 3.4], [4.5, 5.7], ] pads = [0, 2, 0, 0] output = [ [ [0.0, 0.0, 1.0, 1.2], [0.0, 0.0, 2.3, 3.4], [0.0, 0.0, 4.5, 5.7], ], ]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`value`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`数据`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Pow` (ONNXPowOp)

ONNX Pow 操作

Pow 将输入数据 (张量) 和指数张量作为输入，并生成一个输出数据 (张量)，其中函数 `f(x) = x^exponent` 对数据张量逐元素应用。此操作符支持 **多向（即 Numpy 风格）广播**；有关更多详细信息，请查阅 [文档](Broadcasting.md)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Z`	32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量

`onnx.PrintSignature` (ONNXPrintSignatureOp)

用于打印输入操作数类型签名或数据的 ONNX Op

打印此操作的输入操作数的类型签名或数据。参数 op_name 指定一个在张量之前打印的字符串。通常使用 op_name 和 onnx_node_name。此操作尽早引入以保留原始 ONNX op 的名称。参数 print_data 控制是否打印张量的数据。当 print_data == 1 时，将打印张量的数据。否则，只打印形状。参数 input 指定要打印的张量。它们可以是 ONNX op 的输入和输出列表。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

属性

属性	MLIR 类型	描述
`op_name`	::mlir::StringAttr	字符串属性
`print_data`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	任意类型值的变长张量或None类型

`onnx.QLinearConv` (ONNXQLinearConvOp)

ONNX QLinearConv 操作

卷积操作符消耗量化输入张量及其比例和零点、量化滤波器及其比例和零点，以及输出的比例和零点，并计算量化输出。每个比例和零点对必须具有相同的形状。这意味着它们必须是标量 (每张量) 或 1-D 张量 (每输出通道)。每个输入或输出及其相关的零点必须具有相同的类型。当存在偏置时，必须使用 scale = input scale * weight scale 和零点为 0 进行量化。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`auto_pad`	::mlir::StringAttr	字符串属性
`dilations`	::mlir::ArrayAttr	64位整型数组属性
`group`	::mlir::IntegerAttr	64位有符号整数属性
`kernel_shape`	::mlir::ArrayAttr	64位整型数组属性
`pads`	::mlir::ArrayAttr	64位整型数组属性
`strides`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`x`	8位整型值的张量或8位无符号整型值的张量
`x_scale`	32位浮点数值的张量
`x_zero_point`	8位整型值的张量或8位无符号整型值的张量
`w`	8位整型值的张量或8位无符号整型值的张量
`w_scale`	32位浮点数值的张量
`w_zero_point`	8位整型值的张量或8位无符号整型值的张量
`y_scale`	32位浮点数值的张量
`y_zero_point`	8位整型值的张量或8位无符号整型值的张量
`B`	32位整型值的张量或none类型

结果

结果	描述
`y`	8位整型值的张量或8位无符号整型值的张量

`onnx.QLinearMatMul` (ONNXQLinearMatMulOp)

ONNX QLinearMatMul 操作

行为类似于 numpy.matmul 的矩阵乘积。它消耗两个量化输入张量、它们的比例和零点、输出的比例和零点，并计算量化输出。量化公式为 y = saturate((x / y_scale) + y_zero_point)。对于 (x / y_scale)，它采用四舍五入到最近的偶数。详情请参阅 https://en.wikipedia.org/wiki/Rounding。比例和零点必须具有相同的形状。它们必须是标量 (每张量) 或 N-D 张量 ('a' 的每行和 'b' 的每列)。标量指每张量量化，而 N-D 指每行或每列量化。如果输入是形状为 [M, K] 的 2D 张量，则对于每行量化，零点和比例张量可以是包含 M 个元素的向量 [v_1, v_2, …, v_M]；对于每列量化，可以是形状为 [v_1, v_2, …, v_K] 的包含 K 个元素的向量。如果输入是形状为 [D1, D2, M, K] 的 N-D 张量，则对于每行量化，零点和比例张量的形状可以是 [D1, D2, M, 1]；对于每列量化，形状可以是 [D1, D2, 1, K]。乘积绝不能溢出，累加仅在 32 位时才可能溢出。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`a`	8位整型值的张量或8位无符号整型值的张量
`a_scale`	32位浮点数值的张量
`a_zero_point`	8位整型值的张量或8位无符号整型值的张量
`b`	8位整型值的张量或8位无符号整型值的张量
`b_scale`	32位浮点数值的张量
`b_zero_point`	8位整型值的张量或8位无符号整型值的张量
`y_scale`	32位浮点数值的张量
`y_zero_point`	8位整型值的张量或8位无符号整型值的张量

结果

结果	描述
`y`	8位整型值的张量或8位无符号整型值的张量

`onnx.QuantizeLinear` (ONNXQuantizeLinearOp)

ONNX QuantizeLinear 操作

线性量化操作符。它消耗一个高精度张量、一个比例和一个零点来计算低精度/量化张量。比例因子和零点必须具有相同的形状，并且可以是用于每张量/每层量化的标量，也可以是用于每轴量化的 1-D 张量。量化公式为 y = saturate ((x / y_scale) + y_zero_point)。对于饱和，如果是 uint8，则饱和到 [0, 255]；如果是 int8，则饱和到 [-128, 127]。对于 (x / y_scale)，它采用四舍五入到最近的偶数。详情请参阅 https://en.wikipedia.org/wiki/Rounding。‘y_zero_point’ 和 ‘y’ 必须具有相同的类型。‘y_zero_point’ 通常不用于量化到 float8e4m3fn、float8e4m3fnuz、float8e5m2、float8e5m2fnuz，但为了保持一致性，量化公式保持不变，并且属性 ‘y_zero_point’ 的类型仍然决定了量化类型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`saturate`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`x`	32位浮点型值张量或16位浮点型值张量或bfloat16 类型值张量或32位无符号整型值张量
`y_scale`	32位浮点型值张量或16位浮点型值张量或bfloat16 类型值张量或32位无符号整型值张量
`y_zero_point`	8位无符号整型值张量或8位无符号整型值张量或f8E4M3FN 类型值张量或f8E4M3FNUZ 类型值张量或f8E5M2 类型值张量或f8E5M2FNUZ 类型值张量或None类型

结果

结果	描述
`y`	8位无符号整型值张量或8位无符号整型值张量或f8E4M3FN 类型值张量或f8E4M3FNUZ 类型值张量或f8E5M2 类型值张量或f8E5M2FNUZ 类型值张量

`onnx.RMSLayerNormalization` (ONNXRMSLayerNormalizationOp)

ONNX RMSLayerNormalization 操作

这是在 ONNX 中定义为函数的 RMS 层归一化。整个计算可以分为两个阶段。第一阶段是近似标准化，使归一化后的元素具有零均值和单位方差。参阅 [这篇论文](https://arxiv.org/pdf/1910.07467.pdf) 中的公式 (4)。标准化所需的计算可以通过以下公式描述。 DD = Mul(X, X) Var = ReduceMean<axes=normalized_axes>(DD) VarEps = Add(Var, epsilon) StdDev = Sqrt(VarEps) InvStdDev = Reciprocal(StdDev) Normalized = Mul(X, InvStdDev) 其中 normalized_axes 为 [axis, ..., rank of X - 1]。变量 Var 和 StdDev 分别代表近似方差和标准差。根据 stash_type 属性，实际计算必须发生在不同的浮点精度下。例如，如果 stash_type 为 1，则此操作将所有输入变量转换为 32 位浮点数，执行计算，最后将 Normalized 转换回 X 的原始类型。第二阶段使用 NormalizedScaled = Mul(Normalized, Scale) Y = Add(NormalizedScaled, B) 对第一阶段的结果进行缩放和偏移。第二阶段不依赖于 stash_type。所有公式均遵循 [此语法](https://github.com/onnx/onnx/blob/main/docs/Syntax.md)。相同的变量 (即输入、输出和属性) 在上述公式和此操作定义中使用相同的名称。设 d[i] 表示 X 的第 i 维。如果 X 的形状是 [d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]，则 Mean 和 InvStdDev 的形状是 [d[0], ..., d[axis-1], 1, ..., 1]。Y 和 X 具有相同的形状。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`epsilon`	::mlir::FloatAttr	32位浮点属性
`stash_type`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`Scale`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`InvStdDev`	32 位浮点值张量或 bfloat16 类型值张量或 none 类型

`onnx.RNN` (ONNXRNNOp)

ONNX RNN 操作

计算单层简单 RNN。此操作符通常通过一些自定义实现（例如 CuDNN）来支持。

记号

X - 输入张量
i - 输入门
t - 时间步 (t-1 表示上一个时间步)
Wi - 输入门的 W 参数权重矩阵
Ri - 输入门的 R 循环权重矩阵
Wbi - 输入门的 W 参数偏置向量
Rbi - 输入门的 R 参数偏置向量
WBi - 反向输入门的 W 参数权重矩阵
RBi - 反向输入门的 R 循环权重矩阵
WBbi - 反向输入门的 WR 偏置向量
RBbi - 反向输入门的 RR 偏置向量
H - 隐藏状态
num_directions - 如果 direction == bidirectional 则为 2，否则为 1

激活函数

Relu(x) - max(0, x)
Tanh(x) - (1 - e^{-2x})/(1 + e^{-2x})
Sigmoid(x) - 1/(1 + e^{-x})

注意: 以下是可选的

Affine(x) - alpha*x + beta
LeakyRelu(x) - x (如果 x >= 0) 否则 alpha * x
ThresholdedRelu(x) - x (如果 x >= alpha) 否则 0
ScaledTanh(x) - alphaTanh(betax)
HardSigmoid(x) - min(max(alpha*x + beta, 0), 1)
Elu(x) - x if x >= 0 else alpha*(e^x - 1)
Softsign(x) - x/(1 + x )
Softplus(x) - log(1 + e^x)

公式 (默认: f=Tanh)

Ht = f(Xt(Wi^T) + Ht-1(Ri^T) + Wbi + Rbi) 此操作符具有**可选**输入/输出。有关可选参数表示的更多详细信息，请参阅[文档](IR.md)。可以使用空字符串代替实际参数名称来表示参数缺失。末尾的可选参数（后跟的参数缺失）也可以直接省略。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`activation_alpha`	::mlir::ArrayAttr	32位浮点数组属性
`activation_beta`	::mlir::ArrayAttr	32位浮点数组属性
`activations`	::mlir::ArrayAttr	字符串数组属性
`clip`	::mlir::FloatAttr	32位浮点属性
`direction`	::mlir::StringAttr	字符串属性
`hidden_size`	::mlir::IntegerAttr	64位有符号整数属性
`layout`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`W`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`R`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`B`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`sequence_lens`	32位整型值的张量或none类型
`initial_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`Y_h`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型

`onnx.RandomNormalLike` (ONNXRandomNormalLikeOp)

ONNX RandomNormalLike 操作

生成一个张量，其随机值取自正态分布。输出张量的形状复制自输入张量的形状，正态分布的参数由 mean 和 scale 指定。

数据类型由 'dtype' 参数指定，如果未提供，则复制自输入张量。'dtype' 参数必须是 TensorProto 消息中 'DataType' 枚举字段中指定的数据类型之一，并且作为输出类型有效。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`mean`	::mlir::FloatAttr	32位浮点属性
`scale`	::mlir::FloatAttr	32位浮点属性
`seed`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.RandomNormal` (ONNXRandomNormalOp)

ONNX RandomNormal 操作

生成一个张量，其随机值取自正态分布。张量的形状由 shape 参数指定，正态分布的参数由 mean 和 scale 指定。

数据类型由 'dtype' 参数指定。'dtype' 参数必须是 TensorProto 消息中 'DataType' 枚举字段中指定的数据类型之一。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`mean`	::mlir::FloatAttr	32位浮点属性
`scale`	::mlir::FloatAttr	32位浮点属性
`seed`	::mlir::FloatAttr	32位浮点属性
`形状`	::mlir::ArrayAttr	64位整型数组属性

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.RandomUniformLike` (ONNXRandomUniformLikeOp)

ONNX RandomUniformLike 操作

生成一个张量，其随机值取自均匀分布。输出张量的形状复制自输入张量的形状，均匀分布的参数由 low 和 high 指定。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`高`	::mlir::FloatAttr	32位浮点属性
`低`	::mlir::FloatAttr	32位浮点属性
`seed`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.RandomUniform` (ONNXRandomUniformOp)

ONNX RandomUniform 操作

生成一个张量，其随机值取自均匀分布。张量的形状由 shape 参数指定，范围由 low 和 high 指定。

数据类型由 'dtype' 参数指定。'dtype' 参数必须是 TensorProto 消息中 'DataType' 枚举字段中指定的数据类型之一。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性
`高`	::mlir::FloatAttr	32位浮点属性
`低`	::mlir::FloatAttr	32位浮点属性
`seed`	::mlir::FloatAttr	32位浮点属性
`形状`	::mlir::ArrayAttr	64位整型数组属性

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Range` (ONNXRangeOp)

ONNX Range 操作

生成一个张量，其中包含从 start 开始，以 delta 为增量，直到 limit (不包含) 的数字序列。

Range 的输出中的元素数量计算如下

number_of_elements = max( ceil( (limit - start) / delta ) , 0 )

确定输出内容的伪代码如下所示

for(int i=0; i<number_of_elements; ++i) {
  output[i] =  start + (i * delta);
}

示例 1

Inputs: start = 3, limit = 9, delta = 3
Output: [3, 6]

示例 2

Inputs: start = 10, limit = 4, delta = -2
Output: [10, 8, 6]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`start`	32位浮点型值张量或64位浮点型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量
`上限`	32位浮点型值张量或64位浮点型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量
`增量`	32位浮点型值张量或64位浮点型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量

结果

结果	描述
`输出`	32位浮点型值张量或64位浮点型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量

`onnx.Reciprocal` (ONNXReciprocalOp)

ONNX Reciprocal 操作

Reciprocal 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中逐元素应用倒数运算 y = 1/x。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceL1` (ONNXReduceL1Op)

ONNX ReduceL1 操作

计算输入张量元素沿给定轴的 L1 范数。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到 0。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceL1V13` (ONNXReduceL1V13Op)

ONNX ReduceL1 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceL2` (ONNXReduceL2Op)

ONNX ReduceL2 操作

计算输入张量元素沿给定轴的 L2 范数。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到 0。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceL2V13` (ONNXReduceL2V13Op)

ONNX ReduceL2 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceLogSumExp` (ONNXReduceLogSumExpOp)

ONNX ReduceLogSumExp 操作

计算输入张量元素沿给定轴的对数和指数。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到负无穷大 (如果数据类型支持) 或其他情况下未定义。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceLogSumExpV13` (ONNXReduceLogSumExpV13Op)

ONNX ReduceLogSumExp 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceLogSum` (ONNXReduceLogSumOp)

ONNX ReduceLogSum 操作

计算输入张量元素沿给定轴的对数和。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到负无穷大 (如果数据类型支持) 或其他情况下未定义。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceLogSumV13` (ONNXReduceLogSumV13Op)

ONNX ReduceLogSum 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceMax` (ONNXReduceMaxOp)

ONNX ReduceMax 操作

计算输入张量元素沿给定轴的最大值。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到负无穷大 (如果数据类型支持) 或其他情况下数据类型的最小值。

如果输入数据类型为布尔型，则比较应考虑 False < True。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量或1位无符号整型值张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量或1位无符号整型值张量

`onnx.ReduceMaxV13` (ONNXReduceMaxV13Op)

ONNX ReduceMax 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

`onnx.ReduceMaxV18` (ONNXReduceMaxV18Op)

ONNX ReduceMax 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

`onnx.ReduceMean` (ONNXReduceMeanOp)

ONNX ReduceMean 操作

计算输入张量元素沿给定轴的均值。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到未定义。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceMeanV13` (ONNXReduceMeanV13Op)

ONNX ReduceMean 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceMin` (ONNXReduceMinOp)

ONNX ReduceMin 操作

计算输入张量元素沿给定轴的最小值。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到正无穷大 (如果数据类型支持) 或其他情况下数据类型的最大值。

如果输入数据类型为布尔型，则比较应考虑 False < True。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量或1位无符号整型值张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量或1位无符号整型值张量

`onnx.ReduceMinV13` (ONNXReduceMinV13Op)

ONNX ReduceMin 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

`onnx.ReduceMinV18` (ONNXReduceMinV18Op)

ONNX ReduceMin 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或8位无符号整型值张量或8位无符号整型值张量

`onnx.ReduceProd` (ONNXReduceProdOp)

ONNX ReduceProd 操作

计算输入张量元素沿给定轴的乘积。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到 1。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceProdV13` (ONNXReduceProdV13Op)

ONNX ReduceProd 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceSum` (ONNXReduceSumOp)

ONNX ReduceSum 操作

计算输入张量元素沿给定轴的总和。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到 0。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceSumSquare` (ONNXReduceSumSquareOp)

ONNX ReduceSumSquare 操作

计算输入张量元素沿给定轴的平方和。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。秩为零的输入张量有效。对空值集执行归约得到 0。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性
`noop_with_empty_axes`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`axes`	64位整型值的张量或none类型

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceSumSquareV13` (ONNXReduceSumSquareV13Op)

ONNX ReduceSumSquare 操作

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`缩减后的`	32位无符号整型值的张量或64位无符号整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.ReduceSumV11` (ONNXReduceSumV11Op)

ONNX ReduceSum 操作

计算输入张量元素沿给定轴的总和。如果 keepdims 等于 1，则结果张量与输入具有相同的秩。如果 keepdims 等于 0，则结果张量具有被修剪的归约维度。

上述行为类似于 numpy，但 numpy 的 keepdims 默认值为 False，而不是 True。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量

结果

结果	描述
`缩减后的`	32位无符号整型值张量或64位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量

`onnx.Relu` (ONNXReluOp)

ONNX Relu 操作

Relu 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中逐元素应用修正线性函数 y = max(0, x)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	32 位浮点值张量或 32 位整数值张量或 8 位整数值张量或 16 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`Y`	32 位浮点值张量或 32 位整数值张量或 8 位整数值张量或 16 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

`onnx.Reshape` (ONNXReshapeOp)

ONNX Reshape 操作

重塑输入张量，类似于 numpy.reshape。第一个输入是数据张量，第二个输入是形状张量，指定输出形状。它输出重塑后的张量。新形状中最多有一个维度可以是 -1。在这种情况下，该值由张量的大小和剩余维度推断。维度也可以是 0，此时实际维度值保持不变（即取自输入张量）。如果设置了 'allowzero' 属性，并且新形状包含 0，则该维度将被显式设置为零（即不取自输入张量）。形状（第二个输入）可以是空形状，这意味着转换为标量。输入张量的形状和输出张量的形状必须具有相同数量的元素。

如果设置了属性 'allowzero'，则指定的形状包含零值和 -1 是无效的，因为对应于 -1 的维度值无法唯一确定。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`allowzero`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

形状 64位整型值的张量

结果

结果描述

重塑后的 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.Resize` (ONNXResizeOp)

ONNX Resize 操作

调整输入张量大小。通常，它将输出张量中的每个值计算为输入张量中邻域（也称为采样位置）的加权平均值。输出张量的每个维度值为

output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)

如果未指定输入 “sizes”。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`抗锯齿`	::mlir::IntegerAttr	64位有符号整数属性
`axes`	::mlir::ArrayAttr	64位整型数组属性
`coordinate_transformation_mode`	::mlir::StringAttr	字符串属性
`cubic_coeff_a`	::mlir::FloatAttr	32位浮点属性
`exclude_outside`	::mlir::IntegerAttr	64位有符号整数属性
`extrapolation_value`	::mlir::FloatAttr	32位浮点属性
`keep_aspect_ratio_policy`	::mlir::StringAttr	字符串属性
`mode`	::mlir::StringAttr	字符串属性
`nearest_mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`roi`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`比例`	32 位浮点值张量或 none 类型
`尺寸`	64位整型值的张量或none类型

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ResizeV10` (ONNXResizeV10Op)

ONNX Resize 操作

调整输入张量大小。输出张量的每个维度值为：output_dimension = floor(input_dimension * scale)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数描述

比例 32位浮点数值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ResizeV11` (ONNXResizeV11Op)

ONNX Resize 操作

调整输入张量大小。通常，它将输出张量中的每个值计算为输入张量中邻域（也称为采样位置）的加权平均值。输出张量的每个维度值为：output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)，如果未指定输入 “sizes”。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`coordinate_transformation_mode`	::mlir::StringAttr	字符串属性
`cubic_coeff_a`	::mlir::FloatAttr	32位浮点属性
`exclude_outside`	::mlir::IntegerAttr	64位有符号整数属性
`extrapolation_value`	::mlir::FloatAttr	32位浮点属性
`mode`	::mlir::StringAttr	字符串属性
`nearest_mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`roi`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`比例`	32位浮点数值的张量
`尺寸`	64位整型值的张量或none类型

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ResizeV13` (ONNXResizeV13Op)

ONNX Resize 操作

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`coordinate_transformation_mode`	::mlir::StringAttr	字符串属性
`cubic_coeff_a`	::mlir::FloatAttr	32位浮点属性
`exclude_outside`	::mlir::IntegerAttr	64位有符号整数属性
`extrapolation_value`	::mlir::FloatAttr	32位浮点属性
`mode`	::mlir::StringAttr	字符串属性
`nearest_mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`roi`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`比例`	32 位浮点值张量或 none 类型
`尺寸`	64位整型值的张量或none类型

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ResizeV18` (ONNXResizeV18Op)

ONNX Resize 操作

调整输入张量大小。通常，它将输出张量中的每个值计算为输入张量中邻域（也称为采样位置）的加权平均值。输出张量的每个维度值为
output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)
如果未指定输入 “sizes”。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`抗锯齿`	::mlir::IntegerAttr	64位有符号整数属性
`axes`	::mlir::ArrayAttr	64位整型数组属性
`coordinate_transformation_mode`	::mlir::StringAttr	字符串属性
`cubic_coeff_a`	::mlir::FloatAttr	32位浮点属性
`exclude_outside`	::mlir::IntegerAttr	64位有符号整数属性
`extrapolation_value`	::mlir::FloatAttr	32位浮点属性
`keep_aspect_ratio_policy`	::mlir::StringAttr	字符串属性
`mode`	::mlir::StringAttr	字符串属性
`nearest_mode`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`roi`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或none类型
`比例`	32 位浮点值张量或 none 类型
`尺寸`	64位整型值的张量或none类型

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Return` (ONNXReturnOp)

函数返回操作

语法

operation ::= `onnx.Return` attr-dict ($operands^ `:` type($operands))?

onnx.Return 操作表示函数内的返回操作。该操作接受可变数量的操作数，不产生任何结果。操作数的数量和类型必须与包含该操作的函数签名匹配，但形状类型可以比函数签名结果类型具有更具体的形状，这允许重写操作数定义操作以使结果形状更具体。此操作终止 ONNX dialect 中的 func::FuncOp，并在 StandardFuncReturnPass 降级到 Krnl 或其他 dialects 之前由 func::ReturnOp 替换。

特性: AlwaysSpeculatableImplTrait, HasParent<func::FuncOp>, ReturnLike, Terminator

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), RegionBranchTerminatorOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`操作数`	任意类型的变长序列

`onnx.ReverseSequence` (ONNXReverseSequenceOp)

ONNX ReverseSequence 操作

反转由 sequence_lens 指定不同长度的序列批次。

对于在批次轴上迭代的每个切片 i，操作符反转时间轴上的前 sequence_lens[i] 个元素，并将索引超出 sequence_lens[i] 的元素复制到输出。因此，输出切片 i 包含前 sequence_lens[i] 个元素的反转序列，然后复制其他元素的原始值。

示例 1: input = [[0.0, 4.0, 8.0, 12.0], [1.0, 5.0, 9.0, 13.0], [2.0, 6.0, 10.0, 14.0], [3.0, 7.0, 11.0, 15.0]] sequence_lens = [4, 3, 2, 1] time_axis = 0 batch_axis = 1

output = [[3.0, 6.0, 9.0, 12.0], [2.0, 5.0, 8.0, 13.0], [1.0, 4.0, 10.0, 14.0], [0.0, 7.0, 11.0, 15.0]]

示例 2: input = [[0.0, 1.0, 2.0, 3.0 ], [4.0, 5.0, 6.0, 7.0 ], [8.0, 9.0, 10.0, 11.0], [12.0, 13.0, 14.0, 15.0]] sequence_lens = [1, 2, 3, 4] time_axis = 1 batch_axis = 0

output = [[0.0, 1.0, 2.0, 3.0 ], [5.0, 4.0, 6.0, 7.0 ], [10.0, 9.0, 8.0, 11.0], [15.0, 14.0, 13.0, 12.0]]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`批次轴`	::mlir::IntegerAttr	64位有符号整数属性
`时间轴`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

sequence_lens 64位整型值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.RoiAlign` (ONNXRoiAlignOp)

ONNX RoiAlign 操作

在 [Mask R-CNN 论文](https://arxiv.org/abs/1703.06870) 中描述的感兴趣区域 (RoI) 对齐操作。RoiAlign 消耗输入张量 X 和感兴趣区域 (rois)，以在每个 RoI 上应用池化；它生成形状为 (num_rois, C, output_height, output_width) 的 4-D 张量。

提出 RoiAlign 是为了通过在从原始图像转换为特征图以及从特征图转换为 RoI 特征时去除量化来避免未对齐；在每个 ROI bin 中，采样位置的值直接通过双线性插值计算。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`coordinate_transformation_mode`	::mlir::StringAttr	字符串属性
`mode`	::mlir::StringAttr	字符串属性
`output_height`	::mlir::IntegerAttr	64位有符号整数属性
`output_width`	::mlir::IntegerAttr	64位有符号整数属性
`sampling_ratio`	::mlir::IntegerAttr	64位有符号整数属性
`spatial_scale`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`rois`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`批次索引`	64位整型值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Round` (ONNXRoundOp)

ONNX Round 操作

Round 接受一个输入张量，并对值进行逐元素四舍五入，这意味着它为每个值找到最近的整数。对于半数，规则是四舍五入到最近的偶数。如果输入 x 是整数、+0、-0、NaN 或无穷大，则返回 x 本身。输出张量与输入具有相同的形状和类型。

示例

round([0.9]) = [1.0]
round([2.5]) = [2.0]
round([2.3]) = [2.0]
round([1.5]) = [2.0]
round([-4.5]) = [-4.0]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.STFT` (ONNXSTFTOp)

ONNX STFT 操作

计算信号的短时傅里叶变换。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`onesided`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`信号`	32 位浮点值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量
`frame_step`	32位整型值的张量或64位整型值的张量
`窗口`	32位浮点型值张量或16位浮点型值张量或64位浮点型值张量或bfloat16 类型值张量或None类型
`frame_length`	32位整型值的张量或64位整型值的张量或none类型

结果

结果	描述
`输出`	32 位浮点值张量或 16 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

`onnx.SVMClassifier` (ONNXSVMClassifierOp)

ONNX SVMClassifier 操作

支持向量机分类器

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`classlabels_ints`	::mlir::ArrayAttr	64位整型数组属性
`classlabels_strings`	::mlir::ArrayAttr	字符串数组属性
`coefficients`	::mlir::ArrayAttr	32位浮点数组属性
`kernel_params`	::mlir::ArrayAttr	32位浮点数组属性
`kernel_type`	::mlir::StringAttr	字符串属性
`post_transform`	::mlir::StringAttr	字符串属性
`prob_a`	::mlir::ArrayAttr	32位浮点数组属性
`prob_b`	::mlir::ArrayAttr	32位浮点数组属性
`rho`	::mlir::ArrayAttr	32位浮点数组属性
`support_vectors`	::mlir::ArrayAttr	32位浮点数组属性
`vectors_per_class`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	字符串类型值的张量或64位整型值的张量
`Z`	32位浮点数值的张量

`onnx.SVMRegressor` (ONNXSVMRegressorOp)

ONNX SVMRegressor 操作

支持向量机回归预测和单分类 SVM 异常检测。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`coefficients`	::mlir::ArrayAttr	32位浮点数组属性
`kernel_params`	::mlir::ArrayAttr	32位浮点数组属性
`kernel_type`	::mlir::StringAttr	字符串属性
`n_supports`	::mlir::IntegerAttr	64位有符号整数属性
`one_class`	::mlir::IntegerAttr	64位有符号整数属性
`post_transform`	::mlir::StringAttr	字符串属性
`rho`	::mlir::ArrayAttr	32位浮点数组属性
`support_vectors`	::mlir::ArrayAttr	32位浮点数组属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Scaler` (ONNXScalerOp)

ONNX Scaler 操作

重新缩放输入数据，例如通过去除均值和缩放到单位方差来标准化特征。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`offset`	::mlir::ArrayAttr	32位浮点数组属性
`scale`	::mlir::ArrayAttr	32位浮点数组属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Scan` (ONNXScanOp)

ONNX Scan 操作

Scan 可用于迭代一个或多个 scan_input 张量，构建零个或多个 scan_output 张量。它结合了通用递归、函数式编程构造（如 scan、fold、map 和 zip）的思想，旨在实现 RNN 类构造的序列到序列处理的泛化。其他张量（此处称为 state_variables）可用于在从一个元素迭代到另一个元素时携带状态（类似于 RNN 中的隐藏状态，在循环上下文中也称为循环携带依赖）。许多常见用法涉及单个 scan_input 张量（可以获得类似于 scan、fold 和 map 的功能）。使用多个 scan_input 时，可以获得类似于 zip 的行为。

属性 body 必须是一个图，指定在每次迭代中执行的计算。它将 state_variables 的当前值和 scan_inputs 的当前迭代元素作为输入。它必须返回 state_variables 的（更新后的）值以及零个或多个 scan_output_element 张量。将所有迭代中生成的 scan_output_element 张量的值连接起来，以生成 scan 构造的 scan_output 值（类似于 RNN 类构造的连接的中间隐藏状态值）。所有输出张量（state_variables 和 scan_output_element 张量）在循环的每次迭代中都必须具有相同的形状（为实现高效内存分配而施加的限制）。

请注意，传递给 body 子图的迭代元素不具有序列轴。它的秩将比相应的 scan_input 的秩小一。

scan 操作返回 state_variables 的最终值以及 scan_outputs。

可选属性 scan_input_directions 指定每个 scan 输入的方向（正向或反向）。如果省略此属性，则所有序列都以正向扫描。可以通过在 scan_inputs 中两次指定相同的张量输入来执行双向扫描，一次指定正向，一次指定反向。

操作的 scan_output 是通过连接 body 在每次迭代中产生的 scan_output_element 值生成的。可选属性 scan_output_directions 指定为每个 scan_output 构建 scan_output 的方向（在每次迭代中将 scan_output_element 附加或前置到 scan_output）。如果省略此属性，则在每次迭代中将 scan_output_element 附加到 scan_output。

可选属性 scan_input_axes 指定要扫描的每个 scan_input 的轴。如果省略，则每个 scan_input 将在轴 0 中扫描。例如，如果轴 0 是批次轴且轴 1 是时间轴（要扫描），则指定轴值为 1。请注意，扫描非零轴可能比扫描轴零效率低。

可选属性 scan_output_axes 指定每个 scan_output 沿哪个轴进行累积。例如，如果输入和输出的轴 1 都是时间轴（要扫描），则指定 scan_input axis 和 scan_output axis 值为 1。

请注意，由于 ONNX 限制，操作符的最后一个参数才能是可变参数，因此 initial-states 和 scan-inputs 作为单个输入参数一起列出。类似地，final-states 和 scan-outputs 作为单个输出参数一起列出。属性 num_scan_inputs 指示 scan-inputs 的数量 M。

行为

Scan <
    num_scan_inputs = m,
    body = loop-body,
    scan_input_axes = [axis_1, ..., axis_m]
> (init_1, ..., init_n, scan_1, ..., scan_m)

等同于以下伪代码

// scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
// scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
sequence_length = scan_1.shape[axis_1];

// initialize state-variables
st_1 = init_1; ... st_n = init_n;
// initialize scan-output variables: [] denotes an empty tensor
scan_out_1 = []; ...; scan_out_k = [];
// identify number of iterations:

// execute loop
for (int t = 0; t < sequence_length; ++t) {
    // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
    // of rank one less than T obtained by indexing T at position t along axis k.
    si_1 = scan_1<axis=axis_1>[t];
    ... ;
    si_m = scan_m<axis=axis_m>[t];
    // execute loop-body
    st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
    // accumulate the scan-output elements
    scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
}

return st_1, ..., st_n, scan_out_1, ..., scan_out_k;

示例用法：使用 Scan 编码 RNN

以下示例展示了如何将输入张量 %X、权重张量 %Wi、循环权重张量 %Ri、偏置张量 %Wbi 和 %Rbi 以及初始隐藏状态 %H_0 上的简单 RNN 编码为 ScanLoop。请注意，循环体是一个嵌套图，它直接计算 %Wi、%Ri、%Wbi 和 %Rbi（通常是体图中的常量或初始化器）。如果这些值在外层图中计算，则需要作为额外的 state_variables 传入。

graph rnn-encoding {
  %H_0 = ...
  %X = ...
  %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
  return %Y, %Y_h
}

graph rnn-cell-1 (
  %H_tminus1[FLOAT, tensor]
  %X_t[FLOAT, tensor]
) {
  %Wi = ...
  %Ri = ...
  %Wbi = ...
  %Rbi = ...
  %t1 = X_t * (Wi^T)
  %t2 = H_tminus1*(Ri^T)
  %t3 = Add(%t1, %t2)
  %t4 = Add(%t3, %Wbi)
  %t5 = Add(%t4, %Rbi)
  %Ht = Tanh(%t5)
  %Accumulate = Identity(%Ht)
  return %Ht, %Accumulate
}

特性: AlwaysSpeculatableImplTrait

接口：ConditionallySpeculatable, HasOnnxSubgraphOpInterface, NoMemoryEffect (MemoryEffectOpInterface), ResultTypeInferenceOpInterface, ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`num_scan_inputs`	::mlir::IntegerAttr	64位有符号整数属性
`scan_input_axes`	::mlir::ArrayAttr	64位整型数组属性
`scan_input_directions`	::mlir::ArrayAttr	64位整型数组属性
`scan_output_axes`	::mlir::ArrayAttr	64位整型数组属性
`scan_output_directions`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数描述

initial_state_and_scan_inputs 8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或f8E4M3FN 类型值张量或f8E4M3FNUZ 类型值张量或f8E5M2 类型值张量或f8E5M2FNUZ 类型值张量或4位无符号整型值张量或4位无符号整型值张量的变长序列

结果

结果描述

final_state_and_scan_outputs 8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或8位无符号整型值张量或16位无符号整型值张量或32位无符号整型值张量或64位无符号整型值张量或bfloat16 类型值张量或16位浮点型值张量或32位浮点型值张量或64位浮点型值张量或字符串类型值张量或1位无符号整型值张量或包含32位浮点元素值的复数类型张量或包含64位浮点元素值的复数类型张量或f8E4M3FN 类型值张量或f8E4M3FNUZ 类型值张量或f8E5M2 类型值张量或f8E5M2FNUZ 类型值张量或4位无符号整型值张量或4位无符号整型值张量的变长序列

`onnx.ScatterElements` (ONNXScatterElementsOp)

ONNX ScatterElements 操作

ScatterElements 接受三个输入 data、updates 和 indices，它们具有相同的秩 r >= 1，以及一个可选属性 axis，用于标识 data 的一个轴（默认为最外层轴，即轴 0）。操作的输出是通过创建输入 data 的副本，然后使用 updates 指定的值在由 indices 指定的特定索引位置更新其值而生成的。其输出形状与 data 的形状相同。

对于 updates 中的每个条目，通过将 indices 中的相应条目与条目本身的索引组合来获得 data 中的目标索引：维度 = axis 的索引值来自 indices 中相应条目的值，维度 != axis 的索引值来自条目本身的索引。

reduction 允许指定一个可选的归约操作，该操作应用于 updates 张量中的所有值，并将结果放入指定 indices 处的 output。在 reduction 设置为 "none" 的情况下，indices 不应包含重复的条目：即，如果 idx1 != idx2，则 indices[idx1] != indices[idx2]。例如，在 2-D 张量的情况下，对应于 [i][j] 条目的更新执行如下

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

当 reduction 设置为某个归约函数 f 时，对应于 [i][j] 条目的更新执行如下

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 是指定 +、*、max 或 min。

此操作符是 GatherElements 的逆操作。它类似于 Torch 的 Scatter 操作。

(Opset 18 更改): 将 max/min 添加到允许的归约操作集合中。

示例 1

data = [
    [0.0, 0.0, 0.0],
    [0.0, 0.0, 0.0],
    [0.0, 0.0, 0.0],
]
indices = [
    [1, 0, 2],
    [0, 2, 1],
]
updates = [
    [1.0, 1.1, 1.2],
    [2.0, 2.1, 2.2],
]
output = [
    [2.0, 1.1, 0.0]
    [1.0, 0.0, 2.2]
    [0.0, 2.1, 1.2]
]

示例 2

data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
indices = [[1, 3]]
updates = [[1.1, 2.1]]
axis = 1
output = [[1.0, 1.1, 3.0, 2.1, 5.0]]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`reduction`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`indices`	32位整型值的张量或64位整型值的张量
`更新`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.ScatterND` (ONNXScatterNDOp)

ONNX ScatterND 操作

ScatterND 接受三个输入：秩 r >= 1 的 data 张量，秩 q >= 1 的 indices 张量，以及秩 q + r - indices.shape[-1] - 1 的 updates 张量。操作的输出是通过创建输入 data 的副本，然后使用 updates 指定的值在由 indices 指定的特定索引位置更新其值而生成的。其输出形状与 data 的形状相同。

indices 是一个整数张量。设 k 表示 indices.shape[-1]，即 indices 形状中的最后一个维度。indices 被视为一个 (q-1) 维的 k 元组张量，其中每个 k 元组都是 data 的一个部分索引。因此，k 的最大值不能超过 data 的秩。当 k 等于 rank(data) 时，每个更新条目指定对张量单个元素的更新。当 k 小于 rank(data) 时，每个更新条目指定对张量切片的更新。允许索引值为负，作为从末尾向后计数的一般约定，但期望在有效范围内。

updates 被视为一个 (q-1) 维的替换切片值张量。因此，updates.shape 的前 (q-1) 个维度必须匹配 indices.shape 的前 (q-1) 个维度。updates 的剩余维度对应于替换切片值的维度。每个替换切片值是一个 (r-k) 维张量，对应于 data 的末尾 (r-k) 个维度。因此，updates 的形状必须等于 indices.shape[0:q-1] ++ data.shape[k:r-1]，其中 ++ 表示形状的串联。

output 通过以下公式计算

output = np.copy(data)
update_indices = indices.shape[:-1]
for idx in np.ndindex(update_indices):
    output[indices[idx]] = updates[idx]

上述循环中的迭代顺序未指定。特别是，indices 不应包含重复的条目：即，如果 idx1 != idx2，则 indices[idx1] != indices[idx2]。这确保了输出值不依赖于迭代顺序。

reduction 允许指定一个可选的归约操作，该操作应用于 updates 张量中的所有值，并将结果放入指定 indices 处的 output。在 reduction 设置为 "none" 的情况下，indices 不应包含重复的条目：即，如果 idx1 != idx2，则 indices[idx1] != indices[idx2]。这确保了输出值不依赖于迭代顺序。当 reduction 设置为某个归约函数 f 时，output 计算如下

output = np.copy(data)
update_indices = indices.shape[:-1]
for idx in np.ndindex(update_indices):
    output[indices[idx]] = f(output[indices[idx]], updates[idx])

其中 f 是指定 +、*、max 或 min。

此操作符是 GatherND 的逆操作。

(Opset 18 更改): 将 max/min 添加到允许的归约操作集合中。

示例 1

data    = [1, 2, 3, 4, 5, 6, 7, 8]
indices = [[4], [3], [1], [7]]
updates = [9, 10, 11, 12]
output  = [1, 11, 3, 10, 9, 6, 7, 12]

示例 2

data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
            [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
indices = [[0], [2]]
updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
            [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
            [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
            [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`reduction`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`indices`	64位整型值的张量
`更新`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Scatter` (ONNXScatterOp)

ONNX Scatter 操作

此操作符已弃用。请使用 ScatterElements，它提供相同的功能。

Scatter 接受三个输入 data、updates 和 indices，它们具有相同的秩 r >= 1，以及一个可选属性 axis，用于标识 data 的一个轴（默认为最外层轴，即轴 0）。操作的输出是通过创建输入 data 的副本，然后使用 updates 指定的值在由 indices 指定的特定索引位置更新其值而生成的。其输出形状与 data 的形状相同。

例如，在 2-D 张量的情况下，对应于 [i][j] 条目的更新执行如下

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

此操作符是 GatherElements 的逆操作。它类似于 Torch 的 Scatter 操作。

示例 1

  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]

示例 2

  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`indices`	32位整型值的张量或64位整型值的张量
`更新`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Selu` (ONNXSeluOp)

ONNX Selu 操作

Selu 接受一个输入数据 (张量) 并产生一个输出数据 (张量)，其中逐元素应用缩放指数线性单元函数：对于 x <= 0，`y = gamma * (alpha * e^x - alpha)`；对于 x > 0，`y = gamma * x`。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性
`伽马`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.SequenceAt` (ONNXSequenceAtOp)

ONNX SequenceAt 操作

输出 input_sequence 中 position 位置的张量的副本。position 的有效范围是 [-n, n - 1]，其中 n 是 input_sequence 中的张量数量。负值表示从后向前计数。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

position 32位整型值的张量或64位整型值的张量

结果

结果描述

tensor 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.SequenceConstruct` (ONNXSequenceConstructOp)

ONNX SequenceConstruct 操作

构造包含 inputs 张量的张量序列。inputs 中的所有张量必须具有相同的数据类型。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量

结果

结果描述

output_sequence 8位无符号整型值的张量序列类型或16位无符号整型值的张量序列类型或32位无符号整型值的张量序列类型或64位无符号整型值的张量序列类型或8位整型值的张量序列类型或16位整型值的张量序列类型或32位整型值的张量序列类型或64位整型值的张量序列类型或16位浮点数值的张量序列类型或32位浮点数值的张量序列类型或64位浮点数值的张量序列类型或字符串类型值的张量序列类型或1位整型值的张量序列类型或包含32位浮点元素的复数类型张量序列类型或包含64位浮点元素的复数类型张量序列类型

`onnx.SequenceEmpty` (ONNXSequenceEmptyOp)

ONNX SequenceEmpty 操作

构造一个具有指定数据类型的空张量序列。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`dtype`	::mlir::IntegerAttr	64位有符号整数属性

结果

结果	描述
`输出`	8位无符号整型值的张量序列类型或16位无符号整型值的张量序列类型或32位无符号整型值的张量序列类型或64位无符号整型值的张量序列类型或8位整型值的张量序列类型或16位整型值的张量序列类型或32位整型值的张量序列类型或64位整型值的张量序列类型或16位浮点数值的张量序列类型或32位浮点数值的张量序列类型或64位浮点数值的张量序列类型或字符串类型值的张量序列类型或1位整型值的张量序列类型或包含32位浮点元素的复数类型张量序列类型或包含64位浮点元素的复数类型张量序列类型

`onnx.SequenceErase` (ONNXSequenceEraseOp)

ONNX SequenceErase 操作

输出一个张量序列，该序列从 input_sequence 中移除 position 位置的张量。position 的有效范围是 [-n, n - 1]，其中 n 是 input_sequence 中的张量数量。负值表示从后向前计数。position 是可选的，默认情况下，它会移除 input_sequence 中的最后一个张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

position 32位整型值的张量或64位整型值的张量或none类型

结果

结果描述

`onnx.SequenceInsert` (ONNXSequenceInsertOp)

ONNX SequenceInsert 操作

输出一个张量序列，该序列将 tensor 插入到 input_sequence 的 position 位置。tensor 必须与 input_sequence 具有相同的数据类型。position 的有效范围是 [-n, n]，其中 n 是 input_sequence 中的张量数量。负值表示从后向前计数。position 是可选的，默认情况下，它将 tensor 插入到 input_sequence 的末尾。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`input_sequence`	8位无符号整型值的张量序列类型或16位无符号整型值的张量序列类型或32位无符号整型值的张量序列类型或64位无符号整型值的张量序列类型或8位整型值的张量序列类型或16位整型值的张量序列类型或32位整型值的张量序列类型或64位整型值的张量序列类型或16位浮点数值的张量序列类型或32位浮点数值的张量序列类型或64位浮点数值的张量序列类型或字符串类型值的张量序列类型或1位整型值的张量序列类型或包含32位浮点元素的复数类型张量序列类型或包含64位浮点元素的复数类型张量序列类型
`tensor`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`position`	32位整型值的张量或64位整型值的张量或none类型

结果

结果描述

`onnx.SequenceLength` (ONNXSequenceLengthOp)

ONNX SequenceLength 操作

生成一个标量（空形状张量），其中包含 input_sequence 中的张量数量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

结果

结果	描述
`length`	64位整型值的张量

`onnx.SequenceMap` (ONNXSequenceMapOp)

ONNX SequenceMap 操作

将子图应用于输入序列中的每个样本。

输入可以是张量或序列，但第一个输入必须是序列。第一个输入序列的长度将决定输出中的样本数量。任何其他序列输入应具有相同的样本数量。输入和输出的数量应与子图匹配。

对于输出中的每个第 i 个元素，将从输入序列中提取第 i 个位置的样本，并对其应用子图。输出将包含每个样本的子图输出，顺序与输入中的顺序相同。

此算子假定处理每个样本是独立的，并且可以并行或以任何顺序执行。用户不能期望每个子图的计算有任何特定的顺序。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, HasOnnxSubgraphOpInterface, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

additional_inputs 可变数量的 8位无符号整数值张量或 16位无符号整数值张量或 32位无符号整数值张量或 64位无符号整数值张量或 8位无符号整数值张量或 16位无符号整数值张量或 32位无符号整数值张量或 64位无符号整数值张量或 16位浮点值张量或 32位浮点值张量或 64位浮点值张量或字符串类型值张量或 1位无符号整数值张量或包含32位浮点元素复数类型张量或包含64位浮点元素复数类型张量或包含 8位无符号整数值张量的序列类型值或包含 16位无符号整数值张量的序列类型值或包含 32位无符号整数值张量的序列类型值或包含 64位无符号整数值张量的序列类型值或包含 8位无符号整数值张量的序列类型值或包含 16位无符号整数值张量的序列类型值或包含 32位无符号整数值张量的序列类型值或包含 64位无符号整数值张量的序列类型值或包含 16位浮点值张量的序列类型值或包含 32位浮点值张量的序列类型值或包含 64位浮点值张量的序列类型值或包含字符串类型值张量的序列类型值或包含 1位无符号整数值张量的序列类型值或包含包含32位浮点元素复数类型张量的序列类型值或包含包含64位浮点元素复数类型张量的序列类型值

结果

结果描述

可变数量的包含 8位无符号整数值张量的序列类型值或包含 16位无符号整数值张量的序列类型值或包含 32位无符号整数值张量的序列类型值或包含 64位无符号整数值张量的序列类型值或包含 8位无符号整数值张量的序列类型值或包含 16位无符号整数值张量的序列类型值或包含 32位无符号整数值张量的序列类型值或包含 64位无符号整数值张量的序列类型值或包含 16位浮点值张量的序列类型值或包含 32位浮点值张量的序列类型值或包含 64位浮点值张量的序列类型值或包含字符串类型值张量的序列类型值或包含 1位无符号整数值张量的序列类型值或包含包含32位浮点元素复数类型张量的序列类型值或包含包含64位浮点元素复数类型张量的序列类型值 out_sequence

`onnx.Shape` (ONNXShapeOp)

ONNX Shape 操作

接受一个张量作为输入，并输出一个包含输入张量形状的 1D int64 张量。可选属性 start 和 end 可用于计算输入张量形状的切片。如果省略 start 轴，切片从轴 0 开始。end 轴如果指定，是排他的（并且返回值不包含该轴的大小）。如果省略 end 轴，将包含直到最后一个轴的所有轴。负轴表示从最后一个轴向后计数。注意，如果轴超出范围（对于负轴情况，在添加 r 后），它们将被限制在 [0, r-1] 范围内，其中 r 是输入张量的秩。因此，指定任何大于 r 的 end 值等同于指定 end 值为 r，指定任何小于 -r 的 start 值等同于指定 start 值为 0。

示例

Input tensor with shape: [2, 3, 4]
No attributes specified.
Output: [2, 3, 4]

Input tensor with shape: [2, 3, 4]
start: -1
Output: [4]

Input tensor with shape: [2, 3, 4]
end: -1
Output: [2, 3]

Input tensor with shape: [2, 3, 4]
start: 1
end: 2
Output: [3]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`end`	::mlir::IntegerAttr	64位有符号整数属性
`start`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

结果

结果	描述
`形状`	64位整型值的张量

`onnx.ShapeTransform` (ONNXShapeTransformOp)

ONNX 逐元素形状变换操作

此算子将一个张量转换为另一个张量，其形状通过给定的仿射映射改变。这是逐元素的变换，因此输入中的每个元素将通过仿射映射复制到输出中的元素。仿射映射必须是双射的。

例如，以下代码使用 onnx.ShapeTransform 将一个张量从 2D 重塑为 4D。

#reshape = affine_map(d0, d1) -> (d0/32, d0%32, d1/64, d1%64)
%Y = onnx.ShapeTransform(%arg0) {index_map = #reshape} :  (tensor<128x128xf32>) -> tensor<4x32x2x64xf32>

onnx.ShapeTransform 最终将通过降低到 krnl dialect 具体化为一个 affine.for，例如：

%alloc = memref.alloc() {alignment = 16 : i64} : memref<4x32x2x64xf32>
affine.for %arg1 = 0 to 128 {
  affine.for %arg2 = 0 to 128 {
    %0 = affine.load %arg0[%arg1, %arg2] : memref< 128x128xf32 >
    affine.store %0, %alloc[%arg1 / 32, %arg1 % 32, %arg2 / 64, %arg2 % 64] : memref<4x32x2x64xf32>
  }
}

标准化时，ShapeTransform 操作通过组合其仿射映射来组合成新的 ShapeTransform 操作。

目前，此操作仅支持静态维度。

此操作不属于标准 ONNX 操作，添加它是为了辅助 onnx-mlir。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`index_map`	::mlir::AffineMapAttr	AffineMap 属性

操作数

操作数	描述
`输入`	32位浮点数值的张量

结果

结果	描述
`输出`	32位浮点数值的张量

`onnx.Shrink` (ONNXShrinkOp)

ONNX Shrink 操作

Shrink 接受一个输入数据 (Tensor)) 并生成一个 Tensor 输出，该输出与输入具有相同的数据类型和形状。它有两个属性，lambd 和 bias。此算子的公式为：如果 x < -lambd，则 y = x + bias；如果 x > lambd，则 y = x - bias；否则，y = 0。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`bias`	::mlir::FloatAttr	32位浮点属性
`lambd`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Sigmoid` (ONNXSigmoidOp)

ONNX Sigmoid 操作

Sigmoid 接受一个输入数据 (Tensor)) 并产生一个输出数据 (张量) 其中将 sigmoid 函数 y = 1 / (1 + exp(-x)) 逐元素应用于张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Sign` (ONNXSignOp)

ONNX Sign 操作

计算给定输入张量的逐元素符号。如果输入 > 0，输出为 1。如果输入 < 0，输出为 -1。如果输入 == 0，输出为 0。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Sin` (ONNXSinOp)

ONNX Sin 操作

计算给定输入张量的逐元素正弦。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Sinh` (ONNXSinhOp)

ONNX Sinh 操作

计算给定输入张量的逐元素双曲正弦。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Size` (ONNXSizeOp)

ONNX Size 操作

接受一个张量作为输入，并输出一个 int64 标量，该标量等于输入张量的总元素数量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

结果

结果	描述
`size`	64位整型值的张量

`onnx.Slice` (ONNXSliceOp)

ONNX Slice 操作

沿着多个轴生成输入张量的切片。类似于 numpy：https://numpy.com.cn/doc/stable/user/basics.indexing.html?highlight=slice#slicing-and-striding

Slice 使用 starts、ends、axes 和 steps 输入来选择其输入 data 张量的子张量。

对于 [0, ... r-1] 中的每个 i，必须计算一个有效的 starts[i]、ends[i] 和 steps[i]，其中 r = rank(input)，计算方法如下：

如果省略 axes，它们将被设置为 [0, ..., r-1]。如果省略 steps，它们将被设置为长度为 len(starts) 的 [1, ..., 1]。

有效值初始化为 start[i] = 0，ends[i] = dims[i]，其中 dims 是 input 的维度，并且 steps[i] = 1。

axes 的所有负元素通过加上 r 变为非负，其中 r = rank(input)。

starts[i] 和 ends[i] 中的所有负值都加上 dims[axes[i]]，其中 dims 是 input 的维度。然后将调整后的 starts[i] 限制在 [0, dims[axes[i]]] 范围内（对于正步长）和 [0, dims[axes[i]]-1] 范围内（对于负步长），作为 start[axes[i]]。

调整后的 ends[i] 的限制取决于 steps[i] 的符号，并且必须能够处理从 0 到 dims[axes[i]] 个元素的复制，因此对于正步长，ends[axes[i]] 限制在 [0, dims[axes[i]]] 范围内，而对于负步长，它限制在 [-1, dims[axes[i]]-1] 范围内。

最后，steps[axes[i]] = steps[i]。

对于切片到未知大小维度的末尾，建议在向前切片时传入 INT_MAX，在向后切片时传入 INT_MIN。

示例 1

data = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
]
axes = [0, 1]
starts = [1, 0]
ends = [2, 3]
steps = [1, 2]
result = [
    [5, 7],
]

示例 2

data = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
]
starts = [0, 1]
ends = [-1, 1000]
result = [
    [2, 3, 4],
]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`starts`	32位整型值的张量或64位整型值的张量
`ends`	32位整型值的张量或64位整型值的张量
`axes`	32位整型值的张量或64位整型值的张量或none类型
`steps`	32位整型值的张量或64位整型值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.SoftmaxCrossEntropyLoss` (ONNXSoftmaxCrossEntropyLossOp)

ONNX SoftmaxCrossEntropyLoss 操作

计算 scores 和 labels 之间的 softmax 交叉熵的损失函数。此算子首先计算一个损失张量，其形状与 labels 输入相同。如果输入是形状为 (N, C) 的 2D 张量，损失张量可能是一个 N 元素的向量 L = (l_1, l_2, …, l_N)。如果输入是形状为 (N, C, D1, D2, …, Dk) 的 N-D 张量，损失张量 L 的形状可能为 (N, D1, D2, …, Dk)，并且 L[i,][j_1][j_2]…[j_k] 表示 L 中的一个标量元素。在获得 L 后，此算子可以可选地执行一个归约操作。

shape(scores): (N, C)，其中 C 是类别的数量；或 (N, C, D1, D2,…, Dk)，在 K 维损失情况下 K >= 1。
shape(labels): (N)，其中每个值都在 0 <= labels[i] <= C-1 范围内；或 (N, D1, D2,…, Dk)，在 K 维损失情况下 K >= 1。

单个样本的损失 l_i 可以按如下方式计算：

l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.

或

l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.

当标签值等于 ignore_index 时，损失为零。

l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index

其中

p = Softmax(scores)
y = Log(p)
c = labels[i][d1][d2]...[dk]

最后，L 可选地被归约

如果 reduction = ‘none’，输出是形状为 (N, D1, D2, …, Dk) 的 L。
如果 reduction = ‘sum’，输出是标量：Sum(L)。
如果 reduction = ‘mean’，输出是标量：ReduceMean(L)，或者如果提供了 weight：ReduceSum(L) / ReduceSum(W)，其中张量 W 的形状为 (N, D1, D2, ..., Dk) 且 W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]]。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`ignore_index`	::mlir::IntegerAttr	64位有符号整数属性
`reduction`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`scores`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`labels`	32位整型值的张量或64位整型值的张量
`weights`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`log_prob`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量或none类型

`onnx.Softmax` (ONNXSoftmaxOp)

ONNX Softmax 操作

该算子计算给定输入的归一化指数值

Softmax(input, axis) = Exp(input) / ReduceSum(Exp(input), axis=axis, keepdims=1)

"axis" 属性表示执行 Softmax 的维度。输出张量具有相同的形状，并包含对应输入的 Softmax 值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.SoftmaxV11` (ONNXSoftmaxV11Op)

ONNX Softmax 操作

该算子计算给定输入的批量中每个层的 softmax（归一化指数）值。

输入不需要显式地是 2D 向量；它会被强制转换为 2D 向量。对于任意 n 维张量输入 $\in$ [a_0, a_1, …, a_{k-1}, a_k, …, a_{n-1}]，如果提供了轴 k，则输入将被强制转换为维度为 [a_0 * … * a_{k-1}, a_k * … * a_{n-1}] 的 2 维张量。对于默认情况轴为 1，这意味着输入张量将被强制转换为维度为 [a_0, a_1 * … * a_{n-1}] 的 2D 张量，其中 a_0 通常是批量大小。在这种情况下，必须满足 a_0 = N 和 a_1 * … * a_{n-1} = D。这些维度中的每一个都必须正确匹配，否则算子将引发错误。输出张量具有相同的形状，并包含对应输入的 softmax 值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Softplus` (ONNXSoftplusOp)

ONNX Softplus 操作

Softplus 接受一个输入数据 (Tensor)) 并产生一个输出数据 (张量) 其中将 softplus 函数 y = ln(exp(x) + 1) 逐元素应用于张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Softsign` (ONNXSoftsignOp)

ONNX Softsign 操作

计算 softsign (x/(1+

)) 应用于给定输入张量的逐元素值。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.SpaceToDepth` (ONNXSpaceToDepthOp)

ONNX SpaceToDepth 操作

SpaceToDepth 将空间数据块重新排列到深度维度。更具体地说，此算子输出输入张量的一个副本，其中高度和宽度维度的值被移动到深度维度。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`blocksize`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Split` (ONNXSplitOp)

ONNX Split 操作

沿指定的 axis 将张量分割成一个张量列表。必须指定输入 split 或属性 num_outputs 中的一个，但不能同时指定两者。如果指定了属性 num_outputs，则张量将被分割成大小相等的部分。如果张量不能均匀分割成 num_outputs，则最后一个块会较小。如果指定了输入 split，则它指示了分割中每个输出的大小。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`num_outputs`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

split 64位整型值的张量或none类型

结果

结果	描述
`输出`	可变数量的8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.SplitToSequence` (ONNXSplitToSequenceOp)

ONNX SplitToSequence 操作

沿指定的 axis 将张量分割成一个张量序列。可以使用可选参数 split 指定各个部分的长度。如果未指定参数 split，则使用默认标量值 1 作为 split 的值。split 必须只包含正数。split 是一个标量（空形状张量）或一个 1-D 张量。如果 split 是一个标量，那么如果可能，input 将被分割成大小都为 split 的块。如果给定轴 axis 上的 input 大小不能被 split 整除，则最后一个块可能会小于 split。如果 split 是一个 1 维张量，输入张量将被分割成 size(split) 个块，其中 axis 上各部分的长度在 split 中指定。在这种情况下，split 中所有条目的总和必须等于输入张量在 axis 上的维度大小。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`keepdims`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

split 32位整型值的张量或64位整型值的张量或none类型

结果

结果描述

`onnx.SplitV11` (ONNXSplitV11Op)

ONNX Split 操作

沿指定的 axis 将张量分割成一个张量列表。可以使用参数 split 指定各部分的长度。否则，张量将被分割成大小相等的部分。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`split`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`输入`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	可变数量的 8 位无符号整数值张量或 16 位无符号整数值张量或 32 位无符号整数值张量或 64 位无符号整数值张量或 8 位整数值张量或 16 位整数值张量或 32 位整数值张量或 64 位整数值张量或 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或字符串类型值张量或 1 位整数值张量或元素为 32 位浮点数的复数类型值张量或元素为 64 位浮点数的复数类型值张量

`onnx.SplitV13` (ONNXSplitV13Op)

ONNX Split 操作

沿指定的 axis 将张量分割成一个张量列表。可以使用输入 split 指定各部分的长度。否则，张量将被分割成大小相等的部分。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

split 64位整型值的张量或none类型

结果

结果	描述
`输出`	可变数量的8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Sqrt` (ONNXSqrtOp)

ONNX Sqrt 操作

平方根接受一个输入数据 (Tensor)) 并产生一个输出数据 (张量) 其中将平方根 y = x^0.5 逐元素应用于张量。如果 x 为负，则返回 NaN。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`X`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`Y`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Squeeze` (ONNXSqueezeOp)

ONNX Squeeze 操作

从张量的形状中移除单维度条目。接受一个输入 axes，其中包含要压缩的轴列表。如果未提供 axes，则形状中的所有单维度都将被移除。如果选定的轴的形状条目不等于 1，则引发错误。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

axes 64位整型值的张量或none类型

结果

结果描述

squeezed 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.SqueezeV11` (ONNXSqueezeV11Op)

ONNX Squeeze 操作

从张量的形状中移除单维度条目。接受一个参数 axes，其中包含要压缩的轴列表。如果未提供 axes，则形状中的所有单维度都将被移除。如果选定的轴的形状条目不等于 1，则引发错误。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果描述

squeezed 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.StringNormalizer` (ONNXStringNormalizerOp)

ONNX StringNormalizer 操作

StringNormalization 执行字符串操作以进行基本清理。此算子只有一个输入（表示为 X）和一个输出（表示为 Y）。此算子首先检查 X 中的元素，并移除 stopwords 属性中指定的元素。移除停用词后，中间结果可以根据 case_change_action 属性进一步转为小写、大写或直接返回。此算子只接受 [C] 和 [1, C] 形的张量。如果 X 中的所有元素都被丢弃，则输出将是一个空字符串张量，如果输入形状是 [C]，输出形状为 [1]；如果输入形状是 [1, C]，输出形状为 [1, 1]。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`case_change_action`	::mlir::StringAttr	字符串属性
`is_case_sensitive`	::mlir::IntegerAttr	64位有符号整数属性
`locale`	::mlir::StringAttr	字符串属性
`stopwords`	::mlir::ArrayAttr	字符串数组属性

操作数

操作数	描述
`X`	字符串类型值张量

结果

结果	描述
`Y`	字符串类型值张量

`onnx.Sub` (ONNXSubOp)

ONNX Sub 操作

执行逐元素的二进制减法（支持 Numpy 风格的广播）。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

(Opset 14 变更): 扩展支持的类型，包含 uint8, int8, uint16 和 int16。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量
`B`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

结果

结果	描述
`C`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Sum` (ONNXSumOp)

ONNX Sum 操作

对每个输入张量执行逐元素求和（支持 Numpy 风格的广播）。所有输入和输出必须具有相同的数据类型。此算子支持**多方向（即 Numpy 风格）广播**；更多详情请查阅文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`data_0`	可变数量的 16 位浮点值张量或 32 位浮点值张量或 64 位浮点值张量或 bfloat16 类型值张量

结果

结果	描述
`sum`	16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或bfloat16类型值的张量

`onnx.Tan` (ONNXTanOp)

ONNX Tan 操作

计算给定输入张量的逐元素正切。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Tanh` (ONNXTanhOp)

ONNX Tanh 操作

计算给定输入张量的逐元素双曲正切。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`输入`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`输出`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.TfIdfVectorizer` (ONNXTfIdfVectorizerOp)

ONNX TfIdfVectorizer 操作

此变换从输入序列中提取 n-gram 并将其保存为向量。输入可以是 1-D 或 2-D 张量。对于 1-D 输入，输出是该输入的 n-gram 表示。对于 2-D 输入，输出也是一个 2-D 张量，其第 i 行是第 i 个输入行的 n-gram 表示。更具体地说，如果输入形状是 [C]，则对应的输出形状将是 [max(ngram_indexes) + 1]。如果输入形状是 [N, C]，此算子生成一个 [N, max(ngram_indexes) + 1] 形的张量。

与标准的 n-gram 提取不同，此处从原始序列中提取 n-gram 的索引不一定是连续的数字。索引之间的不连续性由跳过次数控制。如果跳过次数为 2，则在扫描原始序列时应跳过两个 token。考虑一个例子。假设输入序列是 [94, 17, 36, 12, 28]，跳过次数为 2。相关的 2-gram 是 [94, 12] 和 [17, 28]，其索引分别为 [0, 3] 和 [1, 4]。如果跳过次数变为 0，生成的 2-gram 是 [94, 17]、[17, 36]、[36, 12]、[12, 28]，其索引分别为 [0, 1]、[1, 2]、[2, 3]、[3, 4]。

输出向量（表示为 Y）存储每个 n-gram 的计数；Y[ngram_indexes[i]] 表示找到第 i 个 n-gram 的次数。属性 ngram_indexes 用于确定索引 i 与对应 n-gram 输出坐标之间的映射。如果 pool_int64s 是 [94, 17, 17, 36]，ngram_indexes 是 [1, 0]，ngram_counts=[0, 0]，则 Y[0]（Y 中的第一个元素）和 Y[1]（Y 中的第二个元素）分别是 [17, 36] 和 [94, 17] 的计数。在 pool_strings/pool_int64s 中找不到的 n-gram 应该被忽略，并且对输出没有影响。注意，在生成 n-gram 时，我们可能会考虑所有小于等于 S 的跳过次数。

上面使用的示例在 mode 为 "TF" 时有效。如果 mode 为 "IDF"，则所有大于 1 的计数将被截断为 1，并且 weights 中的第 i 个元素将用于按比例（通过乘法）缩放 pool 中第 i 个 n-gram 的计数。如果 mode 为 "TFIDF"，此算子首先计算所有 n-gram 的计数，然后根据 weights 属性中关联的值进行缩放。

pool_strings 和 pool_int64s 中只能设置一个。如果设置了 pool_int64s，输入应该是一个整数张量。如果设置了 pool_strings，输入必须是一个字符串张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`max_gram_length`	::mlir::IntegerAttr	64位有符号整数属性
`max_skip_count`	::mlir::IntegerAttr	64位有符号整数属性
`min_gram_length`	::mlir::IntegerAttr	64位有符号整数属性
`mode`	::mlir::StringAttr	字符串属性
`ngram_counts`	::mlir::ArrayAttr	64位整型数组属性
`ngram_indexes`	::mlir::ArrayAttr	64位整型数组属性
`pool_int64s`	::mlir::ArrayAttr	64位整型数组属性
`pool_strings`	::mlir::ArrayAttr	字符串数组属性
`weights`	::mlir::ArrayAttr	32位浮点数组属性

操作数

操作数	描述
`X`	字符串类型值张量或 32位无符号整数值张量或 64位无符号整数值张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.ThresholdedRelu` (ONNXThresholdedReluOp)

ONNX ThresholdedRelu 操作

ThresholdedRelu 接受一个输入数据 (Tensor)) 并产生一个输出数据 (张量) 其中将修正线性函数 y = x (当 x > alpha 时)，y = 0 (否则) 逐元素应用于张量。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`alpha`	::mlir::FloatAttr	32位浮点属性

操作数

操作数	描述
`X`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

结果

结果	描述
`Y`	bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量

`onnx.Tile` (ONNXTileOp)

ONNX Tile 操作

通过平铺给定张量来构造一个张量。这与 Numpy 中的 tile 函数相同，但不包含广播。例如 A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

repeats 64位整型值的张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.TopK` (ONNXTopKOp)

ONNX TopK 操作

沿着指定轴检索 top-K 最大或最小元素。给定形状为 [a_0, a_1, …, a_{n-1}] 的输入张量和整数参数 k，返回两个输出：

形状为 [a_0, a_1, …, a_{axis-1}, k, a_{axis+1}, … a_{n-1}] 的值张量，其中包含沿指定轴的 top k 元素的值。
形状为 [a_0, a_1, …, a_{axis-1}, k, a_{axis+1}, … a_{n-1}] 的索引张量，其中包含 top k 元素的索引（来自输入张量的原始索引）。
如果 largest 为 1（默认值），则返回 k 个最大元素。
如果 sorted 为 1（默认值），则结果中的 k 个元素将被排序。
如果 sorted 为 0，则返回的 Values 和 Indices 的顺序未定义。

给定两个等价的值，此算子使用沿轴的索引作为平局决胜者。也就是说，索引较低的元素将首先出现。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`largest`	::mlir::IntegerAttr	64位有符号整数属性
`sorted`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`K`	64位整型值的张量

结果

结果	描述
`Values`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量
`Indices`	64位整型值的张量

`onnx.Transpose` (ONNXTransposeOp)

ONNX Transpose 操作

转置输入张量，类似于 numpy.transpose。例如，当 perm=(1, 0, 2) 时，给定形状为 (1, 2, 3) 的输入张量，输出形状将是 (2, 1, 3)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`perm`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

结果

结果描述

`onnx.TreeEnsembleClassifier` (ONNXTreeEnsembleClassifierOp)

ONNX TreeEnsembleClassifier 操作

树集成分类器。返回 N 个输入中每个的顶级类别。
名为 ‘nodes_X’ 的属性构成一系列元组，通过索引关联到序列中，这些序列的长度必须全部相等。这些元组定义了节点。
类似地，所有以 ‘class_’ 为前缀的字段都是叶节点处的投票元组。一个叶节点可能有多个投票，每个投票都根据关联的 class_weights 索引加权。
classlabels_strings 或 classlabels_int64s 中只有一个会被定义。class_ids 是此列表的索引。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`base_values`	::mlir::ArrayAttr	32位浮点数组属性
`class_ids`	::mlir::ArrayAttr	64位整型数组属性
`class_nodeids`	::mlir::ArrayAttr	64位整型数组属性
`class_treeids`	::mlir::ArrayAttr	64位整型数组属性
`class_weights`	::mlir::ArrayAttr	32位浮点数组属性
`classlabels_int64s`	::mlir::ArrayAttr	64位整型数组属性
`classlabels_strings`	::mlir::ArrayAttr	字符串数组属性
`nodes_falsenodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_featureids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_hitrates`	::mlir::ArrayAttr	32位浮点数组属性
`nodes_missing_value_tracks_true`	::mlir::ArrayAttr	64位整型数组属性
`nodes_modes`	::mlir::ArrayAttr	字符串数组属性
`nodes_nodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_treeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_truenodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_values`	::mlir::ArrayAttr	32位浮点数组属性
`post_transform`	::mlir::StringAttr	字符串属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	字符串类型值的张量或64位整型值的张量
`Z`	32位浮点数值的张量

`onnx.TreeEnsembleRegressor` (ONNXTreeEnsembleRegressorOp)

ONNX TreeEnsembleRegressor 操作

树集成回归器。返回 N 个输入中每个的回归值。
所有以 nodes_ 开头的参数都是树节点元组的字段，假定它们的长度相同，并且索引 i 将跨这些输入解码元组。每个节点 ID 对于每个树 ID 只能出现一次。
所有以 target_ 为前缀的字段都是叶节点处的投票元组。
一个叶节点可能有多个投票，每个投票都根据关联的 target_weights 索引加权。
所有树的节点 ID 都必须从 0 开始并递增 1。
Mode 枚举为 BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`aggregate_function`	::mlir::StringAttr	字符串属性
`base_values`	::mlir::ArrayAttr	32位浮点数组属性
`n_targets`	::mlir::IntegerAttr	64位有符号整数属性
`nodes_falsenodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_featureids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_hitrates`	::mlir::ArrayAttr	32位浮点数组属性
`nodes_missing_value_tracks_true`	::mlir::ArrayAttr	64位整型数组属性
`nodes_modes`	::mlir::ArrayAttr	字符串数组属性
`nodes_nodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_treeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_truenodeids`	::mlir::ArrayAttr	64位整型数组属性
`nodes_values`	::mlir::ArrayAttr	32位浮点数组属性
`post_transform`	::mlir::StringAttr	字符串属性
`target_ids`	::mlir::ArrayAttr	64位整型数组属性
`target_nodeids`	::mlir::ArrayAttr	64位整型数组属性
`target_treeids`	::mlir::ArrayAttr	64位整型数组属性
`target_weights`	::mlir::ArrayAttr	32位浮点数组属性

操作数

操作数	描述
`X`	32位浮点数值的张量或64位浮点数值的张量或64位整型值的张量或32位整型值的张量

结果

结果	描述
`Y`	32位浮点数值的张量

`onnx.Trilu` (ONNXTriluOp)

ONNX Trilu 操作

给定 2-D 矩阵或批量 2-D 矩阵，返回张量的上三角形或下三角形部分。属性 upper 决定保留上部分还是下部分。如果设置为 true，则保留上三角形矩阵。否则保留下三角形矩阵。属性 upper 的默认值为 true。Trilu 接受一个形状为 [*, N, M] 的输入张量，其中 * 是零个或多个批量维度。上三角形部分包含给定对角线 (k) 上和上方的元素。下三角形部分包含给定对角线上和下方的元素。矩阵中的所有其他元素都设置为零。如果 k = 0，则保留主对角线上方/下方的三角形部分。如果 upper 设置为 true，正 k 保留上三角形矩阵，排除主对角线和其上方 (k-1) 条对角线。负 k 值保留主对角线及其下方 |k| 条对角线。如果 upper 设置为 false，正 k 保留下三角形矩阵，包括主对角线及其上方 k 条对角线。负 k 值排除主对角线及其下方 (|k|-1) 条对角线。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`upper`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数描述

k 64位整型值的张量或none类型

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Unique` (ONNXUniqueOp)

ONNX Unique 操作

找到张量的唯一元素。当提供了可选属性 axis 时，返回沿 axis 切片的唯一子张量。否则，输入张量被展平，并返回展平张量的唯一值。

此算子返回输入张量的唯一值或沿轴切片的唯一子张量以及三个可选输出。第一个输出张量 Y 包含输入的所有唯一值或子张量。第二个可选输出张量 indices 包含 Y 中元素在 X 中首次出现的索引。第三个可选输出张量 inverse_indices 包含 X 中元素在 Y 中的对应索引。第四个可选输出张量 counts 包含 Y 中每个元素在输入中的计数。

输出可以按升序排序，或者可选地按值在输入中首次出现的顺序排列。

https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.unique.html

示例 1

input_X = [2, 1, 1, 3, 4, 3]
attribute_sorted = 0
attribute_axis = None
output_Y = [2, 1, 3, 4]
output_indices = [0, 1, 3, 4]
output_inverse_indices = [0, 1, 1, 2, 3, 2]
output_counts = [1, 2, 2, 1]

示例 2

input_X = [[1, 3], [2, 3]]
attribute_sorted = 1
attribute_axis = None
output_Y = [1, 2, 3]
output_indices = [0, 2, 1]
output_inverse_indices = [0, 2, 1, 2]
output_counts = [1, 1, 2]

示例 3

input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
attribute_sorted = 1
attribute_axis = 0
output_Y = [[1, 0, 0], [2, 3, 4]]
output_indices = [0, 2]
output_inverse_indices = [0, 0, 1]
output_counts = [2, 1]

示例 4

input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
            [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
attribute_sorted = 1
attribute_axis = 1

下面提供了中间数据以更好地理解：沿 input_x（形状 = (2, 4, 2)）的轴 1 切片得到 4 个子张量。

A: [[1, 1], [1, 1]],
   [[0, 1], [0, 1]],
   [[2, 1], [2, 1]],
   [[0, 1], [0, 1]].

有 3 个唯一的子张量

[[1, 1], [1, 1]],
[[0, 1], [0, 1]],
[[2, 1], [2, 1]].

排序后的唯一子张量

B: [[0, 1], [0, 1]],
   [[1, 1], [1, 1]],
   [[2, 1], [2, 1]].

output_Y 由 B 构造

[[[0. 1.], [1. 1.], [2. 1.]],
 [[0. 1.], [1. 1.], [2. 1.]]]

output_indices 用于从 B 到 A 的映射

[1, 0, 2]

output_inverse_indices 用于从 A 到 B 的映射

[1, 0, 2, 0]

output_counts

[2, 1, 1]

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axis`	::mlir::IntegerAttr	64位有符号整数属性
`sorted`	::mlir::IntegerAttr	64位有符号整数属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`indices`	64位整型值的张量或none类型
`inverse_indices`	64位整型值的张量或none类型
`counts`	64位整型值的张量或none类型

`onnx.Unsqueeze` (ONNXUnsqueezeOp)

ONNX Unsqueeze 操作

在输入张量（data）的形状中插入单维度条目。接受一个必需的输入 axes，其中包含一个维度索引列表，并且此算子将在输出张量（expanded）的相应索引处插入一个值为 1 的维度。

例如，给定形状为 [3, 4, 5] 的输入张量（data），则 Unsqueeze(data, axes=[0, 4]) 输出一个张量（expanded），该张量包含与 data 相同的数据，但形状为 [1, 3, 4, 5, 1]。

输入 axes 不应包含任何重复条目。如果包含重复条目，则会引发错误。输出张量（output_rank）的秩等于输入张量（data）的秩加上 axes 中值的数量。axes 中的每个值应在（包含）范围 [-output_rank , output_rank - 1] 内。axes 中值的顺序无关紧要，可以按任何顺序出现。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数描述

axes 64位整型值的张量

结果

结果描述

expanded 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量或f8E4M3FN类型值的张量或f8E4M3FNUZ类型值的张量或f8E5M2类型值的张量或f8E5M2FNUZ类型值的张量或4位无符号整型值的张量或4位整型值的张量

`onnx.UnsqueezeV11` (ONNXUnsqueezeV11Op)

ONNX Unsqueeze 操作

在输入张量（data）的形状中插入单维度条目。接受一个必需的参数 axes，其中包含一个维度索引列表，并且此算子将在输出张量（expanded）的相应索引处插入一个值为 1 的维度。

例如：给定形状为 [3, 4, 5] 的输入张量（data），则 Unsqueeze(data, axes=[0, 4]) 输出一个张量（expanded），该张量包含与 data 相同的数据，但形状为 [1, 3, 4, 5, 1]。

属性 axes 不应包含任何重复条目。如果包含重复条目，则会引发错误。输出张量（output_rank）的秩等于输入张量（data）的秩加上 axes 中值的数量。axes 中的每个值应在（包含）范围 [-output_rank , output_rank - 1] 内。axes 中值的顺序无关紧要，可以按任何顺序出现。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`axes`	::mlir::ArrayAttr	64位整型数组属性

操作数

操作数	描述
`数据`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果描述

expanded 8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Upsample` (ONNXUpsampleOp)

ONNX Upsample 操作

对输入张量进行上采样。输出张量的每个维度值计算如下：output_dimension = floor(input_dimension * scale)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性

操作数

操作数描述

比例 32位浮点数值的张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.UpsampleV7` (ONNXUpsampleV7Op)

ONNX Upsample 操作

对输入张量进行上采样。输出张量的每个维度值计算如下：output_dimension = floor(input_dimension * scale)。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`mode`	::mlir::StringAttr	字符串属性
`比例`	::mlir::ArrayAttr	32位浮点数组属性

操作数

操作数	描述
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Where` (ONNXWhereOp)

ONNX Where 操作

根据条件从 X 或 Y 中返回元素。Where 的行为类似于具有三个参数的 numpy.where。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`condition`	1位整型值的张量
`X`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量
`Y`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

结果

结果	描述
`输出`	8位无符号整型值的张量或16位无符号整型值的张量或32位无符号整型值的张量或64位无符号整型值的张量或8位整型值的张量或16位整型值的张量或32位整型值的张量或64位整型值的张量或bfloat16类型值的张量或16位浮点数值的张量或32位浮点数值的张量或64位浮点数值的张量或字符串类型值的张量或1位整型值的张量或包含32位浮点元素的复数类型张量或包含64位浮点元素的复数类型张量

`onnx.Xor` (ONNXXorOp)

ONNX Xor 操作

返回对输入张量 A 和 B 逐元素执行 xor 逻辑操作（支持 Numpy 风格广播）后得到的张量。

此操作符支持 **多向 (即 Numpy 风格) 广播**；更多详情请查看文档。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`A`	1位整型值的张量
`B`	1位整型值的张量

结果

结果	描述
`C`	1位整型值的张量

`onnx.Yield` (ONNXYieldOp)

ONNX yield 操作

语法

operation ::= `onnx.Yield` attr-dict ($operands^ `:` type($operands))?

该 onnx.Yield 操作表示 ONNX 子图中的一个 yield 操作。此操作接受可变数量的操作数，不产生任何结果。

此操作不属于标准的一部分，是为协助 onnx-mlir 而添加的。它终止一个 ONNXLoop/Scan/IfOp 区域。

Traits: AlwaysSpeculatableImplTrait, HasOnnxSubgraphOpInterface, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), RegionBranchTerminatorOpInterface

效果: MemoryEffects::Effect{}

操作数

操作数	描述
`操作数`	任意类型的变长序列

`onnx.ZipMap` (ONNXZipMapOp)

ONNX ZipMap 操作

从输入和属性创建映射。
值由输入张量提供，而键由属性指定。必须在 classlabels_strings 或 classlabels_int64s 中提供键（但不能同时提供两者）。
张量的列与属性指定的键一一对应。列的数量必须与键的数量相同。

特性: AlwaysSpeculatableImplTrait

接口: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ShapeHelperOpInterface, ShapeInferenceOpInterface

效果: MemoryEffects::Effect{}

属性

属性	MLIR 类型	描述
`classlabels_int64s`	::mlir::ArrayAttr	64位整型数组属性
`classlabels_strings`	::mlir::ArrayAttr	字符串数组属性

操作数

操作数	描述
`X`	32位浮点数值的张量

结果

结果	描述
`Z`	SeqType 包含元组，元组中的元素可以是字符串类型值或 32位浮点值的任意组合；或 SeqType 包含元组，元组中的元素可以是 64位无符号整数值或 32位浮点值的任意组合。

onnx.Abs (ONNXAbsOp)

操作数

结果

onnx.Acos (ONNXAcosOp)

操作数

结果

onnx.Acosh (ONNXAcoshOp)

操作数

结果

onnx.Adagrad (ONNXAdagradOp)

属性

操作数

结果

onnx.Adam (ONNXAdamOp)

属性

操作数

结果

onnx.Add (ONNXAddOp)

操作数

结果

onnx.And (ONNXAndOp)

操作数

结果

onnx.ArgMax (ONNXArgMaxOp)

属性

操作数

结果

onnx.ArgMin (ONNXArgMinOp)

属性

操作数

结果

onnx.ArrayFeatureExtractor (ONNXArrayFeatureExtractorOp)

操作数

结果

onnx.Asin (ONNXAsinOp)

操作数

结果

onnx.Asinh (ONNXAsinhOp)

操作数

结果

onnx.Atan (ONNXAtanOp)

操作数

结果

onnx.Atanh (ONNXAtanhOp)

操作数

结果

onnx.AveragePool (ONNXAveragePoolOp)

属性

操作数

结果

onnx.BatchNormalizationInferenceMode (ONNXBatchNormalizationInferenceModeOp)

属性

操作数

结果

onnx.BatchNormalization (ONNXBatchNormalizationOp)

属性

操作数

结果

onnx.Bernoulli (ONNXBernoulliOp)

属性

操作数

结果

onnx.Binarizer (ONNXBinarizerOp)

属性

操作数

结果

onnx.BitShift (ONNXBitShiftOp)

属性

操作数

结果

onnx.BitwiseAnd (ONNXBitwiseAndOp)

操作数

结果

onnx.BitwiseNot (ONNXBitwiseNotOp)

操作数

结果

onnx.BitwiseOr (ONNXBitwiseOrOp)

操作数

结果

onnx.BitwiseXor (ONNXBitwiseXorOp)

`onnx.Abs` (ONNXAbsOp)

`onnx.Acos` (ONNXAcosOp)

`onnx.Acosh` (ONNXAcoshOp)

`onnx.Adagrad` (ONNXAdagradOp)

`onnx.Adam` (ONNXAdamOp)

`onnx.Add` (ONNXAddOp)

`onnx.And` (ONNXAndOp)

`onnx.ArgMax` (ONNXArgMaxOp)

`onnx.ArgMin` (ONNXArgMinOp)

`onnx.ArrayFeatureExtractor` (ONNXArrayFeatureExtractorOp)

`onnx.Asin` (ONNXAsinOp)

`onnx.Asinh` (ONNXAsinhOp)

`onnx.Atan` (ONNXAtanOp)

`onnx.Atanh` (ONNXAtanhOp)

`onnx.AveragePool` (ONNXAveragePoolOp)

`onnx.BatchNormalizationInferenceMode` (ONNXBatchNormalizationInferenceModeOp)

`onnx.BatchNormalization` (ONNXBatchNormalizationOp)

`onnx.Bernoulli` (ONNXBernoulliOp)

`onnx.Binarizer` (ONNXBinarizerOp)

`onnx.BitShift` (ONNXBitShiftOp)

`onnx.BitwiseAnd` (ONNXBitwiseAndOp)

`onnx.BitwiseNot` (ONNXBitwiseNotOp)

`onnx.BitwiseOr` (ONNXBitwiseOrOp)

`onnx.BitwiseXor` (ONNXBitwiseXorOp)

`onnx.BlackmanWindow` (ONNXBlackmanWindowOp)

`onnx.CastLike` (ONNXCastLikeOp)

`onnx.CastMap` (ONNXCastMapOp)

`onnx.Cast` (ONNXCastOp)

`onnx.CategoryMapper` (ONNXCategoryMapperOp)

`onnx.Ceil` (ONNXCeilOp)

`onnx.Celu` (ONNXCeluOp)

`onnx.CenterCropPad` (ONNXCenterCropPadOp)

`onnx.Clip` (ONNXClipOp)

`onnx.ClipV11` (ONNXClipV11Op)

`onnx.ClipV12` (ONNXClipV12Op)

`onnx.ClipV6` (ONNXClipV6Op)

`onnx.Col2Im` (ONNXCol2ImOp)

`onnx.Compress` (ONNXCompressOp)

`onnx.ConcatFromSequence` (ONNXConcatFromSequenceOp)

`onnx.Concat` (ONNXConcatOp)

`onnx.ConcatShapeTranspose` (ONNXConcatShapeTransposeOp)