OpenXLA Project

Halaman ini diterjemahkan oleh Cloud Translation API.

`-chlo-legalize-to-stablehlo`

Mengonversi dari alur operasi CHLO ke operasi StableHLO dan Shape

`-shape-legalize-to-stablehlo`

Membuat operasi terkait bentuk menjadi legal untuk StableHLO.

Kartu eksperimental yang melegalkan operasi terkait bentuk ke operasi StableHLO.

Menggabungkan komputasi bentuk dan data melalui kartu opsional akan memungkinkan ekosistem StableHLO berpotensi memanfaatkan pipeline kompilasi yang menggunakan operasi StableHLO untuk membuat model dinamisme.

`-stablehlo-aggressive-folder`

Melipat operasi StableHLO

Opsi

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

`-stablehlo-aggressive-simplification`

Mengonversi operasi StableHLO menjadi kanonis

`-stablehlo-canonicalize-dynamism`

Mengonvergensi operasi StableHLO dinamis menjadi operasi statis.

Mengganti operasi StableHLO dinamis seperti DynamicReshapeOp dengan counterpart statis yang sesuai seperti DynamicReshapeOp ke ReshapeOp atau DynamicBroadcastInDim ke BroadcastInDim jika semua elemen dinamis dari op ini sebenarnya adalah konstanta.

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

Ekspander kompatibilitas untuk operasi StableHLO.

Operasi StableHLO mendapatkan update atau operasi baru diperkenalkan di versi terbaru. Kartu keikutsertaan ini memperluas kompatibilitas mundur dengan versi StableHLO lama dengan mendekomposisi operasi StableHLO yang lebih baru menjadi operasi yang setara yang didukung oleh versi lama tersebut.

Mengapa ini adalah kartu keikutsertaan?

Terkadang, peningkatan op StableHLO digunakan untuk sangat menyederhanakan penanganan pola umum tertentu di ekosistem OpenXLA. Hal ini mencakup hal-hal seperti TanOp, yang memiliki dukungan framework dan compiler yang tinggi, serta dimensi pengelompokan pengumpulan/penyebaran, yang dapat direpresentasikan menggunakan slice, tetapi membuat sharding jauh lebih sulit. Untuk kategori fitur baru ini, kami tidak menawarkan downgrade otomatis, karena dapat menghapus informasi penting yang digunakan dalam pengoptimalan berikutnya. Kartu ini dapat digunakan untuk memperluas operasi ini berdasarkan versi target untuk memaksimalkan kompatibilitas dengan mengorbankan kompilasi yang berpotensi kurang optimal.

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

Opsi

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

`-stablehlo-convert-to-signless`

Teruskan untuk mengubah IR menjadi bilangan bulat tanpa tanda tangan.

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

Mengganti operasi gabungan dengan panggilan ke dekomposisinya.

Mengganti operasi gabungan dengan panggilan ke dekomposisinya, misalnya, di bawah ini:

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

Akan menjadi:

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

Subkumpulan komposit dapat dikecualikan dari transformasi ini menggunakan flag "except", misalnya:

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

Opsi

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

`-stablehlo-legalize-deprecated-ops`

Legalkan operasi yang tidak digunakan lagi ke operasi yang didukung dengan baik.

RFC Penghentian Opset StableHLO v1.0 (#2283) mengusulkan untuk menghapus beberapa operasi yang redundan. Kartu ini membantu mengevaluasi dampak penghapusan op ini di berbagai pipeline kompilasi dengan melegalkannya ke op yang didukung jangka panjang.

Opsi

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

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

Menggabungkan pola (de-kuantisasi, operasi floating point, dan kuantisasi) ke dalam operasi kuantisasi StableHLO

Menggabungkan pola (de-kuantisasi, operasi floating point, dan kuantisasi) ke dalam operasi kuantisasi StableHLO Catatan: Kartu tidak menghapus operasi yang sudah ada. Misalnya, program berikut

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

Akan menjadi:

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`

Konversi dari operasi kuantisasi StableHLO ke operasi matematika primitif StableHLO.

Mengonversi program StableHLO menggunakan jenis UniformQuantized ke operasi matematika bilangan bulat yang setara secara semantik.

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

Akan menjadi:

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`

Dekomposisi operasi StableHLO yang terkuantisasi ke pola (dekuantisasi, operasi floating point, dan kuantisasi).

Dekomposisi program kuantisasi StableHLO menggunakan operasi kuantisasi/dekuantisasi seragam. Misalnya, program berikut

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

Akan menjadi:

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`

Mengizinkan StableHLO ke VHLO.

`-stablehlo-refine-arguments`

Meningkatkan bentuk argumen fungsi utama.

Mengubah argumen fungsi utama menggunakan tanda tangan jenis input. Menggabungkan argumen dalam custom_call @stablehlo.shape_refinement_operand_wrapper agar IR tetap valid sebelum penyempurnaan bentuk dijalankan.

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

refinedTypesOption dapat digunakan untuk menentukan daftar jenis yang difilter. Hal ini dapat ditentukan di MLIR dengan --types='tensor<...>,tensor<...>', atau diteruskan ke metode pembuatan kartu. Daftar jenis peningkatan harus menentukan jenis setiap argumen ke metode main yang ditingkatkan.

Opsi

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

`-stablehlo-refine-shapes`

Meningkatkan kualitas bentuk di seluruh program StableHLO.

Menjelaskan program StableHLO yang meningkatkan kualitas bentuk dalam operasi.

Kasus penggunaan unggulan untuk kartu ini adalah mengkhususkan program berbentuk dinamis ke bentuk statis. Jika program StableHLO berbentuk dinamis memiliki struktur yang tepat, memperbarui jenis argumennya dari bentuk dinamis menjadi bentuk statis dan menjalankan penerusan ini akan menyebarkan bentuk statis di seluruh program.

Kartu ini menghapus custom_call @shape_refinement_operand_wrapper dengan mengganti penggunaan hasil dengan operand secara langsung, dan menyebarkan bentuk statis di seluruh program.

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

Modul yang valid untuk penyempurnaan bentuk harus memiliki properti berikut:

Semua bentuk dinamis hanya bergantung pada bentuk input (tidak ada dependensi bentuk pada konten array input). Kita menyebut operasi yang hanya bergantung secara transitif pada bentuk input (misalnya, seperti yang diberikan oleh stablehlo.get_dimension_size) atau konstanta global seperti nilai bilangan bulat simbolis yang di-resolve (yaitu tensor : A = 5), sebagai operasi dimension. Semua nilai dimensi dapat di-resolve ke konstanta melalui penggabungan konstanta antar-prosedural.
Fungsi perantara dapat menggunakan sejumlah argumen token (berjenis !stablehlo.token) di awal daftar argumen, diikuti dengan beberapa argumen konstanta global yang merupakan skalar bilangan bulat konstan, seperti nilai bilangan bulat simbolis yang di-resolve (yaitu tensor : A = 5).
Beberapa fungsi perantara dapat menampilkan komputasi pada konstanta global, yaitu floordiv pada nilai symint. Fungsi ini ditunjukkan dengan hanya menampilkan nilai konstan setelah penyempurnaan. Fungsi ini disisipkan.
Semua panggilan ke satu fungsi di-resolve ke bentuk argumen yang sama, dan tidak ada panggilan fungsi rekursif / ko-rekursif yang dilakukan. ### -vhlo-legalize-to-stablehlo

Mengesahkan VHLO ke StableHLO.

`-vhlo-to-version`

Mengonversi antar-versi VHLO.

Opsi

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