OpenXLA Project

Ta strona została przetłumaczona przez Cloud Translation API.

`-chlo-legalize-to-stablehlo`

Legalizuje przepływ danych z poziomu CHLO do StableHLO i Shape

`-shape-legalize-to-stablehlo`

Legalize shape-related ops to StableHlo.

Eksperymentalny pass, który legalizuje operacje związane z kształtem dla operacji StableHLO.

Połączenie obliczeń kształtu i danych za pomocą opcjonalnego przejścia umożliwi ekosystemowi StableHLO potencjalne wykorzystanie przepływów kompilacji, które wykorzystują operacje StableHLO do modelowania dynamiki.

`-stablehlo-aggressive-folder`

Zwijanie operacji StableHLO

Opcje

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

`-stablehlo-aggressive-simplification`

Kanonizuje operacje StableHLO

`-stablehlo-canonicalize-dynamism`

Kanonizuje dynamiczne operacje StableHLO w operacje statycznej.

Zastępuje dynamiczne operacje StableHLO, takie jak DynamicReshapeOp, ich odpowiednikami statycznymi, np. DynamicReshapeOp na ReshapeOp lub DynamicBroadcastInDim na BroadcastInDim, jeśli wszystkie dynamiczne elementy tych operacji są w rzeczywistości stałymi.

  %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`

Rozszerzenie zgodności dla operacji StableHLO.

W najnowszych wersjach StableHLO pojawiają się aktualizacje lub nowe opcje. Ta opcja zwiększa zgodność wsteczną ze starszymi wersjami StableHLO, ponieważ rozkłada nowsze operacje StableHLO na operacje równoważne obsługiwane przez te starsze wersje.

Dlaczego jest to karta dla zainteresowanych?

Czasami w celu uproszczenia obsługi niektórych typowych wzorców w ekosystemie OpenXLA stosuje się ulepszenia operacji StableHLO. Dotyczy to np. instrukcji TanOp, która ma wysoką obsługę frameworku i kompilatora, a także wymiarów zbiorczego zbierania/rozpraszania, które można reprezentować za pomocą wycinków, ale znacznie utrudnia dzielenie. W przypadku tej kategorii nowych funkcji nie oferujemy automatycznego obniżenia wersji, ponieważ może to spowodować utratę ważnych informacji wykorzystywanych w kolejnych optymalizacjach. Ten etap może służyć do rozszerzania tych operacji na podstawie wersji docelowej w celu maksymalizacji zgodności kosztem potencjalnie mniej optymalnej kompilacji.

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>
}

Opcje

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

`-stablehlo-convert-to-signless`

Przekazywanie, aby przekształcić IR w liczby całkowite bez znaku.

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

Zastępuje operacje złożone wywołaniem ich dekompozycji.

Zastępuje operacje złożone wywołaniem ich rozkładu, np.:

stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
  decomposition = @bar,
  version = 1,
  composite_attributes = {
    "my_attribute": "my_value"
  }
}

Zmieni się w:

func.call @bar(%arg0, %arg1)

Podzbiór kompozycji można wykluczyć z tej transformacji, używając flagi „except”, np.:

stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'

Opcje

-except : Names of composites that should not be replaced with calls.

`-stablehlo-legalize-deprecated-ops`

Zlegalizować przestarzałe operacje jako dobrze obsługiwane operacje.

W RFC StableHLO v1.0 Opset Deprecations (#2283) proponujemy usunięcie kilku zbędnych operacji. Ten etap pozwala ocenić wpływ tych zmian w różnych przepływach kompilacji przez legalizację ich odpowiedników w wersjach długoterminowych.

Opcje

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

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

Połączenie (dekwantyzacji, operacji zmiennoprzecinkowej i kwantyzacji) w ramach operacji kwantyzacji StableHLO

Przekształcanie (dekwantyzacji, operacji zmiennoprzecinkowej i kwantyzacji) w operacji kwantyzacji StableHLO. Uwaga: przejście nie usuwa żadnej wcześniejszej operacji.

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>>
}

Zmieni się w:

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`

Przekształcanie zaokrąglonych operacji StableHLO w proste operacje matematyczne StableHLO.

Przekształcanie programów StableHLO korzystających z typów UniformQuantized na semantycznie równoważne operacje arytmetyczne na liczbach całkowitych.

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>>
}

Zmieni się w:

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`

Zdekomponuj zaszyfrowaną operację StableHLO do wzorca (deszyfrowanie, operacja zmiennoprzecinkowa i szyfrowanie).

Rozkładanie zaprogramowanych za pomocą StableHLO programów za pomocą operacji jednolitego kodowania i dekodowania. Na przykład program

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>>
}

Zmieni się w:

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`

Zlegalizuj StableHLO jako VHLO.

`-stablehlo-refine-arguments`

Uszczegóławia kształty argumentów funkcji głównej.

Modyfikuje argumenty funkcji głównej za pomocą sygnatury typu danych wejściowych. Argumenty są ujęte w funkcji custom_call @stablehlo.shape_refinement_operand_wrapper, aby zachować ważność IR przed uruchomieniem udoskonalenia kształtu.

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

Za pomocą elementu refinedTypesOption możesz określić listę doprecyzowanych typów. Można go określić w MLIR za pomocą --types='tensor<...>,tensor<...>' lub przekazać metodzie pass create. Lista typów doprecyzowania musi określać typ każdego argumentu metody main, która ma zostać doprecyzowana.

Opcje

-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'

`-stablehlo-refine-shapes`

Udoskonalenie kształtów w ramach programu StableHLO.

Przewodnik po programie StableHLO służącym do ulepszania kształtów w ramach operacji.

Głównym zastosowaniem tej karty jest dostosowanie programów o kształtach dynamicznych do kształtów statycznych. Jeśli program StableHLO o kształcie dynamicznym ma odpowiednią strukturę, zmiana typów argumentów z kształtów dynamicznych na statyczne i wykonanie tego przejścia spowoduje rozprzestrzenianie się kształtów statycznych w programie.

Ten krok usuwa custom_call @shape_refinement_operand_wrapper, zastępując użycie wyniku bezpośrednio przez operand, i rozprzestrzenia statyczne kształty w całym programie.

  %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>

Moduły kwalifikujące się do użycia w ramach udoskonalenia kształtu muszą mieć te właściwości:

Wszystkie kształty dynamiczne zależą tylko od kształtów wejściowych (brak zależności od zawartości tablicy wejściowej). Operacje, które zależą pośrednio tylko od kształtów danych wejściowych (np. zgodnie z stablehlo.get_dimension_size) lub stałych globalnych, takich jak rozwiązane wartości symbolicznych liczb całkowitych (np. tensor : A = 5), nazywamy operacjami dimension. Wszystkie wartości wymiarów można przekształcić w stałe za pomocą składania stałych międzyprocedurowych.
Funkcje pośrednie mogą przyjmować na początku listy argumentów pewną liczbę argumentów tokenów (typu !stablehlo.token), a następnie niektóre argumenty stałych globalnych, które są stałymi skalarami całkowitymi, np.rozwiązane wartości symbolicznych liczb całkowitych (np. tensor : A = 5).
Niektóre funkcje pośrednie mogą zwracać obliczenia na podstawie stałych globalnych, czyli floordiv na podstawie wartości symint. Te funkcje są wskazywane przez zwracanie wartości stałych po ulepszeniu. Te funkcje są wstawiane w kod.
Wszystkie wywołania jednej funkcji prowadzą do tego samego kształtu argumentu i nie są wykonywane żadne wywołania funkcji rekurencyjnych ani współrekurencyjnych. ### -vhlo-legalize-to-stablehlo

Legalize VHLO to StableHLO.

`-vhlo-to-version`

Przekształcanie wersji VHLO

Opcje

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