OpenXLA Project

Diese Seite wurde von der Cloud Translation API übersetzt.

`-chlo-legalize-to-stablehlo`

Legalisiert den Ablauf von CHLO-Ops zu StableHLO- und Shape-Ops

`-shape-legalize-to-stablehlo`

Formenbezogene Vorgänge für StableHLO legalisieren

Ein experimenteller Pass, der formbezogene Vorgänge für StableHLO-Vorgänge legalisiert.

Wenn Form- und Datenberechnungen über einen optionalen Pass zusammengeführt werden, kann das StableHLO-System möglicherweise die Kompilierungspipelines nutzen, die mit StableHLO-Vorgängen Dynamik modellieren.

`-stablehlo-aggressive-folder`

StableHLO-Vorgänge zusammenführen

Optionen

-fold-float : Allow for potentially lossy computations using float type.

`-stablehlo-aggressive-simplification`

StableHLO-Vorgänge kanonisieren

`-stablehlo-canonicalize-dynamism`

Kanonisiert dynamische StableHLO-Vorgänge in statische Vorgänge.

Ersetzt dynamische StableHLO-Vorgänge wie DynamicReshapeOp durch die entsprechenden statischen Pendants wie DynamicReshapeOp durch ReshapeOp oder DynamicBroadcastInDim durch BroadcastInDim, wenn alle dynamischen Elemente dieser Vorgänge tatsächlich Konstanten sind.

  %c = stablehlo.constant dense<16> : tensor<1xi32>
  %0 = stablehlo.dynamic_broadcast_in_dim %cst, %c, dims = [] : (tensor<f32>, tensor<1xi32>) -> tensor<16xf32>

  ==>

  %0 = stablehlo.broadcast_in_dim %cst, dims = [] : (tensor<f32>) -> tensor<16xf32>

`-stablehlo-compatibility-expander`

Kompatibilitätserweiterung für StableHLO-Vorgänge

StableHLO-Ops werden in den neuesten Versionen aktualisiert oder es werden neue Ops eingeführt. Diese Option erweitert die Abwärtskompatibilität mit älteren StableHLO-Versionen, indem neuere StableHLO-Vorgänge in äquivalente Vorgänge zerlegt werden, die von diesen älteren Versionen unterstützt werden.

Warum ist dieser Ausweis ein Opt-in-Ausweis?

Gelegentlich werden StableHLO-Optimierungen verwendet, um die Verarbeitung bestimmter gängiger Muster im OpenXLA-System erheblich zu vereinfachen. Dazu gehören beispielsweise TanOp, das eine hohe Framework- und Compilerunterstützung bietet, sowie Gather/Scatter-Batching-Dimensionen, die mit Slices dargestellt werden können, das Sharding aber viel schwieriger machen. Für diese Kategorie von neuen Funktionen bieten wir kein automatisches Downgrade an, da dadurch wichtige Informationen verloren gehen können, die bei nachfolgenden Optimierungen verwendet werden. Mit diesem Pass können diese Vorgänge basierend auf einer Zielversion erweitert werden, um die Kompatibilität zu maximieren, was jedoch zu einer potenziell weniger optimalen Kompilierung führen kann.

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %1 = stablehlo.tan %arg0 : tensor<4xf64>
  func.return %1 : tensor<4xf64>
}

==>

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %0 = stablehlo.sine %arg0 : tensor<4xf64>
  %1 = stablehlo.cosine %arg0 : tensor<4xf64>
  %2 = stablehlo.divide %0, %1 : tensor<4xf64>
  return %2 : tensor<4xf64>
}

Optionen

-target : The target version. Must be a version of the form #.#.#.

`-stablehlo-convert-to-signless`

Übergeben, um die IR in vorzeichenlose Ganzzahlen umzuwandeln.

`-stablehlo-legalize-composite-to-call`

Ersetzt zusammengesetzte Vorgänge durch einen Aufruf ihrer Dekomposition.

Ersetzt zusammengesetzte Vorgänge durch einen Aufruf ihrer Dekomposition, z.B. den folgenden:

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)

Mit dem Flag „except“ kann eine Teilmenge der Kompositionen von dieser Transformation ausgenommen werden, 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`

Veraltete Vorgänge durch gut unterstützte Vorgänge ersetzen.

Im RFC zur Einstellung von OpSets für StableHLO v1.0 (#2283) wird vorgeschlagen, mehrere redundante Vorgänge zu entfernen. Mit diesem Pass können die Auswirkungen dieser Entfernungen in verschiedenen Pipeline-Kompilierungen bewertet werden, indem sie in ihre langfristig unterstützten Pendants umgewandelt werden.

Optionen

-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.

`-stablehlo-legalize-qdq-to-quantized-op`

Muster (Quantisierung aufheben, Gleitkommaoperation und Quantisierung) in quantisierten StableHLO-Vorgang einfügen

Muster (Quantisierung aufheben, Gleitkommaoperation und Quantisierung) in quantisierten StableHLO-Vorgang zusammenführen Hinweis: Der Pass löscht keine vorhandenen Vorgänge. Beispiel: 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`

Quantisierte StableHLO-Vorgänge in primitive StableHLO-Mathematische-Vorgänge umwandeln

StableHLO-Programme mit UniformQuantized-Typen in semantisch äquivalente Ganzzahlarithmetikumwandlungen konvertieren

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`

Quantisierten StableHLO-Vorgang in das Muster „Quantisierung aufheben, Gleitkommaoperation und Quantisierung“ zerlegen.

Quantisierte StableHLO-Programme mithilfe einheitlicher Quantisierungs-/Dequantisierungsvorgänge zerlegen. Beispiel:

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`

StableHLO für VHLO legalisieren.

`-stablehlo-refine-arguments`

Die Argumentformen der Hauptfunktion werden optimiert.

Ändert die Argumente der Hauptfunktion mithilfe der Signatur des Eingabetyps. Argumente werden in custom_call @stablehlo.shape_refinement_operand_wrapper eingeschlossen, damit die IR gültig bleibt, bevor die Formoptimierung ausgeführt wird.

func.func public @main(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  ...
}

==>

func.func public @main(%arg0: tensor<16xf32>) -> tensor<?xf32> {
  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
    : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  ...

Mit refinedTypesOption können Sie eine Liste von verfeinerten Typen angeben. Dieser kann in MLIR mit --types='tensor<...>,tensor<...>' angegeben oder an die Methode „create“ übergeben werden. In der Liste der Verfeinerungstypen muss der Typ jedes Arguments für die zu verfeinernde main-Methode angegeben werden.

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 optimieren.

Ein StableHLO-Programm wird durchlaufen, um Formen innerhalb von Operationen zu optimieren.

Der Hauptanwendungsfall für diese Karte/dieses Ticket besteht darin, dynamisch geformte Programme auf statische Formen auszurichten. Wenn ein dynamisch geformtes StableHLO-Programm die richtige Struktur hat, werden durch das Aktualisieren der Argumenttypen von dynamischen zu statischen Formen und das Ausführen dieses Durchlaufs statische Formen im gesamten Programm übernommen.

Mit diesem Pass wird custom_call @shape_refinement_operand_wrapper entfernt, indem die Verwendungen des Ergebnisses direkt durch den Operanden ersetzt werden. Außerdem werden statische Formen im gesamten Programm weitergegeben.

  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
      : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  %1 = stablehlo.add %0, %0 : tensor<?xf32>

  ==>

  %1 = stablehlo.add %arg0, %arg0 : tensor<16xf32>

Module, die für die Formoptimierung zulässig sind, müssen die folgenden Eigenschaften haben:

Alle dynamischen Formen hängen nur von den Eingabeformen ab (keine Formabhängigkeit vom Inhalt des Eingabearrays). Als dimension-Vorgänge bezeichnen wir solche, die nur transitiven von den Eingabeformen abhängen (z.B. wie von stablehlo.get_dimension_size angegeben) oder von globalen Konstanten wie den aufgelösten Werten symbolischer Ganzzahlen (z.B. Tensor : A = 5). Alle Dimensionswerte können durch interprozedurales Konstanten-Falten in Konstanten aufgelöst werden.
Zwischenfunktionen können zu Beginn der Argumentliste eine Reihe von Tokenargumenten (vom Typ !stablehlo.token) haben, gefolgt von einigen globalen Konstantenargumenten, die konstante Ganzzahlskaläre sind, z. B. die aufgelösten Werte symbolischer Ganzzahlen (z. B. tensor : A = 5).
Einige Zwischenfunktionen geben möglicherweise Berechnungen für globale Konstanten zurück, z.B. floordiv für symint-Werte. Diese Funktionen geben nach der Optimierung nur konstante Werte zurück. Diese Funktionen sind inline.
Alle Aufrufe einer einzelnen Funktion werden auf dieselben Argumentformen zurückgeführt und es werden keine rekursiven / kooperativen Funktionsaufrufe ausgeführt. ### -vhlo-legalize-to-stablehlo

VHLO zu StableHLO legalisieren.

`-vhlo-to-version`

Zwischen Versionen von VHLO konvertieren

Optionen

-target : The target version. Must be a version of the form #.#.# .