-chlo-legalize-to-stablehlo
Der Ablauf von CHLO-Operationen zu StableHLO und Shape-Operationen wird legalisiert
-shape-legalize-to-stablehlo
Formbezogene Vorgänge in StableHLO legalisieren.
Eine experimentelle Karte / ein experimentelles Ticket, das formbezogene Vorgänge für StableHLO-Vorgänge zulässt.
Die Zusammenführung von Form- und Datenberechnungen über eine optionale Karte bzw. ein optionales Ticket ermöglichen es der StableHLO-Umgebung, Kompilierungspipelines, die mit StableHLO-Vorgängen die Dynamik modellieren.
-stablehlo-aggressive-folder
Folds StableHLO-Vorgänge
Optionen
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
Kanonischisiert StableHLO-Vorgänge
-stablehlo-canonicalize-dynamism
Kanonischisiert dynamische StableHLO-Vorgänge in statische Operationen.
Ersetzt dynamische StableHLO-Operationen wie DynamicReshapeOp durch die entsprechenden statische Entsprechungen wie ReshapeOp, wenn alle dynamischen Elemente dieser Operationen tatsächlich konstant sind.
Wenn beispielsweise der Operand "output_shape" von DynamicReshapeOp eine Konstante ist, kann der Vorgang in ReshapeOp umgewandelt werden.
-stablehlo-convert-to-signless
Übergeben, um die IR in vorzeichenlose Ganzzahlen umzuwandeln.
-stablehlo-legalize-composite-to-call
Ersetzt zusammengesetzte Vorgänge durch einen Aufruf zu ihrer Zerlegung
Ersetzt zusammengesetzte Operationen durch einen Aufruf zu ihrer Zerlegung, z.B. unten:
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
Wird zu:
func.call @bar(%arg0, %arg1)
Eine Teilmenge von zusammengesetzten Werten kann von dieser Transformation mithilfe der Methode "außer" Flag, z.B.:
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
Optionen
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
Eingestellte Vorgänge für gut unterstützte Vorgänge legalisieren.
Der StableHLO v1.0 Opset Deprecations RFC (#2283) schlägt vor, mehrere redundante Vorgänge. Diese Karte bzw. dieses Ticket hilft bei der Bewertung der Auswirkungen dieser Operationen in verschiedenen Kompilierungspipelines, indem sie in ihren langfristig unterstützten Gegenstücken.
Optionen
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
Muster in StableHLO-quantisierten Operationen zusammenführen (de-quantisieren, Gleitkommaoperation und quantisieren)
Muster (de-quantisieren, Gleitkommaoperation und Quantisierung) in StableHLO-quantisierte Operation zusammenführen Hinweis: Durch die Karte bzw. das Ticket werden bereits vorhandene Vorgänge nicht gelöscht. Das folgende Programm
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>>
}
Wird zu:
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
Wandeln Sie von StableHLO quantisierten Operationen in primitive StableHLO-Operationen um.
StableHLO-Programme mit UniformQuantized-Typen in semantische gleichwertigen mathematischen ganzzahligen Operationen.
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>>
}
Wird zu:
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
Zerlegen Sie den quantisierten StableHLO-Vorgang in ein Muster (dequantisieren, Gleitkommaoperation und quantisieren).
StableHLO-quantisierte Programme mit einheitlicher Quantisierung/Dequantisierung zerlegen Geschäftsabläufe. Das folgende Programm
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>>
}
Wird zu:
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
Stabilisierung von StableHLO zu VHLO
-stablehlo-refine-arguments
Verfeinert die Argumentformen der Hauptfunktion.
Ändert die Argumente der Hauptfunktion mithilfe der Signatur des Eingabetyps. Fügt Argumente in custom_call @stablehlo.shape_refinement_operand_wrapper ein damit der IR-Wert gültig bleibt, bevor die Formverfeinerung ausgeführt wird.
Mit refinedTypesOption kann eine Liste mit optimierten Typen angegeben werden.
Dies kann in MLIR mit --types='tensor<...>,tensor<...>' angegeben werden oder
an die Methode zum Erstellen von Karten/Tickets übergeben. In der Liste der Suchfiltertypen muss Folgendes angegeben werden:
Typ jedes Arguments für die Methode main, die optimiert wird.
Optionen
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
Formen in einem StableHLO-Programm werden verfeinert.
Durchläuft ein StableHLO-Programm, um Formen in Ops zu verfeinern.
Der wichtigste Anwendungsfall für diese Karte bzw. dieses Ticket besteht darin, dynamisch geformte auf statische Shapes übertragen. Wenn ein dynamisch geformtes StableHLO-Programm und die Argumenttypen von dynamischen Formen auf Wenn Sie diese Karte bzw. dieses Ticket ausführen, Programm teilnehmen.
-vhlo-legalize-to-stablehlo
VHLO als StableHLO legalisieren.
-vhlo-to-version
Konvertieren Sie zwischen VHLO-Versionen.
Optionen
-target : The target version. Must be a version of the form #.#.# or 'current'.