-chlo-legalize-to-stablehlo

Chuyển đổi hợp pháp từ luồng hoạt động CHLO sang StableHLO và hoạt động định hình

-shape-legalize-to-stablehlo

Hợp pháp hoá các thao tác liên quan đến hình dạng cho StableHLO.

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

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

-stablehlo-aggressive-folder

Gộp các thao tác StableHLO

Tùy chọn

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

-stablehlo-aggressive-simplification

Chuẩn hoá các thao tác StableHLO

-stablehlo-canonicalize-dynamism

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

Thay thế các toán tử StableHLO động như DynamicReshapeOp bằng các toán tử 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 toán tử 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-compatibility-expander

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

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

Tại sao đây là thẻ và vé không bắt buộc?

Đôi khi, các tính năng nâng cao về toán tử StableHLO được dùng để đơn giản hoá đáng kể việc xử lý một số mẫu phổ biến nhất định trong hệ sinh thái OpenXLA. Điều này bao gồm các tính năng như TanOp, có hỗ trợ khung và trình biên dịch cao, cũng như các phương diện phân lô thu thập/phân tán, có thể được biểu thị bằng cách sử dụng lát cắt, nhưng khiến việc phân đoạn 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 lần tối ưu hoá tiếp theo. Bạn có thể sử dụng thẻ thông hành 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ể phải trả giá bằng việc biên dịch không tối ưu.

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-convert-to-signless

Chuyển để biến đổi IR thành số nguyên không dấu.

-stablehlo-legalize-composite-to-call

Thay thế các toán tử tổng hợp bằng lệnh gọi đến quá trình phân ly của chúng.

Thay thế các toán tử tổng hợp bằng lệnh gọi đến quá trình phân ly, ví dụ như 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 tập hợp con của thành phần kết hợp khỏi phép biến đổi này bằng cách sử dụng cờ "except" (ngoại trừ), 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ợ tốt.

RFC về việc ngừng sử dụng Opset StableHLO v1.0 (#2283) đề xuất xoá một số thao tác thừa. Lệnh này giúp đánh giá tác động của việc xoá các toán tử này trong nhiều quy trình biên dịch bằng cách hợp pháp hoá các toán tử này thành các toán tử đượ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 (huỷ lượng tử hoá, phép tính dấu phẩy động và lượng tử hoá) mẫu vào phép tính lượng tử hoá StableHLO

Hợp nhất (huỷ lượng tử hoá, phép tính dấu phẩy động và lượng tử hoá) mẫu vào phép tính lượng tử hoá StableHLO Lưu ý: Lệnh truyền không xoá bất kỳ toán tử nào có sẵn. 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 toán tử lượng tử hoá StableHLO sang các toán tử số học gốc 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ố nguyên tương đương về 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 ly phép toán StableHLO đã lượng tử hoá thành mẫu (huỷ lượng tử hoá, phép toán dấu phẩy động và lượng tử hoá).

Phân ly các chương trình đã được lượng tử hoá StableHLO bằng cách sử dụng các phép toán 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

Chuyển StableHLO sang VHLO.

-stablehlo-refine-arguments

Chỉnh sửa 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 dữ liệu đầu vào. Gói 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 vào phương thức tạo thẻ và vé. 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

Cải tiến hình dạng trên một chương trình StableHLO.

Hướng dẫn từng bước về chương trình StableHLO giúp tinh chỉnh các hình dạng trong các thao tác.

Trường hợp sử dụng chính của thẻ này là chuyên biệt hoá các chương trình có hình dạng động 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 thành 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 chương trình.

Lệnh truyền này sẽ xoá custom_call @shape_refinement_operand_wrapper bằng cách thay thế việc 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 hình dạng đầu vào (không có phần phụ thuộc hình dạng nào trên nội dung mảng đầu vào). Chúng tôi gọi các phép toán chỉ phụ thuộc bắc cầu vào các hình dạng đầu vào (ví dụ: do stablehlo.get_dimension_size cung cấp) hoặc các hằng số toàn cục như giá trị đã phân giải của số nguyên tượng trưng (tức là tensor : A = 5) là các phép toán dimension. Tất cả giá trị phương diện đều có thể được phân giải thành hằng số thông qua việc gập hằng số giữa các quy trình.
• Các hàm trung gian có thể nhận một số đối số mã thông báo (loại !stablehlo.token) ở đầu danh sách đối số, theo sau là một số đối số hằng số toàn cục là các đại lượng vô hướng số nguyên không đổi, chẳng hạn như 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ề kết quả tính toán trên các hằng số toàn cục, nghĩa là floordiv trên các giá trị symint. Các hàm này được chỉ báo bằng cách chỉ trả về giá trị không đổi sau khi tinh chỉnh. Các hàm này được nội tuyến.
• Tất cả lệnh gọi đến một hàm sẽ phân giải thành cùng một hình dạng đối số và không có lệnh gọi hàm đệ quy / đồng đệ quy nào được thực hiện. ### -vhlo-legalize-to-stablehlo

Chuyển VHLO sang StableHLO.

-vhlo-to-version

Chuyển đổi giữa các phiên bản VHLO.

Tùy chọn

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