OpenXLA Project

Trang này được dịch bởi Cloud Translation API.

`-chlo-legalize-to-stablehlo`

Hợp pháp hoá quy trình hoạt động CHLO sang hoạt động ổn định và hình dạng

`-shape-legalize-to-stablehlo`

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

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

Việc kết hợp các phép tính hình dạng và dữ liệu với nhau thông qua một lần truyền tuỳ chọn sẽ giúp hệ sinh thái StableHLO có thể tận dụng quy trình biên dịch sử dụng thao tác ổn định HLO để lập mô hình động lực.

`-stablehlo-aggressive-folder`

Folds ổn định hoạt độngHLO

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 ổn địnhHLO

`-stablehlo-canonicalize-dynamism`

Chuẩn hoá hoạt động ổn định động thành hoạt động tĩnh.

Thay thế hoạt động ổn định động như DynamicReShapeOp bằng các thuộc tính tương ứng các đối tác tĩnh như ReshapeOp nếu tất cả các phần tử động của các hoạt động này thực sự không đổi.

Ví dụ: nếu toán hạng output_shape của DynamicReShapeOp là một hằng số , thì bạn có thể chuyển đổi thao tác này thành ReshapeOp.

`-stablehlo-convert-to-signless`

Truyền để biến đổi IR thành các số nguyên không có dấu.

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

Thay thế hoạt động tổng hợp bằng lệnh gọi đến quá trình phân ly

Thay thế hoạt động tổng hợp bằng lệnh gọi đến quá trình phân rã, ví dụ: 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)

Có thể loại trừ một tập hợp con tổng hợp khỏi phép biến đổi này bằng cách sử dụng phương thức "ngoại trừ" cờ, 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 hoạt động không dùng nữa thành các hoạt động được hỗ trợ tốt.

RFC (#2283) không hỗ trợ hoạt động ổn định phiên bản 1.0 đề xuất loại bỏ một số hoạt động dư thừa. Lượt chuyển này giúp đánh giá tác động của những hoạt động này việc gỡ bỏ bằng nhiều quy trình biên dịch bằng cách hợp pháp hoá chúng thành những đố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 (loại bỏ lượng tử, hoạt động dấu phẩy động và định lượng) vào thao tác lượng tử hoá ổn địnhHLO

Kết hợp mẫu (Khử lượng tử, hoạt động dấu phẩy động và lượng tử hoá) vào hoạt động lượng tử hoá ổn địnhHLO Lưu ý: Thẻ/vé này không xoá bất kỳ hoạt động nào đã có 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ừ hoạt động lượng tử hoá StableHLO sang hoạt động toán học gốc của StableHLO.

Chuyển đổi các chương trình StableHLO bằng các kiểu Hệ thống phân loại thống nhất sang các chương trình theo ngữ nghĩa phép toán số nguyên tương đương.

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 toán tử ổn định lượng tử hoá cho mẫu (loại bỏ lượng tử, hoạt động dấu phẩy động và định lượng).

Phân huỷ các chương trình lượng tử hoá StableHLO bằng cách sử dụng phương pháp định lượng/loại bỏ lượng tử đồng nhất các toán 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.

`-stablehlo-refine-arguments`

Tinh chỉnh 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 đối số trong custom_call @stablehlo.shape_refinement_operand_wrapper để giữ cho IR hợp lệ trước khi chạy tinh chỉnh hình dạng.

Bạn có thể sử dụng refinedTypesOption để chỉ định danh sách các loại đã tinh chỉnh. Bạn có thể chỉ định thuộc tính này trong MLIR bằng --types='tensor<...>,tensor<...>', hoặc được chuyển vào phương thức tạo thẻ/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`

Tinh chỉnh hình dạng trong chương trình StableHLO.

Xem qua quy trình tinh chỉnh các hình dạng của chương trình StableHLO trong hoạt động.

Trường hợp sử dụng chính của thẻ và vé này là chuyên về hình dạng động chương trình sang các hình dạng tĩnh. Nếu chương trình Ổn định HLO có hình dạng động có cấu trúc bên phải, sau đó cập nhật loại đối số từ hình dạng động thành hình dạng tĩnh và khi chạy thẻ/vé này sẽ truyền các hình dạng tĩnh trên chương trình.

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

Tùy chọn

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