'mhlo' phương ngữ

Hoạt động

mhlo.abs (mhlo::AbsOp)

Hoạt động abs

Cú pháp:

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán abs từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

Ví dụ:

%result = mhlo.abs %operand : tensor<3xi32>

Các đặc điểm: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.acos (mhlo::AcosOp)

Hoạt động Acos

Cú pháp:

operation ::= `mhlo.acos` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán acos từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Ví dụ:

%result = mhlo.acos %operand : tensor<2x2xf32>

Đặc điểm: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.acosh (mhlo::AcoshOp)

Hoạt động Acosh

Cú pháp:

operation ::= `mhlo.acosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán acosh theo từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Ví dụ:

%result = mhlo.acosh %operand : tensor<2x2xf32>

Đặc điểm: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.add (mhlo::AddOp)

Thêm hoạt động

Cú pháp:

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Thực hiện phép cộng từng phần tử của hai tenxơ lhs và rhs và tạo ra một tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

Ví dụ:

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

Các đặc điểm: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.add_dependency (mhlo::AddDependencyOp)

Hoạt động AddDependency

Cú pháp:

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

Hoạt động này là riêng tư đối với trình biên dịch XLA, do đó nó vẫn chưa có thông số kỹ thuật cụ thể.

Nói một cách không chính thức, thao tác này bao gồm hai toán hạng: một toán hạng dữ liệu và một mã thông báo. Đầu ra của thao tác là toán hạng dữ liệu. Khi được sử dụng với AfterAll, thao tác này cho phép sắp xếp các thao tác không có tác dụng phụ (những thao tác không tạo ra giá trị mã thông báo).

Ví dụ:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.after_all (mhlo::AfterAllOp)

Hoạt động AfterAll

Cú pháp:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

Đảm bảo rằng các hoạt động tạo ra inputs được thực hiện trước bất kỳ hoạt động nào phụ thuộc vào result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Ví dụ:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.all_gather (mhlo::AllGatherOp)

Hoạt động AllGather

Trong mỗi nhóm quy trình trong lưới quy trình, nối các giá trị của tenxơ toán hạng từ mỗi quy trình dọc theo all_gather_dim và tạo ra một tenxơ kết quả. computation được áp dụng riêng cho từng toán hạng trong operands , tạo ra một kết quả cho mỗi toán hạng.

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

Ví dụ:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

Đặc điểm: SameOperandsAndResultElementType

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.all_reduce (mhlo::AllReduceOp)

Hoạt động AllReduce

Trong mỗi nhóm quy trình trong lưới quy trình, áp dụng computation hàm rút gọn cho các giá trị của một tenxơ toán hạng từ mỗi quy trình và tạo ra một tenxơ kết quả. computation được áp dụng riêng cho từng toán hạng trong operands , tạo ra một kết quả cho mỗi toán hạng.

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Ví dụ:

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

Đặc điểm: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.all_to_all (mhlo::AllToAllOp)

Hoạt động AllToAll

Trong mỗi nhóm quy trình trong lưới quy trình, chia các giá trị của tenxơ toán operand theo split_dimension thành các phần, phân tán các phần phân tán giữa các quy trình, nối các phần phân tán theo concat_dimension và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

Ví dụ:

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

Các đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.and (mhlo::AndOp)

Và hoạt động

Cú pháp:

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Thực hiện phép AND từng phần tử của hai tenxơ lhs và rhs và tạo ra một tenxơ result

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

Ví dụ:

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

Các đặc điểm: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.asin (mhlo::AsinOp)

Hoạt động Asin

Cú pháp:

operation ::= `mhlo.asin` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán asin từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Ví dụ:

%result = mhlo.asin %operand : tensor<2x2xf32>

Đặc điểm: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.asinh (mhlo::AsinhOp)

Hoạt động Asinh

Cú pháp:

operation ::= `mhlo.asinh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán asin từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Ví dụ:

%result = mhlo.asinh %operand : tensor<2x2xf32>

Đặc điểm: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.async_done (mhlo::AsyncDoneOp)

Hoạt động AsyncDone

Hoạt động này là riêng tư đối với trình biên dịch XLA, do đó nó vẫn chưa có thông số kỹ thuật cụ thể.

Nói một cách không chính thức, thao tác này sẽ chặn cho đến khi kết thúc một phép tính bất đồng bộ. Nó trả về kết quả cuối cùng của phép tính bất đồng bộ.

Xem tài liệu về AsyncStart để biết thêm thông tin.

Giao diện: InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.async_start (mhlo::AsyncStartOp)

Hoạt động AsyncStart

Hoạt động này là riêng tư đối với trình biên dịch XLA, do đó nó vẫn chưa có thông số kỹ thuật cụ thể.

Nói một cách không chính thức, hoạt động này khởi động một phép tính không đồng bộ.

Điều này được sử dụng khi có các hàm chứa cả chờ đợi bất đồng bộ (chẳng hạn như DMA) và tính toán trên luồng. Ví dụ, một hàm có thể bao gồm một phép tính, một DMA, một phép tính khác, một DMA thứ hai và một phép tính cuối cùng. Điều này sẽ được biểu diễn dưới dạng async_start theo sau là async_update và async_done. async_start sẽ thực hiện phép tính đầu tiên trên luồng và sau đó bắt đầu DMA. async_update sẽ đợi DMA hoàn tất nếu nó chưa hoàn tất, sau đó thực hiện phép tính thứ hai trong hàm và bắt đầu DMA thứ hai. Cuối cùng, async_done sẽ đợi DMA cuối cùng này, sau đó chạy phép tính cuối cùng cần chạy trên luồng và trả về kết quả của phép tính cuối cùng đó.

operands được truyền trực tiếp đến phép tính. called_computation là hàm sẽ được chạy không đồng bộ. execution_thread là tên luồng mà nó sẽ được chạy. Luồng chính được gọi là "main". Tất cả các luồng đều có tên.

Hàm này trả về tất cả trạng thái cần thiết giữa các thao tác bất đồng bộ. Sau khi gán bộ đệm, các giá trị trả về biểu thị không gian cần thiết để chứa dữ liệu đầu vào, kết quả và bất kỳ vùng nhớ tạm nào được thao tác bất đồng bộ cần hoặc chỉnh sửa.

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.async_update (mhlo::AsyncUpdateOp)

Hoạt động AsyncUpdate

Hoạt động này là riêng tư đối với trình biên dịch XLA, do đó nó vẫn chưa có thông số kỹ thuật cụ thể.

Nói một cách không chính thức, thao tác này sẽ chặn một phép tính bất đồng bộ cho đến khi gặp rào cản đồng bộ. Thao tác này trả về bundle sau khi thực hiện.

Xem tài liệu về AsyncStart để biết thêm thông tin.

Giao diện: InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.atan2 (mhlo::Atan2Op)

Hoạt động Atan2

Cú pháp:

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Thực hiện phép toán atan2 theo từng phần tử trên tenxơ lhs và rhs và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

Ví dụ:

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

Các đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.atanh (mhlo::AtanhOp)

Hoạt động Atanh

Cú pháp:

operation ::= `mhlo.atanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán atanh theo từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Ví dụ:

%result = mhlo.atanh %operand : tensor<2x2xf32>

Đặc điểm: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Hoạt động BatchNormGrad

Tính toán độ dốc của một số đầu vào của BatchNormTrainingOp truyền ngược từ grad_output và tạo ra các tenxơ grad_operand , grad_scale và grad_offset .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

Ví dụ:

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Hoạt động BatchNormInference

Chuẩn hóa tenxơ operand trên tất cả các chiều ngoại trừ chiều feature_index và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

Ví dụ:

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Hoạt động BatchNormTraining

Tính toán giá trị trung bình và phương sai trên các chiều lô và không gian và chuẩn hóa tenxơ operand , cho mỗi tính năng trong chiều feature_index và tạo ra tenxơ output là batch_mean và batch_var .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

Ví dụ:

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.bitcast (mhlo::BitcastOp)

Hoạt động Bitcast

Cú pháp:

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

Hoạt động này là riêng tư đối với trình biên dịch XLA, do đó nó vẫn chưa có thông số kỹ thuật cụ thể.

Nói một cách không chính thức, hoạt động này thay đổi hình dạng của đầu vào theo cách mà sự sắp xếp vật lý của các phần tử không thay đổi.

Hoạt động này cần thông tin bố cục để hiểu được "sự sắp xếp vật lý của các thành phần" và hỗ trợ bố cục trong MHLO hiện đang trong quá trình hoàn thiện.

Ví dụ:

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Hoạt động BitcastConvert

Cú pháp:

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

Thực hiện thao tác bitcast trên tenxơ operand và tạo ra tenxơ result trong đó các bit của toàn bộ tenxơ toán operand được diễn giải lại bằng cách sử dụng kiểu của tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

Ví dụ:

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.broadcast (mhlo::BroadcastOp)

Hoạt động phát sóng

Hoạt động này đang trên đường ra khỏi StableHLO, do đó nó không được đưa vào đặc tả: https://github.com/openxla/stablehlo/issues/3

Nói một cách không chính thức, hoạt động này thực hiện cùng một chức năng như Broadcast của XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Ví dụ:

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

Các đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Hoạt động BroadcastInDim

Mở rộng kích thước và/hoặc hạng của tenxơ đầu vào bằng cách sao chép dữ liệu trong tenxơ toán operand và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

Ví dụ:

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

Đặc điểm: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.case (mhlo::CaseOp)

Hoạt động trường hợp

Tạo ra kết quả từ việc thực thi chính xác một function từ branches tùy thuộc vào giá trị của index .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Ví dụ:

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

Đặc điểm: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Giao diện: InferTypeOpInterface

Toán hạng:

Kết quả:

mhlo.cbrt (mhlo::CbrtOp)

Hoạt động Cbrt

Cú pháp:

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện phép toán căn bậc ba từng phần tử trên tenxơ operand và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Ví dụ:

%result = mhlo.cbrt %operand : tensor<4xf32>

Các đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.ceil (mhlo::CeilOp)

Hoạt động trần nhà

Cú pháp:

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Thực hiện tính toán từng phần tử của tenxơ toán operand và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

Ví dụ:

%result = mhlo.ceil %operand : tensor<5xf32>

Các đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.cholesky (mhlo::CholeskyOp)

Phẫu thuật Cholesky

Tính toán phân tích Cholesky của một loạt ma trận.

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Ví dụ:

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

Các đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.clamp (mhlo::ClampOp)

Hoạt động kẹp

Cú pháp:

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

Kẹp mọi phần tử của tenxơ toán operand giữa giá trị tối thiểu và tối đa và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Ví dụ:

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

Đặc điểm: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Hoạt động CollectiveBroadcast

Trong mỗi nhóm quy trình trong lưới quy trình, gửi giá trị của tenxơ toán operand từ quy trình nguồn đến các quy trình đích và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Ví dụ:

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

Đặc điểm: CompatibleOperandsAndResultType

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Hoạt động CollectivePermute

Trong mỗi nhóm quy trình trong lưới quy trình, gửi giá trị của tenxơ toán operand từ quy trình nguồn đến quy trình đích và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Ví dụ:

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

Đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.compare (mhlo::CompareOp)

So sánh hoạt động

Cú pháp:

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

Thực hiện so sánh từng phần tử của tenxơ lhs và rhs theo comparison_direction và compare_type và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Ví dụ:

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

Các đặc điểm: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

mhlo.complex (mhlo::ComplexOp)

Hoạt động phức tạp

Cú pháp:

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

Thực hiện chuyển đổi từng phần tử thành giá trị phức hợp từ một cặp giá trị thực và ảo, lhs và rhs , và tạo ra tenxơ result .

Xem: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

Ví dụ:

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

Các đặc điểm: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

Giao diện: Có thể suy ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

mhlo.composite (mhlo::CompositeOp)

Hoạt động tổng hợp

Cú pháp:

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

Ví dụ:

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

Interfaces: SymbolUserOpInterface

Thuộc tính:

Operands:

Kết quả:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate

Ví dụ:

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

Ví dụ:

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Kết quả:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Cú pháp:

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

Ví dụ:

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

Cú pháp:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Ví dụ:

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.copy (mhlo::CopyOp)

Copy operation

Cú pháp:

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

Ví dụ:

%0 = mhlo.copy %arg0 : tensor<f32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

Cú pháp:

operation ::= `mhlo.cosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosh operation on operand tensor and produces a result tensor.

Ví dụ:

%result = mhlo.cosh %operand : tensor<2x2xf32>

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Kết quả:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Cú pháp:

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

Ví dụ:

%result = mhlo.cosine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Cú pháp:

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of leading zero bits in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

Ví dụ:

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Cú pháp:

operation ::= `mhlo.create_token` attr-dict `:` type(results)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AfterAllOp with 0 inputs: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Ví dụ:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Kết quả:

mhlo.cross-replica-sum (mhlo::CrossReplicaSumOp)

CrossReplicaSum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Ví dụ:

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Cú pháp:

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

Ví dụ:

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

Thuộc tính:

Operands:

Kết quả:

mhlo.divide (mhlo::DivOp)

Div operation

Cú pháp:

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

Ví dụ:

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.domain (mhlo::DomainOp)

Domain operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dot (mhlo::DotOp)

Dot operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

Ví dụ:

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

Ví dụ:

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

Ví dụ:

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Ví dụ:

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Ví dụ:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

Ví dụ:

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Cú pháp:

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Cú pháp:

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

Ví dụ:

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

Ví dụ:

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Cú pháp:

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

Ví dụ:

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as TF's einsum: https://www.tensorflow.org/api_docs/python/tf/einsum

Ví dụ:

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.erf (mhlo::ErfOp)

Erf operation

Cú pháp:

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise erf operation on operand tensor and produces a result tensor.

Ví dụ:

%result = mhlo.erf %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Cú pháp:

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

Ví dụ:

%result = mhlo.exponential %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Cú pháp:

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

Ví dụ:

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

Ví dụ:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.floor (mhlo::FloorOp)

Floor operation

Cú pháp:

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

Ví dụ:

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.fusion (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

Thuộc tính:

Operands:

Kết quả:

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Ví dụ:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

Ví dụ:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Operands:

Kết quả:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Cú pháp:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)