-chlo-legalize-to-stablehlo

Melegalkan dari alur operasi CHLO ke StableHLO dan operasi Shape

-shape-legalize-to-stablehlo

Melegalkan operasi terkait bentuk ke StableHLO.

Penerusan eksperimental yang melegalkan operasi terkait bentuk ke operasi StableHLO.

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

-stablehlo-canonicalize-dynamism

Mengubah operasi StableHLO dinamis menjadi operasi statis.

Menggantikan operasi StableHLO dinamis seperti DynamicReshapeOp dengan operasi statis yang sesuai seperti DynamicReshapeOp ke ReshapeOp atau DynamicBroadcastInDim ke BroadcastInDim jika semua elemen dinamis dari operasi 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-check-shape-assertions

_Check stablehlo.custom_call @shapeassertion ops.

Validasi panggilan kustom shape_assertion.

Pernyataan bentuk memvalidasi batasan pada dimensi dinamis di StableHLO. Misalnya, jika framework perlu menerapkan batasan DimA < 2, IR berikut dapat dikeluarkan:

%dimA = <get_dimension_size or input arg> : tensor<i32>
%c2 = stablehlo.constant dense<2> : tensor<i32>
%is_lt = stablehlo.compare LT %dimA, %c2 : tensor<i1>
stablehlo.custom_call @shape_assertion(%is_lt) { error_message = "DimA must be less than 2" }

Setelah lulus, jika bentuknya benar, stablehlo.custom_call akan dihapus.

Opsi

-enable-shape-assertions : Whether shape assertions may generate errors.

-stablehlo-compatibility-expander

Pengembang kompatibilitas untuk operasi StableHLO.

Operasi StableHLO mendapatkan update atau operasi baru diperkenalkan dalam versi terbaru. Pilihan ikut serta ini memperluas kompatibilitas mundur dengan versi StableHLO lama dengan menguraikan operasi StableHLO baru menjadi operasi yang setara yang didukung oleh versi lama tersebut.

Mengapa ini adalah kartu keikutsertaan?

Terkadang, peningkatan kualitas operasi StableHLO digunakan untuk menyederhanakan penanganan pola umum tertentu dalam ekosistem OpenXLA secara signifikan. Hal ini mencakup hal-hal seperti TanOp, yang memiliki dukungan framework dan compiler yang tinggi, serta dimensi batching pengumpulan/penyebaran, yang dapat direpresentasikan menggunakan slice, tetapi membuat sharding menjadi jauh lebih sulit. Untuk kategori fitur baru ini, kami tidak menawarkan downgrade otomatis, karena dapat menghapus informasi penting yang digunakan dalam pengoptimalan berikutnya. Penerusan ini dapat digunakan untuk memperluas operasi ini berdasarkan versi target guna 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-complex-math-expander

Expander untuk operasi matematika kompleks StableHLO.

Operasi matematika kompleks StableHLO adalah dekomposisi menggunakan operasi matematika riil StableHLO.

Pernyataan ini didasarkan pada asumsi bahwa tidak ada hardware yang mendukung bilangan kompleks atau operasi matematika kompleks secara native. Artinya, mekanisme penggantian pada operasi matematika kompleks yang dapat diterapkan oleh compiler, bersifat redundan. Dengan mengaktifkan tahap ini, semua operasi matematika kompleks StableHLO akan diperluas.

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  %1 = stablehlo.sqrt %arg0 : tensor<4xcomplex<f64>>
  func.return %1 : tensor<4xcomplex<f64>>
}

==>

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  TBD
  return %2 : tensor<4xcomplex<f64>>
}

-stablehlo-convert-to-signless

Teruskan untuk mengubah IR agar berada pada bilangan bulat tanpa tanda.

-stablehlo-legalize-composite-to-call

Mengganti operasi komposit dengan panggilan ke dekomposisinya.

Mengganti operasi komposit 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)

Sebagian komposit dapat dikecualikan dari transformasi ini menggunakan tanda "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

Melegalkan operasi yang tidak digunakan lagi menjadi operasi yang didukung dengan baik.

RFC Penghentian Penggunaan Opset StableHLO v1.0 (#2283) mengusulkan penghapusan beberapa operasi yang redundan. Penerusan ini membantu mengevaluasi dampak penghapusan op ini dalam berbagai pipeline kompilasi dengan melegalkan penghapusan tersebut ke rekanan yang didukung dalam 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 terkuantisasi StableHLO

Pola gabungan (de-kuantisasi, operasi floating point, dan kuantisasi) ke dalam operasi terkuantisasi StableHLO Catatan: Pass 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

Mengonversi dari operasi terkuantisasi StableHLO ke operasi matematika primitif StableHLO.

Mengonversi program StableHLO yang 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

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

Dekomposisi program terkuantisasi 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

Melegalkan StableHLO ke VHLO.

Melegalkan StableHLO ke versi terbaru operasi di VHLO. Operasi ini kemudian dapat diturunkan ke versi VHLO yang lebih lama untuk kompatibilitas ke depan menggunakan VhloToVersionPass.

stablehlo.exponential %[[ARG0]] <{result_accuracy = DEFAULT}> : tensor<f32>
# ====>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = #vhlo.DEFAULT_v1}> : !vhlo.tensor_v1<!vhlo.f32_v1>

Lihat vhlo.md > The VHLO dialect untuk mengetahui detail lengkap tentang cara VHLO digunakan untuk mempertahankan kompatibilitas maju dan mundur.

Opsi

-allow-other-dialects : Allow serialization to use other (potentially unstable) dialects, inserts unrealized casts between dialects.

-stablehlo-refine-arguments

Memperbaiki bentuk argumen fungsi utama.

Mengubah argumen fungsi utama menggunakan tanda tangan jenis input. Membungkus 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 disempurnakan. Hal ini dapat ditentukan di MLIR dengan --types='tensor<...>,tensor<...>', atau diteruskan ke metode pembuatan pass. Daftar jenis penyempurnaan harus menentukan jenis setiap argumen ke metode main yang disempurnakan.

Opsi

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

-stablehlo-refine-shapes

Memperbaiki bentuk di seluruh program StableHLO.

Menjelaskan program StableHLO yang menyempurnakan bentuk dalam operasi.

Kasus penggunaan utama 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 ke bentuk statis dan menjalankan lintasan ini akan menyebarkan bentuk statis di seluruh program.

Pass 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). Kami menyebut operasi yang bergantung secara transitif hanya 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 diselesaikan menjadi konstanta melalui pelipatan konstanta antar-prosedur.
• Fungsi perantara dapat mengambil sejumlah argumen token (berjenis !stablehlo.token) di awal daftar argumen, diikuti dengan beberapa argumen konstanta global yang merupakan skalar bilangan bulat konstanta, seperti nilai bilangan bulat simbolis yang telah diselesaikan (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 konstanta setelah penyempurnaan. Fungsi ini di-inline.
• Semua panggilan ke satu fungsi diselesaikan ke bentuk argumen yang sama, dan tidak ada panggilan fungsi rekursif / ko-rekursif yang dilakukan.

-stablehlo-wrap-in-composite

Membungkus operasi StableHLO non-gabungan dalam operasi gabungan.

Membungkus operasi StableHLO dalam operasi stablehlo.composite.

Misalnya, pertimbangkan program StableHLO sederhana:

func.func @main(%arg0 : tensor<2xf32>, %arg1 : tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

Menerapkan kartu ini untuk membungkus operasi stablehlo.add akan menghasilkan program berikut:

func.func @main(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.composite "stablehlo.add" %arg0, %arg1 {decomposition = @stablehlo.add.impl} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xf32>
  return %0 : tensor<2xf32>
}
func.func private @stablehlo.add.impl(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

Catatan:

• Atribut name dari operasi stablehlo.composite yang dihasilkan akan selalu sama dengan nama operasi asli yang di-wrap (misalnya, jika Anda mem-wrap operasi stablehlo.add, komposit juga akan diberi nama "stablehlo.add").
• Fungsi pribadi yang merangkum operasi asli (dirujuk oleh atribut decomposition dari operasi stablehlo.composite) akan diberi nama menggunakan pola <op_name>.impl[.N], dengan <op_name> adalah nama operasi asli, dan N adalah ID bilangan bulat unik yang dibuat untuk mencegah konflik penamaan dalam modul.

Kartu ini dapat digunakan dengan dua cara yang berbeda:

Mode 1: Penggunaan Command Line

Mode ini ditujukan untuk proses debug atau pengujian, karena menawarkan kontrol minimal atas atribut operasi stablehlo.composite yang dihasilkan. Opsi ini mencakup semua instance operasi yang ditentukan menggunakan opsi op-names (daftar nama operasi yang dipisahkan koma). Atribut operasi stablehlo.composite yang baru dibuat akan sama dengan atribut operasi asli.

Contoh Penggunaan:

stablehlo-opt input.mlir --stablehlo-wrap-in-composite=op-names='stablehlo.add,stablehlo.mul' -o output.mlir

Mode 2: Pembungkusan Seluruh Modul Terprogram dengan Penanganan Atribut yang disesuaikan

Mode ini memperluas pembungkusan terprogram ke seluruh modul, yang menawarkan kontrol terperinci atas operasi yang dibungkus dan atributnya. Hal ini dilakukan dengan menggunakan createStablehloWrapInCompositePass API, yang menggunakan CompositeAttributeProviderMap sebagai argumen.

CompositeAttributeProviderMap adalah peta yang menentukan operasi mana yang harus dipertimbangkan untuk pembungkusan dan cara menangani atributnya. Semantiknya adalah sebagai berikut:

• Kunci (mlir::TypeID): TypeID dari operasi MLIR. Jika TypeID operasi cocok dengan kunci dalam peta, operasi tersebut akan menjadi kandidat untuk pembungkusan.
• Nilai (Fungsi Lambda): Fungsi lambda berjenis std::function<std::optional<NamedAttrList>(Operation*)>. Fungsi ini diterapkan ke setiap operasi kandidat.
  • Input: mlir::Operation*, yang merupakan instance dari jenis operasi yang sesuai dengan kunci TypeID.
  • Nilai yang Ditampilkan: std::optional<NamedAttrList>.
    • Jika lambda menampilkan NamedAttrList (di-wrap dalam std::optional), operasi akan di-wrap dalam operasi stablehlo::composite, dan atribut yang ditampilkan digunakan untuk menetapkan atribut komposit.
    • Jika lambda menampilkan std::nullopt, operasi tidak di-wrap. Hal ini memungkinkan pembungkusan selektif berdasarkan kriteria kustom.

Contoh (C++):

stablehlo::CompositeAttributeProviderMap compositeAttributeProviderMap;

compositeAttributeProviderMap[mlir::TypeID::get<mlir::stablehlo::AddOp>()] =
  [](mlir::Operation* op) -> std::optional<mlir::NamedAttrList> {
  // Custom logic to determine if and how to wrap the operation.
  // Example: Only wrap if it's on a specific type.
  if (mlir::isa<mlir::Float32Type>(op->getOperand(0).getType())) {
    return mlir::NamedAttrList(op->getAttrs());
  }
  return std::nullopt; // Do not wrap.
};

pm.addPass(createStablehloWrapInCompositePass(compositeAttributeProviderMap, compositeVersion));
if (mlir::failed(pm.run(module))) {
  return;
}

Opsi

-op-names : The names of the ops to wrap.
-version  : The version number of the composite op.

-vhlo-legalize-to-stablehlo

Melegalkan VHLO ke StableHLO.

-vhlo-to-version

Konversi antar-versi VHLO untuk kompatibilitas.

Mengonversi antar-versi VHLO untuk upgrade dan downgrade IR guna mempertahankan kompatibilitas maju dan mundur.

"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>
# ==( -target=1.0.0 )==>
"vhlo.exponential_v1"(%[[ARG0]])
# ==( -target=1.9.0 )==>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>

Lihat vhlo.md > The VHLO dialect untuk mengetahui detail lengkap tentang cara VHLO digunakan untuk mempertahankan kompatibilitas maju dan mundur.

Opsi

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