-chlo-legalize-to-stablehlo

Hợp pháp hoá từ quy trình hoạt động CHLO sang StableHLO và hoạt động Shape

-shape-legalize-to-stablehlo

Hợp pháp hoá các hoạt động liên quan đến hình dạng đối với StableHLO.

Một đường chuyền thử nghiệm hợp pháp hoá các hoạt động liên quan đến hình dạng thành các hoạt động StableHLO.

Việc kết hợp các phép tính về hình dạng và dữ liệu thông qua một đường truyền không bắt buộc sẽ giúp hệ sinh thái StableHLO có khả năng tận dụng các quy trình biên dịch sử dụng các thao tác StableHLO để mô hình hoá tính linh hoạt.

-stablehlo-canonicalize-dynamism

Chuẩn hoá các thao tác StableHLO linh động thành các thao tác tĩnh.

Thay thế các thao tác StableHLO động như DynamicReshapeOp bằng các thao tác tĩnh tương ứng như DynamicReshapeOp thành ReshapeOp hoặc DynamicBroadcastInDim thành BroadcastInDim nếu tất cả các phần tử động của các thao tác này thực sự là hằng số.

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

Xác thực các lệnh gọi tuỳ chỉnh shape_assertion.

Các câu lệnh về hình dạng xác thực các ràng buộc về kích thước động trong StableHLO. Ví dụ: nếu một khung cần thực thi một ràng buộc của DimA < 2, thì IR sau đây có thể được phát ra:

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

Sau khi vượt qua, nếu các hình dạng chính xác, stablehlo.custom_call sẽ bị xoá.

Tùy chọn

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

-stablehlo-compatibility-expander

Trình mở rộng khả năng tương thích cho các hoạt động StableHLO.

Các thao tác StableHLO sẽ được cập nhật hoặc thao tác mới sẽ được giới thiệu trong các phiên bản mới nhất. Lựa chọn tham gia này mở rộng khả năng tương thích ngược với các phiên bản StableHLO cũ hơn bằng cách phân tách các hoạt động StableHLO mới hơn thành các hoạt động tương đương được các phiên bản cũ hơn đó hỗ trợ.

Tại sao đây là thẻ chọn tham gia?

Đôi khi, các tính năng nâng cao của StableHLO được dùng để đơn giản hoá đáng kể việc xử lý một số mẫu phổ biến trong hệ sinh thái OpenXLA. Điều này bao gồm những thứ như TanOp, có khả năng hỗ trợ cao cho khung và trình biên dịch, cũng như các phương diện phân lô thu thập/phân tán. Các phương diện này có thể được biểu thị bằng các lát cắt, nhưng khiến việc phân mảnh trở nên khó khăn hơn nhiều. Đối với danh mục tính năng mới này, chúng tôi không cung cấp tính năng hạ cấp tự động vì tính năng này có thể loại bỏ thông tin quan trọng được dùng trong các hoạt động tối ưu hoá tiếp theo. Bạn có thể dùng lượt truyền này để mở rộng các thao tác này dựa trên phiên bản mục tiêu nhằm tối đa hoá khả năng tương thích, nhưng có thể làm giảm hiệu quả biên dịch.

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

Tùy chọn

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

-stablehlo-complex-math-expander

Trình mở rộng cho các phép toán số học phức tạp của StableHLO.

Các phép toán phức tạp trong StableHLO là các phép phân tách bằng cách sử dụng các phép toán thực trong StableHLO.

Tuyên bố này dựa trên giả định rằng không có phần cứng nào hỗ trợ số phức cũng như các phép toán phức tạp một cách tự nhiên. Điều này có nghĩa là các cơ chế dự phòng cho các hoạt động toán học phức tạp mà trình biên dịch có thể triển khai là dư thừa. Khi bạn bật lượt truyền này, tất cả các phép toán phức tạp của StableHLO sẽ được mở rộng.

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

Truyền để chuyển đổi IR thành số nguyên không dấu.

-stablehlo-legalize-composite-to-call

Thay thế các thao tác kết hợp bằng một lệnh gọi đến quá trình phân tách của các thao tác đó.

Thay thế các thao tác kết hợp bằng một lệnh gọi đến quá trình phân tách của chúng, chẳng hạn như lệnh gọi bên dưới:

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

Sẽ trở thành:

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

Bạn có thể loại trừ một nhóm nhỏ các thành phần kết hợp khỏi quy tắc chuyển đổi này bằng cờ "except", ví dụ:

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

Tùy chọn

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

-stablehlo-legalize-deprecated-ops

Hợp pháp hoá các thao tác không dùng nữa thành các thao tác được hỗ trợ đầy đủ.

RFC về việc ngừng sử dụng Opset StableHLO phiên bản 1.0 (#2283) đề xuất xoá một số thao tác dư thừa. Giai đoạn này giúp đánh giá tác động của việc xoá các thao tác này trong nhiều quy trình biên dịch bằng cách hợp thức hoá chúng thành các đối tác được hỗ trợ lâu dài.

Tùy chọn

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

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

Hợp nhất mẫu (huỷ định lượng hoá, phép toán dấu phẩy động và định lượng hoá) thành phép toán được định lượng hoá StableHLO

Hợp nhất mẫu (giảm lượng tử hoá, hoạt động dấu phẩy động và lượng tử hoá) thành hoạt động được lượng tử hoá StableHLO Lưu ý: Lượt truyền này không xoá bất kỳ hoạt động nào đã có từ trước. Ví dụ: chương trình sau

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

Sẽ trở thành:

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

Chuyển đổi từ các hoạt động được lượng tử hoá StableHLO sang các hoạt động toán học cơ bản StableHLO.

Chuyển đổi các chương trình StableHLO bằng cách sử dụng các loại UniformQuantized thành các phép toán số học tương đương về mặt ngữ nghĩa.

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

Sẽ trở thành:

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

Phân tách hoạt động StableHLO được lượng tử hoá thành mẫu (huỷ lượng tử hoá, hoạt động dấu phẩy động và lượng tử hoá).

Phân tách các chương trình được lượng tử hoá StableHLO bằng cách sử dụng các thao tác lượng tử hoá/giải lượng tử hoá đồng nhất. Ví dụ: chương trình sau

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

Sẽ trở thành:

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

Hợp pháp hoá StableHLO thành VHLO.

Hợp thức hoá StableHLO thành phiên bản mới nhất của các thao tác trong VHLO. Sau đó, bạn có thể hạ cấp các thao tác này xuống các phiên bản cũ hơn của VHLO để đảm bảo khả năng tương thích về sau bằng cách sử dụng VhloToVersionPass.

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

Hãy xem vhlo.md > The VHLO dialect (vhlo.md > Ngôn ngữ VHLO) để biết đầy đủ thông tin chi tiết về cách VHLO được dùng để duy trì khả năng tương thích tiến và tương thích ngược.

Tùy chọn

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

-stablehlo-refine-arguments

Tinh chỉnh các hình dạng đối số của hàm chính.

Sửa đổi các đối số của hàm chính bằng cách sử dụng chữ ký loại đầu vào. Bao bọc các đối số trong custom_call @stablehlo.shape_refinement_operand_wrapper để giữ cho IR hợp lệ trước khi chạy quy trình tinh chỉnh hình dạng.

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

Bạn có thể dùng refinedTypesOption để chỉ định danh sách các loại được tinh chỉnh. Bạn có thể chỉ định thông tin này trong MLIR bằng --types='tensor<...>,tensor<...>' hoặc truyền đến phương thức tạo lượt truyền. Danh sách loại tinh chỉnh phải chỉ định loại của mọi đối số cho phương thức main đang được tinh chỉnh.

Tùy chọn

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

-stablehlo-refine-shapes

Tinh chỉnh các hình dạng trong một chương trình StableHLO.

Hướng dẫn về một chương trình StableHLO tinh chỉnh các hình dạng trong các thao tác.

Trường hợp sử dụng chính cho đường chuyền này là chuyên về các chương trình có hình dạng linh hoạt thành hình dạng tĩnh. Nếu một chương trình StableHLO có hình dạng động có cấu trúc phù hợp, thì việc cập nhật các loại đối số của chương trình đó từ hình dạng động sang hình dạng tĩnh và chạy lượt truyền này sẽ truyền hình dạng tĩnh trên toàn bộ chương trình.

Lượt truyền này sẽ xoá custom_call @shape_refinement_operand_wrapper bằng cách thay thế các lượt sử dụng kết quả bằng toán hạng trực tiếp và truyền các hình dạng tĩnh trong toàn bộ chương trình.

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

Các mô-đun hợp lệ để tinh chỉnh hình dạng phải có các thuộc tính sau:

  • Tất cả các hình dạng động chỉ phụ thuộc vào các hình dạng đầu vào (không có sự phụ thuộc hình dạng nào vào nội dung của mảng đầu vào). Chúng tôi gọi các thao tác chỉ phụ thuộc một cách bắc cầu vào các hình dạng đầu vào (ví dụ: do stablehlo.get_dimension_size đưa ra) hoặc các hằng số chung như các giá trị đã phân giải của số nguyên tượng trưng (tức là tensor : A = 5) là các thao tác dimension. Tất cả các giá trị phương diện đều có thể được phân giải thành các hằng số thông qua việc kết hợp hằng số giữa các quy trình.
  • Các hàm trung gian có thể lấy một số đối số mã thông báo (thuộc loại !stablehlo.token) ở đầu danh sách đối số, theo sau là một số đối số hằng số chung là các vô hướng số nguyên hằng số, chẳng hạn như các giá trị đã phân giải của số nguyên tượng trưng (tức là tensor : A = 5).
  • Một số hàm trung gian có thể trả về các phép tính trên hằng số chung, tức là floordiv trên các giá trị symint. Các hàm này chỉ trả về các giá trị không đổi sau khi tinh chỉnh. Các hàm này được nội tuyến.
  • Tất cả các lệnh gọi đến một hàm duy nhất đều phân giải thành các hình dạng đối số giống nhau và không có lệnh gọi hàm đệ quy / cùng đệ quy nào được thực hiện.

-stablehlo-wrap-in-composite

Bao bọc một thao tác StableHLO không phải là thao tác kết hợp trong một thao tác kết hợp.

Bao bọc các hoạt động StableHLO trong các hoạt động stablehlo.composite.

Ví dụ: hãy xem xét một chương trình StableHLO đơn giản:

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

Việc áp dụng lượt truyền này để bao bọc các thao tác stablehlo.add sẽ dẫn đến chương trình sau:

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

Lưu ý:

  • Thuộc tính name của thao tác stablehlo.composite được tạo sẽ luôn giống với tên của thao tác ban đầu đã được bao bọc (ví dụ: nếu bạn bao bọc một thao tác stablehlo.add, thì thành phần kết hợp cũng sẽ có tên là "stablehlo.add").
  • Hàm riêng tư bao bọc thao tác ban đầu (được tham chiếu theo thuộc tính decomposition của thao tác stablehlo.composite) sẽ được đặt tên theo mẫu <op_name>.impl[.N], trong đó <op_name> là tên của thao tác ban đầu và N là giá trị nhận dạng số nguyên duy nhất được tạo để ngăn xung đột tên trong mô-đun.

Bạn có thể sử dụng thẻ và vé này theo hai cách riêng biệt:

Chế độ 1: Sử dụng dòng lệnh

Chế độ này dùng để gỡ lỗi hoặc kiểm thử, vì chế độ này cung cấp khả năng kiểm soát tối thiểu đối với các thuộc tính của hoạt động stablehlo.composite đã tạo. Thao tác này bao bọc tất cả các thực thể của các thao tác được chỉ định bằng cách sử dụng các lựa chọn op-names (danh sách tên thao tác được phân tách bằng dấu phẩy). Các thuộc tính của thao tác stablehlo.composite mới tạo sẽ giống với các thuộc tính của thao tác ban đầu.

Ví dụ về cách sử dụng:

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

Chế độ 2: Bao bọc theo mô-đun trên diện rộng có Xử lý thuộc tính tuỳ chỉnh

Chế độ này mở rộng tính năng bao bọc có lập trình cho toàn bộ mô-đun, mang đến khả năng kiểm soát chi tiết đối với những thao tác được bao bọc và các thuộc tính của chúng. Bạn có thể thực hiện việc này bằng cách sử dụng API createStablehloWrapInCompositePass. API này lấy CompositeAttributeProviderMap làm đối số.

CompositeAttributeProviderMap là một bản đồ quy định những thao tác nào cần được xem xét để bao bọc và cách xử lý các thuộc tính của thao tác đó. Ngữ nghĩa của nó như sau:

  • Khoá (mlir::TypeID): TypeID của một thao tác MLIR. Nếu TypeID của một thao tác khớp với một khoá trong bản đồ, thì thao tác đó sẽ trở thành một ứng cử viên để bao bọc.
  • Giá trị (Hàm Lambda): Hàm Lambda thuộc kiểu std::function<std::optional<NamedAttrList>(Operation*)>. Hàm này được áp dụng cho từng thao tác đề xuất.
    • Đầu vào: Một mlir::Operation*, là một thực thể của loại thao tác tương ứng với khoá TypeID.
    • Giá trị trả về: Một std::optional<NamedAttrList>.
      • Nếu lambda trả về một NamedAttrList (được bao bọc trong std::optional), thì thao tác sẽ được bao bọc trong một thao tác stablehlo::composite và các thuộc tính được trả về sẽ được dùng để thiết lập các thuộc tính của thành phần.
      • Nếu lambda trả về std::nullopt, thì thao tác sẽ không được bao bọc. Điều này cho phép bao bọc có chọn lọc dựa trên tiêu chí tuỳ chỉnh.

Ví dụ (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;
}

Tùy chọn

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

-vhlo-legalize-to-stablehlo

Hợp pháp hoá VHLO thành StableHLO.

-vhlo-to-version

Chuyển đổi giữa các phiên bản của VHLO để đảm bảo khả năng tương thích.

Chuyển đổi giữa các phiên bản của VHLO để nâng cấp và hạ cấp IR nhằm duy trì khả năng tương thích tiến và tương thích ngược.

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

Hãy xem vhlo.md > The VHLO dialect (vhlo.md > Ngôn ngữ VHLO) để biết đầy đủ thông tin chi tiết về cách VHLO được dùng để duy trì khả năng tương thích tiến và tương thích ngược.

Tùy chọn

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