'mhlo' phương ngữ

Hoạt động

mhlo.abs (mhlo::AbsOp)

Hoạt động cơ bụng

Cú pháp:

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

Thực hiện thao tác abs theo 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 điểm: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Các giao diện: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Toán hạng:

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 theo 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 điểm: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Các giao diện: 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, vì vậy nó chưa có thông số kỹ thuật.

Một cách không chính thức, thao tác này có hai toán hạng: toán hạng dữ liệu và mã thông báo. Đầu ra của hoạt động 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 hoạt động không có tác dụng phụ (những hoạt động 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

Các giao diện: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Toán hạng:

Kết quả:

mhlo.after_all (mhlo::AfterAllOp)

Sau tất 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 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 điểm: AlwaysSpeculatableImplTrait

Các 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 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

Các 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, phân chia các giá trị của tensor operand theo split_dimension thành các phần, phân tán các phần được phân tách giữa các quy trình, nối các phần phân tán dọc theo concat_dimension và tạo ra 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>

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

Các giao diện: 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 AND theo 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 điểm: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Các giao diện: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Toán hạng:

Kết quả:

mhlo.async_done (mhlo::AsyncDoneOp)

Hoạt động không đồng bộ

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

Một cách không chính thức, hoạt động này sẽ chặn cho đến khi kết thúc quá trình tính toán không đồng bộ. Nó trả về kết quả cuối cùng của tính toán không đồ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, vì vậy nó chưa có thông số kỹ thuật.

Một cách không chính thức, hoạt động này khởi động một tính toán không đồng bộ.

Điều này được sử dụng khi có các hàm chứa cả thời gian chờ không đồ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, 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 tính toán đầu tiên trên luồng và sau đó khởi động DMA. async_update sẽ đợi DMA hoàn thành nếu nó chưa hoàn thành, 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 trên 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 chuyển trực tiếp đến tính toán called_computation là hàm sẽ được chạy không đồng bộ execution_thread là tên của luồng mà nó sẽ được chạy trong đó. Chủ đề chính được gọi là "chính". Tất cả các chủ đề đều có tên.

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

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, vì vậy nó chưa có thông số kỹ thuật.

Một cách không chính thức, hoạt động này chặn tính toán không đồng bộ cho đến khi có rào cản đồng bộ hóa. Điều này trả về bundle sau khi hoạt động trên 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 thao tác atan2 theo phần tử trên tensor lhs và rhs và 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 điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Các giao diện: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

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 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 điểm: AlwaysSpeculatableImplTrait , InferTensorType

Các giao diện: 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 kích thước ngoại trừ thứ nguyên 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

Các giao diện: 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 đào tạo BatchNorm

Tính toán giá trị trung bình và phương sai giữa các kích thước lô và không gian, đồng thời chuẩn hóa tenxơ toán operand cho từng tính năng trong thứ nguyên feature_index và tạo ra các tenxơ 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 điểm: AlwaysSpeculatableImplTrait , InferTensorType

Các giao diện: 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ư cho trình biên dịch XLA, vì vậy nó chưa có đặc điểm kỹ thuật.

Về mặt 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 sắp xếp vật lý của các yếu tố không thay đổi.

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

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

Hàng hóa:

Kết quả:

mhlo.bitcast_convert (mhlo :: bitcastconvertop)

BitcastConvert hoạt động

Cú pháp:

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

Thực hiện hoạt động bitcast trên tenxơ operand và tạo ra một tenxơ result trong đó các bit của toàn bộ tenxơ operand được giải thích lại bằng cách sử dụng loại 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: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Hàng hóa:

Kết quả:

mhlo.broadcast (MHLO :: phát sóng)

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

Hoạt động này đang trên đường thoát khỏi StableHlo, vì vậy nó không được đưa vào đặc điểm kỹ thuật: https://github.com/openxla/stablehlo/issues/3

Một cách không chính thức, thao tác này làm điều tương tự như phát sóng 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 điểm: AlwaysSpeculatableImplTrait kiểm InferTensorType SameOperandsAndResultElementType

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

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

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.broadcast_in_dim (mhlo :: phát sóng)

Phát sóng hoạt động

Mở rộng kích thước và/hoặc thứ hạng của một tenxơ đầu vào bằng cách sao chép dữ liệu trong tenxơ operand và tạo ra một 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: HLO_CompatibleOperandsAndResultElementType AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.case (MHLO :: CASEOP)

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

Tạo đầu ra 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

Hàng hóa:

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 hoạt động rễ hình khối yếu tố trên tenxơ operand và tạo ra một tenxơ result .

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType thể SameOperandsAndResultShape soát Elementwise

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

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

Hàng hóa:

Kết quả:

mhlo.ceil (MHLO :: LEOILOP)

Hoạt động trần

Cú pháp:

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

Thực hiện trần phần tử khôn ngoan của tenxơ toán operand và tạo ra một tenxơ result .

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType thể SameOperandsAndResultShape soát Elementwise

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

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

Hàng hóa:

Kết quả:

mhlo.cholesky (MHLO :: Choleskyop)

Hoạt động cholesky

Tính toán sự phân hủy 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 điểm: AlwaysSpeculatableImplTrait kiểm InferTensorType SameOperandsAndResultElementType

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

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

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.clamp (mhlo :: kẹp)

Kẹp hoạt động

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 yếu tố của tenxơ toán operand giữa giá trị tối thiểu và tối đa và tạo ra một 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 InferTensorType HLO_BroadcastingElementwise SameOperandsAndResultElementType

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

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

Hàng hóa:

Kết quả:

mhlo.collective_broadcast (MHLO :: CollectiveBroadcastop)

Hoạt độ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 tenxơ toán operand từ quy trình nguồn đến các quy trình đích và tạo ra một 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:

Hàng hóa:

Kết quả:

mhlo.collective_permute (MHLO :: CollectivePermuteop)

Hoạt động tập thể

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 một 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: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.compare (mhlo :: so sánh)

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 phần tử của lhs và rhs Tensors theo comparison_direction và compare_type , và tạo ra một 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 điểm: AlwaysSpeculatableImplTrait Elementwise SameOperandsElementType InferTensorType SameOperandsAndResultShape

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

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

Thuộc tính:

Hàng hóa:

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 phần tử khôn ngoan thành một giá trị phức tạp từ một cặp giá trị thực và tưởng tượng, lhs và rhs , và tạo ra một 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 điểm: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape SameOperandsElementType

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

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

Hàng hóa:

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)

Đóng gói một hoạt động được tạo thành (bao gồm) các hoạt động ổn định khác, thực hiện inputs và composite_attributes và tạo ra results . Các ngữ nghĩa của OP được thực hiện bởi thuộc tính decomposition . OP composite có thể được thay thế bằng sự phân hủy của nó mà không thay đổi ngữ nghĩa chương trình. Trong trường hợp việc phân hủy nội tuyến không cung cấp cùng một ngữ nghĩa op, thích sử dụng custom_call .

Trường version (mặc định là 0 ) được sử dụng để biểu thị khi ngữ nghĩa của tổng hợp thay đổi.

Xem: 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>

Giao diện: SymbolUserOpInterface

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.concatenate (mhlo :: concatenateop)

Hoạt động liên kết

Concatenates một số lượng các tenxơ trong inputs dọc theo kích thước dimension theo cùng thứ tự với các đối số đã cho và tạo ra một tenxơ result .

Xem: 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>

Đặc điểm: AlwaysSpeculatableImplTrait SameOperandsAndResultElementType

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

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

Thuộc tính:

Hàng hóa:

Kết quả:

mhlo.constant (mhlo :: hằng số)

Hoạt động liên tục

Tạo ra một tenxơ output từ một value không đổi.

Xem: 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>

Đặc điểm: AlwaysSpeculatableImplTrait , ConstantLike

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

Hiệu ứng: 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{}

Attributes:

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

Attributes:

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

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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.

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

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

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

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

Attributes:

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.

Attributes:

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

Attributes:

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

Attributes:

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)

Extracts element at index position of the operand tuple and produces a result .

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

Ví dụ:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Kết quả:

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

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

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

Kết quả:

mhlo.imag (mhlo::ImagOp)

Imag operation

Cú pháp:

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

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

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

Ví dụ:

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

Ví dụ:

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

Attributes:

Operands:

Kết quả:

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

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

Ví dụ:

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Kết quả:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Cú pháp:

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

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

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

Ví dụ:

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Kết quả:

mhlo.log (mhlo::LogOp)

Log operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Kết quả: