-chlo-legalize-to-stablehlo
实现从 CHLO 操作流到 StableHLO 和 Shape 操作的合法性
-shape-legalize-to-stablehlo
将与形状相关的操作合法化为 StableHLO。
一个实验性通行证，可将形状相关操作合法化为 StableHLO 操作。
通过可选传递将形状和数据计算整合在一起， 使 StableHLO 生态系统有可能利用 使用 StableHLO 操作对动态进行建模的编译流水线。
-stablehlo-aggressive-folder
折叠 StableHLO 操作
选项
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
规范 StableHLO 操作
-stablehlo-canonicalize-dynamism
将动态 StableHLO 操作规范化为静态操作。
将 DynamicReshapeOp 等动态 StableHLO 操作替换为相应的 静态对应项（如 ReshapeOp） 实际上是恒定的。
例如，如果 DynamicReshapeOp 的 output_shape 运算数是一个常量 值，就可以将该操作转换为 ReshapeOp。
-stablehlo-convert-to-signless
通过将 IR 转换为无符号整数。
-stablehlo-legalize-composite-to-call
将复合操作替换为调用其分解
将复合操作替换为调用其分解，例如如下：
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
将变为：
func.call @bar(%arg0, %arg1)
您可以使用 “除了”标志，例如：
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
选项
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
将已弃用的操作合法化为得到良好支持的操作。
StableHLO v1.0 Opset 弃用 RFC (#2283) 提议在 执行多项冗余操作此卡券有助于评估这些操作的影响 通过合法化的方式获取 长期支持的类似应用。
选项
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
将（去量化、浮点运算和量化）模式融合为 StableHLO 量化运算
将（去量化、浮点运算和量化）模式融合为 StableHLO 量化运算 注意：此卡券不会删除任何先前存在的操作。 例如，以下程序
func.func @add(%arg0: tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
func.return %2 : tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
}
将变为：
func.func @add(%arg0: tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.abs %arg0 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
%3 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
return %2 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
}
-stablehlo-legalize-quant-to-math
从 StableHLO 量化运算转换为 StableHLO 基元数学运算。
将使用 UniformQuantized 类型的 StableHLO 程序转换为语义 等值的整数数学运算。
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
将变为：
func.func @add(%arg0: tensor<i8>, %arg1: tensor<i8>) -> tensor<i8> {
%0 = stablehlo.convert %arg0 : (tensor<i8>) -> tensor<f32>
%cst = stablehlo.constant dense<0.333333343> : tensor<f32>
%1 = chlo.broadcast_multiply %0, %cst : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_0 = stablehlo.constant dense<2.000000e+00> : tensor<f32>
%2 = chlo.broadcast_add %1, %cst_0 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%3 = stablehlo.round_nearest_even %2 : tensor<f32>
%4 = stablehlo.convert %3 : (tensor<f32>) -> tensor<i32>
%5 = stablehlo.convert %arg1 : (tensor<i8>) -> tensor<f32>
%cst_1 = stablehlo.constant dense<0.666666686> : tensor<f32>
%6 = chlo.broadcast_multiply %5, %cst_1 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_2 = stablehlo.constant dense<1.33333337> : tensor<f32>
%7 = chlo.broadcast_add %6, %cst_2 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%8 = stablehlo.round_nearest_even %7 : tensor<f32>
%9 = stablehlo.convert %8 : (tensor<f32>) -> tensor<i32>
%c = stablehlo.constant dense<2> : tensor<i32>
%10 = chlo.broadcast_add %4, %9 : (tensor<i32>, tensor<i32>) -> tensor<i32>
%11 = chlo.broadcast_subtract %10, %c : (tensor<i32>, tensor<i32>) -> tensor<i32>
%c_3 = stablehlo.constant dense<-128> : tensor<i32>
%c_4 = stablehlo.constant dense<127> : tensor<i32>
%12 = stablehlo.clamp %c_3, %11, %c_4 : tensor<i32>
%13 = stablehlo.convert %12 : (tensor<i32>) -> tensor<i8>
return %13 : tensor<i8>
}
-stablehlo-legalize-quantized-op-to-qdq
将量化的 StableHLO 运算分解为（去量化、浮点运算和量化）模式。
使用统一量化/去量化分解 StableHLO 量化程序 操作。例如，以下程序
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
将变为：
func.func @add(%arg0: tensor<!quant.uniform<i8:f32, 1.000000e+00>>, %arg1: tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<f32>
%1 = stablehlo.uniform_dequantize %arg1 : (tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<f32>
%2 = stablehlo.add %0, %1 : tensor<f32>
%3 = stablehlo.uniform_quantize %2 : (tensor<f32>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
return %3 : tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
}
-stablehlo-legalize-to-vhlo
将 StableHLO 合法化为 VHLO。
-stablehlo-refine-arguments
优化主函数的参数形状。
使用输入类型签名来修改主函数的参数。 将 custom_call @stablehlo.shape_refinement_operand_wrapper 封装参数 以确保 IR 在运行形状优化之前有效。
refinedTypesOption 可用于指定经过优化的类型列表。
这可以在 MLIR 中使用 --types='tensor<...>,tensor<...>' 指定，或
传递给 pass create 方法优化类型列表必须指定
要优化的 main 方法的每个参数的类型。
选项
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
优化 StableHLO 程序中的形状。
详细介绍在操作中优化形状的 StableHLO 程序。
此卡券的旗舰用例专门用于 转换为静态形状。如果动态形状的 StableHLO 程序的 正确的结构，然后将其参数类型从动态形状更新为 静态形状，并运行此卡券将传播静态形状 程序。
-vhlo-legalize-to-stablehlo
将 VHLO 合法化为 StableHLO。
-vhlo-to-version
在 VHLO 的版本之间转换。
选项
-target : The target version. Must be a version of the form #.#.# or 'current'.