'mhlo' phương ngữ

Hoạt động

mhlo.abs (mhlo::AbsOp)

Phẫu thuật 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 tensor operand và tạo ra tensor result .

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

Ví dụ:

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

Đặc tính: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

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

Toán tử:

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 tensor operand và tạo ra tensor result .

Ví dụ:

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

Các đặc tính: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán tử:

Kết quả:

mhlo.acosh (mhlo::AcoshOp)

Chiến dịch 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 từng phần tử trên tensor operand và tạo ra tensor result .

Ví dụ:

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

Các đặc tính: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán tử:

Kết quả:

mhlo.add (mhlo::AddOp)

Thêm thao tác

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 tensor lhs và rhs và tạo ra một tensor 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 tính: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Toán tử:

Kết quả:

mhlo.add_dependency (mhlo::AddDependencyOp)

Thao tác AddDependency

Cú pháp:

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

Thao tác này thuộc phạm vi riêng của trình biên dịch XLA, do đó nó chưa có đặc tả kỹ thuật.

Một cách không chính thức, thao tác này có hai toán hạng: một toán hạng dữ liệu và một token. Kết quả 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 gây tác dụng phụ (những thao tác không tạo ra giá trị token).

Ví dụ:

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

Đặc tính: AlwaysSpeculatableImplTrait

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

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

Toán tử:

Kết quả:

mhlo.after_all (mhlo::AfterAllOp)

Sau tất cả các hoạt động

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 thao tác tạo ra inputs được thực hiện trước bất kỳ thao tác 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 tính: AlwaysSpeculatableImplTrait

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

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

Toán tử:

Kết quả:

mhlo.all_gather (mhlo::AllGatherOp)

Chiến dịch AllGather

Trong mỗi nhóm quy trình trong lưới quy trình, các giá trị của tensor toán hạng từ mỗi quy trình dọc theo all_gather_dim được nối lại với nhau và tạo ra một tensor kết quả. computation được áp dụng riêng biệt 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 tử:

Kết quả:

mhlo.all_reduce (mhlo::AllReduceOp)

Thao tác AllReduce

Trong mỗi nhóm quy trình trong lưới quy trình, một computation hàm giảm được áp dụng cho các giá trị của tensor toán hạng từ mỗi quy trình và tạo ra một tensor kết quả. computation được áp dụng riêng biệt 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 tính: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Toán tử:

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, hàm sẽ chia các giá trị của tensor operand theo chiều split_dimension thành các phần, phân tán các phần đã chia giữa các quy trình, nối các phần đã phân tán theo chiều concat_dimension và tạo ra một tensor 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

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

Thuộc tính:

Toán tử:

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 toán AND từng phần tử của hai tensor lhs và rhs và tạo ra một tensor 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 tính: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Toán tử:

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 tensor operand và tạo ra tensor result .

Ví dụ:

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

Các đặc tính: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán tử:

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 asinh từng phần tử trên tensor operand và tạo ra tensor result .

Ví dụ:

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

Các đặc tính: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán tử:

Kết quả:

mhlo.async_done (mhlo::AsyncDoneOp)

Thao tác AsyncDone

Thao tác này thuộc phạm vi riêng của trình biên dịch XLA, do đó nó chưa có đặc tả kỹ thuật.

Nói một cách không chính thức, thao tác này sẽ chặn quá trình cho đến khi kết thúc 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 hướng dẫn về AsyncStart để biết thêm thông tin.

Giao diện: InferTypeOpInterface

Toán tử:

Kết quả:

mhlo.async_start (mhlo::AsyncStartOp)

Thao tác AsyncStart

Thao tác này thuộc phạm vi riêng của trình biên dịch XLA, do đó nó chưa có đặc tả kỹ thuật.

Nói một cách không chính thức, thao tác này khởi động một quá trình tính toán bất đồng bộ.

Phương pháp này được sử dụng khi có các hàm chứa cả các thao tác chờ không đồng bộ (như DMA) và tính toán trên cùng một 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 một async_start, tiếp theo là một async_update và một async_done. Async_start sẽ thực hiện phép tính đầu tiên trên cùng một luồng và sau đó bắt đầu DMA. Async_update sẽ chờ DMA hoàn tất nếu nó chưa xong, 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ẽ chờ DMA cuối cùng này, sau đó chạy phép tính cuối cùng cần được chạy trên cùng một 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 vào phép tính; called_computation là hàm sẽ được chạy bất đồng bộ; execution_thread là tên của 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ề thể hiện 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ần thiết hoặc được chỉnh sửa bởi thao tác bất đồng bộ.

Thuộc tính:

Toán tử:

Kết quả:

mhlo.async_update (mhlo::AsyncUpdateOp)

Thao tác AsyncUpdate

Thao tác này thuộc phạm vi riêng của trình biên dịch XLA, do đó nó chưa có đặc tả kỹ thuật.

Một cách không chính thức, thao tác này sẽ chặn quá trình tính toán bất đồng bộ cho đến khi gặp rào cản đồng bộ. Sau khi thực hiện các thao tác trên đó, nó sẽ trả về bundle .

Xem tài liệu hướng dẫn về AsyncStart để biết thêm thông tin.

Giao diện: InferTypeOpInterface

Toán tử:

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 từng phần tử trên tensor lhs và rhs , rồi tạo ra tensor 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 tính: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Toán tử:

Kết quả:

mhlo.atanh (mhlo::AtanhOp)

Chiến dịch 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 từng phần tử trên tensor operand và tạo ra tensor result .

Ví dụ:

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

Các đặc tính: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán tử:

Kết quả:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Thao tác BatchNormGrad

Tính toán đạo hàm của một số đầu vào của BatchNormTrainingOp bằng cách lan truyền ngược từ grad_output , và tạo ra các tensor 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 tính: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Thao tác BatchNormInference

Hàm này chuẩn hóa tensor operand trên tất cả các chiều ngoại trừ chiều feature_index và tạo ra tensor 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 tính: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Thao tác BatchNormTraining

Tính toán giá trị trung bình và phương sai trên các chiều không gian và lô, đồng thời chuẩn hóa tensor operand cho mỗi đặc trưng trong chiều feature_index và tạo ra các tensor output , 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 tính: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.bitcast (mhlo::BitcastOp)

Thao tác Bitcast

Cú pháp:

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

Thao tác này thuộc phạm vi riêng của trình biên dịch XLA, do đó nó chưa có đặc tả kỹ thuật.

Nói một cách không chính thức, thao tác này thay đổi hình dạng của dữ liệu đầ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.

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

Ví dụ:

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

Đặc tính: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Toán tử:

Kết quả:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Thao tác BitcastConvert

Cú pháp:

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

Thực hiện phép ép kiểu bit trên tensor operand và tạo ra tensor result , trong đó các bit của toàn bộ tensor operand được diễn giải lại bằng cách sử dụng kiểu của tensor 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 tính: AlwaysSpeculatableImplTrait

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

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

Toán tử:

Kết quả:

mhlo.broadcast (mhlo::BroadcastOp)

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

Thao tác này đang dần bị loại bỏ khỏi StableHLO, vì vậy nó không được bao gồm trong đặc tả kỹ thuật: https://github.com/openxla/stablehlo/issues/3

Nói một cách không chính thức, thao tác này thực hiện điều tương tự 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

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

Thuộc tính:

Toán tử:

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 tensor đầu vào bằng cách sao chép dữ liệu trong tensor operand và tạo ra tensor 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 tính: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.case (mhlo::CaseOp)

Ca phẫu thuật

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 tính: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Giao diện: InferTypeOpInterface

Toán tử:

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ơ toán 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 tính: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.ceil (mhlo::CeilOp)

Thao tác trần

Cú pháp:

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

Thực hiện phép lấy tròn lên từng phần tử của tensor operand và tạo ra tensor result .

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

Ví dụ:

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

Các đặc tính: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Toán tử:

Kết quả:

mhlo.cholesky (mhlo::CholeskyOp)

Phẫu thuật Cholesky

Tính toán phép phân rã Cholesky của một nhóm 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

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

Thuộc tính:

Toán tử:

Kết quả:

mhlo.clamp (mhlo::ClampOp)

Thao tác kẹp

Cú pháp:

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

Hàm này giới hạn mọi phần tử của tensor operand trong khoảng giá trị tối thiểu và tối đa, rồi tạo ra tensor result .

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

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

Toán tử:

Kết quả:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Hoạt động phát sóng tập thể

Trong mỗi nhóm quy trình trong lưới quy trình, hãy gửi giá trị của tensor operand từ quy trình nguồn đến các quy trình đích và tạo ra một tensor 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 tính: Toán CompatibleOperandsAndResultType

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Toán tử:

Kết quả:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Thao tác hoán vị tập thể

Trong mỗi nhóm quy trình trong lưới quy trình, giá trị của tensor operand được gửi từ quy trình nguồn đến quy trình đích và tạo ra một tensor 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 tính: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

Thuộc tính:

Toán tử:

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 tensor lhs và rhs theo comparison_direction và compare_type , và tạo ra một tensor 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>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

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

Thuộc tính:

Toán tử:

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ử sang giá trị phức từ một cặp giá trị thực và ảo ( lhs và rhs , và tạo ra một tensor result .

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

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

Toán tử:

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)

Phép toán tích chập

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)