-chlo-legalize-to-stablehlo
Legaliza el flujo de operaciones de CHLO a StableHLO y las operaciones Shape.
-shape-legalize-to-stablehlo
Legaliza las operaciones relacionadas con formas en StableHLO.
Pase experimental que legaliza las operaciones relacionadas con formas para las operaciones de StableHLO
Unir cálculos de forma y datos a través de un pase opcional permitir que el ecosistema StableHLO aproveche canalizaciones de compilación que usan operaciones StableHLO para modelar el dinamismo.
-stablehlo-aggressive-folder
Operaciones de StableHLO de Fold
Opciones
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
Canonicaliza las operaciones de StableHLO
-stablehlo-canonicalize-dynamism
Canonicaliza las operaciones dinámicas de StableHLO en operaciones estáticas.
Reemplaza las operaciones dinámicas de StableHLO, como DynamicReshapeOp, por las operaciones equivalentes estáticos como ReshapeOp si todos los elementos dinámicos de estas operaciones son en realidad constantes.
Por ejemplo, si el operando output_shape de DynamicReshapeOp es una constante valor, la operación se puede transformar en ReshapeOp.
-stablehlo-convert-to-signless
Pasa a la transformación del IR para que esté en números enteros sin signo.
-stablehlo-legalize-composite-to-call
Reemplaza las operaciones compuestas con una llamada a su descomposición.
Reemplaza las operaciones compuestas con una llamada a su descomposición, p.ej., lo siguiente:
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
Será:
func.call @bar(%arg0, %arg1)
Se puede excluir un subconjunto de compuestos de esta transformación mediante la "excepto" marca, p.ej.:
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
Opciones
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
Legaliza las operaciones obsoletas en operaciones con mayor compatibilidad.
El RFC de bajas de conjunto de operaciones de StableHLO v1.0 (#2283) propone quitar varias operaciones redundantes. Este pase ayuda a evaluar el impacto de las operaciones de datos en varias canalizaciones de compilación a través de su legalización con el apoyo a largo plazo.
Opciones
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
Fusiona (descuantizar, operación de punto flotante y cuantización) en una operación cuantizada StableHLO
Fusiona (descuantización, operación de punto flotante y cuantización) en operación cuantizada StableHLO Nota: El pase no borra ninguna operación preexistente. Por ejemplo, el siguiente programa
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>>
}
Será:
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
Convierte operaciones cuantizadas de StableHLO en operaciones matemáticas primitivas de StableHLO.
Convertir programas StableHLO con tipos UniformQuantized a semánticamente operaciones matemáticas con números enteros equivalentes.
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>>
}
Será:
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
Desglosar la operación StableHLO cuantificada según el patrón (descuantizar, operación de punto flotante y cuantización).
Desglosar programas cuantificados de StableHLO mediante cuantización/decuantización uniforme las operaciones. Por ejemplo, el siguiente programa
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>>
}
Será:
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
Legaliza StableHLO a VHLO
-stablehlo-refine-arguments
Define mejor las formas de argumentos de la función principal.
Modifica los argumentos de la función principal con la firma de tipo de entrada. Une argumentos en custom_call @stablehlo.shape_refinement_operand_wrapper para que el IR sea válido antes de ejecutar el refinamiento de la forma.
Se puede usar refinedTypesOption para especificar una lista de tipos mejor definidos.
Esto se puede especificar en MLIR con --types='tensor<...>,tensor<...>', o
y se pasan al método de creación de pases. La lista de tipos de perfeccionamiento debe especificar
tipo de cada argumento para el método main que se definirá mejor.
Opciones
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
Define mejor las formas en el programa StableHLO.
Se explica un programa de StableHLO que define mejor las formas en las operaciones.
El caso de uso insignia de este pase se especializa en diseñar dinámicamente programas a formas estáticas. Si un programa StableHLO de forma dinámica tiene la la estructura correcta y, luego, actualiza los tipos de argumentos de formas dinámicas a formas estáticas y, al ejecutar este pase, se propagarán las formas estáticas en el programa.
-vhlo-legalize-to-stablehlo
Legaliza VHLO a StableHLO
-vhlo-to-version
Convierte entre versiones de VHLO.
Opciones
-target : The target version. Must be a version of the form #.#.# or 'current'.