'mhlo' phương ngữ

Hoạt động

mhlo.abs (mhlo::AbsOp)

Hoạt động abs

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của số nguyên không dấu 2/4/8/16/32/64-bit hoặc kiểu float hoặc phức hợp 4/6/8/16/32/64-bit với các phần tử float 32/64-bit hoặc số nguyên có dấu lượng tử hóa đồng đều 2/4/8/16/32-bit hoặc số nguyên có dấu lượng tử hóa đồng đều 2/4/8/16/32-bit hoặc số nguyên không dấu lượng tử hóa đồng đều 2/4/8/16/32-bit hoặc giá trị số nguyên không dấu lượng tử hóa đồng đều 2/4/8/16/32-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng của số nguyên không dấu 2/4/8/16/32/64 bit hoặc số thực 4/6/8/16/32/64 bit hoặc số nguyên có dấu lượng tử hóa đồng đều 2/4/8/16/32 bit hoặc số nguyên có dấu lượng tử hóa đồng đều 2/4/8/16/32 bit theo trục hoặc số nguyên không dấu lượng tử hóa đồng đều 2/4/8/16/32 bit theo trục giá trị số nguyên không dấu

mhlo.acos (mhlo::AcosOp)

Hoạt động Acos

Cú pháp:

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

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

Ví dụ:

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

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

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

mhlo.acosh (mhlo::AcoshOp)

Hoạt động Acosh

Cú pháp:

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

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

Ví dụ:

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

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

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

mhlo.add (mhlo::AddOp)

Thêm hoạt động

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục
rhs	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.add_dependency (mhlo::AddDependencyOp)

Hoạt động AddDependency

Cú pháp:

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

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc tenxơ xếp hạng của các giá trị lượng tử nguyên trên mỗi trục hoặc mã thông báo hoặc mã thông báo stablehlo
token	token hoặc token stablehlo

Kết quả:

Kết quả	Sự miêu tả
output	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc tenxơ xếp hạng của các giá trị lượng tử nguyên trên mỗi trục hoặc mã thông báo hoặc mã thông báo stablehlo

mhlo.after_all (mhlo::AfterAllOp)

Hoạt động AfterAll

Cú pháp:

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

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Toán hạng:

Toán hạng	Sự miêu tả
inputs	variadic của token

Kết quả:

Kết quả	Sự miêu tả
result	mã thông báo

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:

Thuộc tính	Loại MLIR	Sự miêu tả
all_gather_dim	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm
replica_groups	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	hai số nguyên 64 bit 'xử lý' và 'kiểu'
use_global_device_ids	::mlir::UnitAttr	thuộc tính đơn vị

Toán hạng:

Toán hạng	Sự miêu tả
operands	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

mhlo.all_reduce (mhlo::AllReduceOp)

Hoạt động AllReduce

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

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

Ví dụ:

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

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

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
replica_groups	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	hai số nguyên 64 bit 'xử lý' và 'kiểu'
use_global_device_ids	::mlir::UnitAttr	thuộc tính đơn vị

Toán hạng:

Toán hạng	Sự miêu tả
operands	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

mhlo.all_to_all (mhlo::AllToAllOp)

Hoạt động AllToAll

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

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

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
split_dimension	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm
concat_dimension	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm
split_count	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị dương
replica_groups	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	hai số nguyên 64 bit 'xử lý' và 'kiểu'

Toán hạng:

Toán hạng	Sự miêu tả
operand	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic của tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

mhlo.and (mhlo::AndOp)

Và hoạt động

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tenxơ xếp hạng của bool hoặc các giá trị số nguyên 2/4/8/16/32/64-bit
rhs	tenxơ xếp hạng của bool hoặc các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.asin (mhlo::AsinOp)

Hoạt động Asin

Cú pháp:

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

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

Ví dụ:

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

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

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

mhlo.async_done (mhlo::AsyncDoneOp)

Hoạt động AsyncDone

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

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

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

Giao diện: InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
bundle	async_bundle với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục hoặc các giá trị token hoặc token stablehlo

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

variadic của tenxơ được xếp hạng là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc các giá trị số nguyên được lượng tử hóa theo từng trục hoặc token hoặc stablehlo token hoặc tuple lồng nhau với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc memref là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc tenxơ được xếp hạng là số nguyên trên mỗi trục giá trị lượng tử hoặc giá trị mã thông báo

mhlo.async_start (mhlo::AsyncStartOp)

Hoạt động AsyncStart

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

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
called_computation	::mlir::FlatSymbolRefAttr	thuộc tính tham chiếu ký hiệu phẳng
execution_thread	::mlir::StringAttr	thuộc tính chuỗi

Toán hạng:

Toán hạng

Sự miêu tả

inputs

variadic của tenxơ được xếp hạng là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc các giá trị số nguyên được lượng tử hóa theo từng trục hoặc token hoặc stablehlo token hoặc tuple lồng nhau với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc memref là 4/6/8/16/32/64 bit float hoặc bool hoặc 2/4/8/16/32/64 bit số nguyên hoặc kiểu phức hợp với các phần tử float 32/64 bit hoặc các giá trị số nguyên được lượng tử hóa theo từng tenxơ hoặc tenxơ được xếp hạng là số nguyên trên mỗi trục giá trị lượng tử hoặc giá trị mã thông báo

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	async_bundle với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục hoặc các giá trị token hoặc token stablehlo

mhlo.async_update (mhlo::AsyncUpdateOp)

Hoạt động AsyncUpdate

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

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

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

Giao diện: InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
bundle	async_bundle với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục hoặc các giá trị token hoặc token stablehlo

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	async_bundle với bất kỳ sự kết hợp nào của tenxơ được xếp hạng là 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục hoặc các giá trị token hoặc token stablehlo

mhlo.atan2 (mhlo::Atan2Op)

Hoạt động Atan2

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tenxơ xếp hạng có kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa trên mỗi tenxơ
rhs	tenxơ xếp hạng có kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa trên mỗi tenxơ

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng có kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa trên mỗi tenxơ

mhlo.atanh (mhlo::AtanhOp)

Hoạt động Atanh

Cú pháp:

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

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

Ví dụ:

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

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

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Hoạt động BatchNormGrad

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
epsilon	::mlir::FloatAttr	Thuộc tính float 32-bit
feature_index	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit
scale	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
mean	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
variance	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
grad_output	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
grad_operand	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit
grad_scale	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
grad_offset	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Hoạt động BatchNormInference

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
epsilon	::mlir::FloatAttr	Thuộc tính float 32-bit
feature_index	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit
scale	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
offset	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
mean	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
variance	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Hoạt động BatchNormTraining

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
epsilon	::mlir::FloatAttr	Thuộc tính float 32-bit
feature_index	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64-bit có giá trị không âm

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit
scale	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
offset	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
output	tenxơ xếp hạng của các giá trị float 4/6/8/16/32/64-bit
batch_mean	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit
batch_var	Tensor 1D của các giá trị float 4/6/8/16/32/64-bit

mhlo.bitcast (mhlo::BitcastOp)

Hoạt động Bitcast

Cú pháp:

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

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

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Hoạt động BitcastConvert

Cú pháp:

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

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.broadcast (mhlo::BroadcastOp)

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

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

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

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
broadcast_sizes	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Hoạt động BroadcastInDim

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
broadcast_dimensions	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ có hình dạng tĩnh hoặc có một chiều bị giới hạn với kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc các giá trị lượng tử nguyên trên mỗi trục

mhlo.case (mhlo::CaseOp)

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

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

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

Ví dụ:

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

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

Giao diện: InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
index	tenxơ của các giá trị số nguyên không dấu 32 bit

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic của tenxơ xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit integer hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị lượng tử nguyên trên mỗi tenxơ hoặc tenxơ xếp hạng của các giá trị lượng tử nguyên trên mỗi trục hoặc token

mhlo.cbrt (mhlo::CbrtOp)

Hoạt động Cbrt

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Độ chính xác được yêu cầu cho các phép toán đơn nhất.

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng có kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa trên mỗi tenxơ

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng có kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa trên mỗi tenxơ

mhlo.ceil (mhlo::CeilOp)

Hoạt động trần nhà

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ được xếp hạng của các giá trị số thực 4/6/8/16/32/64-bit hoặc số nguyên được lượng tử hóa theo tenxơ

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ được xếp hạng của các giá trị số thực 4/6/8/16/32/64-bit hoặc số nguyên được lượng tử hóa theo tenxơ

mhlo.cholesky (mhlo::CholeskyOp)

Phẫu thuật Cholesky

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

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

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
lower	::mlir::BoolAttr	thuộc tính bool

Toán hạng:

Toán hạng	Sự miêu tả
a	tenxơ xếp hạng của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float 4/6/8/16/32/64-bit hoặc kiểu phức hợp với các giá trị phần tử float 32/64-bit

mhlo.clamp (mhlo::ClampOp)

Hoạt động kẹp

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
min	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục
max	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Hoạt động CollectiveBroadcast

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

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

Ví dụ:

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

Đặc điểm: CompatibleOperandsAndResultType

Giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
replica_groups	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	hai số nguyên 64 bit 'xử lý' và 'kiểu'

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Hoạt động CollectivePermute

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

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

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
source_target_pairs	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	hai số nguyên 64 bit 'xử lý' và 'kiểu'

Toán hạng:

Toán hạng	Sự miêu tả
operand	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

mhlo.compare (mhlo::CompareOp)

So sánh hoạt động

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	Thực hiện phép so sánh nào?
compare_type	::mlir::mhlo::ComparisonTypeAttr	Nên sử dụng loại so sánh nào?

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục
rhs	tenxơ xếp hạng của kiểu float hoặc bool 4/6/8/16/32/64-bit hoặc kiểu số nguyên hoặc kiểu phức hợp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị số nguyên lượng tử hóa theo tenxơ hoặc các giá trị số nguyên lượng tử hóa theo trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tenxơ xếp hạng của các giá trị bool

mhlo.complex (mhlo::ComplexOp)

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

Cú pháp:

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

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

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tenxơ xếp hạng của các giá trị float 32/64-bit
rhs	tenxơ xếp hạng của các giá trị float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tenxơ xếp hạng kiểu phức với các giá trị phần tử float 32/64-bit

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 thao tác được tạo thành từ các thao tác StableHLO khác, lấy inputs và composite_attributes rồi tạo ra results . Ngữ nghĩa của op được triển khai bởi thuộc tính decomposition . Op composite có thể được thay thế bằng phép phân tách của nó mà không làm thay đổi ngữ nghĩa chương trình. Trong trường hợp việc nội tuyến phép phân tách không cung cấp cùng ngữ nghĩa op, hãy ưu tiên sử dụng custom_call .

Trường version (mặc định là 0 ) được sử dụng để biểu thị thời điểm ngữ nghĩa của một hợp phần 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:

Thuộc tính	Loại MLIR	Sự miêu tả
name	::mlir::StringAttr	thuộc tính chuỗi
composite_attributes	::mlir::DictionaryAttr	từ điển các giá trị thuộc tính được đặt tên
decomposition	::mlir::FlatSymbolRefAttr	thuộc tính tham chiếu biểu tượng phẳng
version	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 32 bit

Toán hạng:

Toán hạng

Sự miêu tả

inputs

biến thể của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc số nguyên mỗi tensor được lượng tử hóa hoặc các giá trị số nguyên được lượng tử hóa trên mỗi trục hoặc mã thông báo hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị được lượng tử hóa trên mỗi tensor hoặc tenxơ xếp hạng của giá trị hoặc mã thông báo số nguyên trên mỗi trục giá trị

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

biến thể của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc số nguyên mỗi tensor được lượng tử hóa hoặc các giá trị số nguyên được lượng tử hóa trên mỗi trục hoặc mã thông báo hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị được lượng tử hóa trên mỗi tensor hoặc tenxơ xếp hạng của giá trị hoặc mã thông báo số nguyên trên mỗi trục giá trị

mhlo.concatenate (mhlo::ConcatenateOp)

Hoạt động nối

Ghép một số tensor khác nhau trong inputs dọc theo chiều thứ dimension theo cùng thứ tự với các đối số đã cho và tạo ra một tensor 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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
dimension	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị không âm

Toán hạng:

Toán hạng	Sự miêu tả
val	biến thể của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.constant (mhlo::ConstantOp)

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
value	::mlir::ElementsAttr	thuộc tính vectơ/tensor không đổi

Kết quả:

Kết quả	Sự miêu tả
output	tensor có hình dạng tĩnh của float hoặc bool 4/6/8/16/32/64-bit hoặc số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.convert (mhlo::ConvertOp)

Chuyển đổi hoạt động

Cú pháp:

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

Thực hiện chuyển đổi theo từng phần tử từ loại phần tử này sang loại phần tử khác trên tenxơ operand và tạo ra một tenxơ result .

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

Ví dụ:

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

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

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.convolution (mhlo::ConvolutionOp)

Hoạt động 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)

Tính tích số chấm giữa các cửa sổ của lhs và các lát rhs và tạo ra result .

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

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
window_strides	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
padding	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
lhs_dilation	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
rhs_dilation	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
window_reversal	::mlir::DenseElementsAttr	thuộc tính vectơ/tensor boolean không đổi
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Cấu trúc thông tin thứ nguyên cho chuyển đổi
feature_group_count	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị dương
batch_group_count	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị dương
precision_config	::mlir::ArrayAttr	Thuộc tính cấu hình chính xác

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.copy (mhlo::CopyOp)

Thao tác sao chép

Cú pháp:

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

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 là một bản sao của operand . Tùy thuộc vào siêu dữ liệu được đính kèm với hoạt động, nó có thể hoạt động hoàn toàn khác với hoạt động không hoạt động.

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
cross_program_prefetch_index	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 32 bit

Toán hạng:

Toán hạng

Sự miêu tả

operand

tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc số nguyên 2/4/8/16/32/64-bit hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hoặc số nguyên trên mỗi tensor được lượng tử hóa hoặc số nguyên trên mỗi trục hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị được lượng tử hóa trên mỗi tensor hoặc tenxơ xếp hạng của giá trị lượng tử hóa số nguyên trên mỗi trục hoặc giá trị mã thông báo

Kết quả:

Kết quả

Sự miêu tả

result

tenxơ xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc số nguyên 2/4/8/16/32/64-bit hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hoặc số nguyên trên mỗi tensor được lượng tử hóa hoặc số nguyên trên mỗi trục hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị được lượng tử hóa trên mỗi tensor hoặc tenxơ xếp hạng của giá trị lượng tử hóa số nguyên trên mỗi trục hoặc giá trị mã thông báo

mhlo.cosh (mhlo::CoshOp)

Hoạt động tiền tệ

Cú pháp:

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

Thực hiện phép toán cosh theo phần tử trên tensor operand và tạo ra tensor result .

Ví dụ:

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

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

Các giao diện: InferShapedTypeOpInterface , InferTypeOpInterface

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor của loại float 4/6/8/16/32/64-bit hoặc loại phức tạp với các giá trị phần tử float 32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor của loại float 4/6/8/16/32/64-bit hoặc loại phức tạp với các giá trị phần tử float 32/64-bit

mhlo.cosine (mhlo::CosineOp)

Hoạt động cosine

Cú pháp:

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

Thực hiện phép toán cosine 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#cosine

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Độ chính xác được yêu cầu cho các hoạt động đơn nhất.

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor

mhlo.count_leading_zeros (mhlo::ClzOp)

hoạt động Clz

Cú pháp:

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

Thực hiện đếm phần tử số bit 0 đứng đầu trong tensor operand và tạo ra tensor result .

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

Ví dụ:

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

Đặ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:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của các giá trị nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của các giá trị nguyên 2/4/8/16/32/64-bit

mhlo.create_token (mhlo::CreateTokenOp)

Hoạt động CreateToken

Cú pháp:

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

Hoạt động này sắp được đưa ra khỏi StableHLO nên không có trong thông số 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 thực hiện tương tự như AfterAllOp với 0 đầu vào: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Ví dụ:

%output = mhlo.create_token : !mhlo.token

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Kết quả:

Kết quả	Sự miêu tả
output	mã thông báo

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

Hoạt động CrossReplicaSum

Hoạt động này sắp được đưa ra khỏi StableHLO nên không có trong thông số 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 thực hiện tương tự như AllReduceOp vớichannel_id channel_id = 0 , use_global_device_ids = false và bổ sung triển khai computation : 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>

Đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
replica_groups	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.custom_call (mhlo::CustomCallOp)

Hoạt động cuộc gọi tùy chỉnh

Cú pháp:

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

Đóng gói một hoạt động do triển khai xác định call_target_name nhận inputs và called_computations rồi tạo ra results .

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

Giao diện: MemoryEffectOpInterface

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
call_target_name	::mlir::StringAttr	thuộc tính chuỗi
has_side_effect	::mlir::BoolAttr	thuộc tính bool
backend_config	::mlir::Thuộc tính	thuộc tính chuỗi hoặc từ điển của các giá trị thuộc tính được đặt tên
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Phiên bản API cuộc gọi tùy chỉnh
called_computations	::mlir::ArrayAttr	thuộc tính mảng ref biểu tượng phẳng
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Chỉ định lịch trình mong muốn cho cuộc gọi tùy chỉnh.
operand_layouts	::mlir::ArrayAttr	Mảng thuộc tính bố cục (tensor 1D của loại chỉ mục)
result_layouts	::mlir::ArrayAttr	Mảng thuộc tính bố cục (tensor 1D của loại chỉ mục)
output_operand_aliases	::mlir::ArrayAttr	Thuộc tính bí danh cho đầu ra và toán hạng của CustomCall

Toán hạng:

Toán hạng

Sự miêu tả

inputs

biến thể của tenxơ 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc số nguyên trên mỗi trục hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc mã thông báo hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor của 4/6/8/16/32/64-bit float hoặc bool hoặc số nguyên hoặc kiểu phức tạp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc số nguyên trên mỗi tensor các giá trị lượng tử hóa hoặc số nguyên trên mỗi trục hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với phần tử float 32/64-bit hoặc giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc giá trị mã thông báo

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

biến thể của tenxơ 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc số nguyên trên mỗi trục hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc Số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc mã thông báo hoặc bộ dữ liệu lồng nhau với bất kỳ sự kết hợp nào của tensor của 4/6/8/16/32/64-bit float hoặc bool hoặc số nguyên hoặc kiểu phức tạp 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc số nguyên trên mỗi tensor các giá trị lượng tử hóa hoặc số nguyên trên mỗi trục hoặc memref của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với phần tử float 32/64-bit hoặc giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc giá trị mã thông báo

mhlo.divide (mhlo::DivOp)

hoạt động phân chia

Cú pháp:

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

Thực hiện phép chia theo phần tử của tensor bị chia lhs và tensor chia rhs và tạo ra một tensor result .

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

Ví dụ:

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

Đặ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:

Toán hạng	Sự miêu tả
lhs	tensor xếp hạng của số nguyên 2/4/8/16/32/64-bit hoặc kiểu float hoặc kiểu phức 4/6/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của số nguyên 2/4/8/16/32/64-bit hoặc kiểu float hoặc kiểu phức 4/6/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của số nguyên 2/4/8/16/32/64-bit hoặc kiểu float hoặc kiểu phức 4/6/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.domain (mhlo::DomainOp)

Hoạt động tên miền

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, các thao tác này được sử dụng để nhóm các hướng dẫn có cùng thuộc tính DomainMetadata. ShardingMetadata là trường hợp sử dụng chính hiện nay để nhóm các hướng dẫn trên cùng một thiết bị. Hướng dẫn tên miền cung cấp hai lợi ích chính:

• Ngăn chặn các hướng dẫn tối ưu hóa ngoài ý muốn trên các miền.
• Tự động gán siêu dữ liệu của các hướng dẫn được tạo trong miền. Nếu không có hướng dẫn tên miền, mỗi lần tối ưu hóa HLO sẽ phải kiểm tra và truyền siêu dữ liệu, điều này sẽ dễ bị bỏ sót và cũng làm tăng thêm độ phức tạp cho trình biên dịch. Vì các lệnh miền kết nối hai miền khác nhau nên mỗi lệnh miền được liên kết với hai DomainMetadata -- một ở phía toán hạng và một ở phía người dùng của miền.

Đặc điểm: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
kind	::mlir::mhlo::DomainKindAttr	Loại siêu dữ liệu miền được đính kèm với miền HLO.
entry_metadata	::mlir::StringAttr	thuộc tính chuỗi
exit_metadata	::mlir::StringAttr	thuộc tính chuỗi

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc tensor xếp hạng của các giá trị hoặc mã thông báo được lượng tử hóa số nguyên trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc tensor xếp hạng của các giá trị hoặc mã thông báo được lượng tử hóa số nguyên trên mỗi trục

mhlo.dot (mhlo::DotOp)

Thao tác chấm

Hoạt động này sắp được đưa ra khỏi StableHLO nên không có trong thông số 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 thực hiện tương tự như Dot của XLA: https://www.tensorflow.org/xla/Operation_semantics#dot

Ví dụ:

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

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
precision_config	::mlir::ArrayAttr	Thuộc tính cấu hình chính xác

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dot_general (mhlo::DotGeneralOp)

DotHoạt động chung

Tính tích số chấm giữa các lát lhs và các lát rhs và tạo ra result tensor.

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Thuộc tính mô hình hóa thông tin kích thước cho dấu chấm.
precision_config	::mlir::ArrayAttr	Thuộc tính cấu hình chính xác
algorithm	::mlir::mhlo::DotAlgorithmAttr	Thuộc tính mô hình hóa các ràng buộc thuật toán để sử dụng cho tính toán dấu chấm.

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

Hoạt động DynamicBroadcastInDim

Hoạt động này có chức năng giống với hoạt động Broadcast_in_dim op, nhưng hình dạng kết quả được chỉ định động thông qua output_dimensions .

Nó cũng chấp nhận các thuộc tính tùy chọn để thể hiện kiến thức tĩnh về hoạt động mở rộng của các chiều. Nếu không được chỉ định, tất cả các kích thước được coi là có thể mở rộng. Các tập hợp kích thước được biết là đang mở rộng và tập hợp các kích thước được biết là không mở rộng phải tách rời nhau và chúng phải là tập hợp con của các kích thước của toán hạng.

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
broadcast_dimensions	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
known_expanding_dimensions	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
output_dimensions	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_conv (mhlo::DynamicConvOp)

Hoạt động DynamicConv

Hoạt động này đang được tiến hành nên chưa được đưa vào đặc tả: https://github.com/openxla/stablehlo/issues/8

Một cách không chính thức, thao tác này thực hiện tương tự như ConvolutionOp ngoại trừ padding được chỉ định động thông qua 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>

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
window_strides	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
padding	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
lhs_dilation	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
rhs_dilation	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit
window_reversal	::mlir::DenseElementsAttr	thuộc tính vectơ/tensor boolean không đổi
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Cấu trúc thông tin thứ nguyên cho chuyển đổi
feature_group_count	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị dương
batch_group_count	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị dương
precision_config	::mlir::ArrayAttr	Thuộc tính cấu hình chính xác

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
d_padding	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

Hoạt động DynamicGather

Hoạt động này đang được tiến hành nên chưa được đưa vào đặc tả: https://github.com/openxla/stablehlo/issues/8

Một cách không chính thức, thao tác này thực hiện tương tự như GatherOp ngoại trừ slice_sizes được chỉ định động: 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>

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Thuộc tính mô hình hóa thông tin thứ nguyên để thu thập
indices_are_sorted	::mlir::BoolAttr	thuộc tính bool

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
start_indices	tensor xếp hạng của các giá trị nguyên 2/4/8/16/32/64-bit
slice_sizes	tenxơ số nguyên 1 chiều có hình dạng tĩnh của các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

Hoạt động DynamicIota

Hoạt động này giống về mặt chức năng với iota op, nhưng hình dạng kết quả được chỉ định động thông qua output_shape .

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
iota_dimension	::mlir::IntegerAttr	Thuộc tính số nguyên không dấu 64 bit có giá trị không âm

Toán hạng:

Toán hạng	Sự miêu tả
output_shape	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_pad (mhlo::DynamicPadOp)

Hoạt động DynamicPad

Cú pháp:

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

Tự động đệm operand , với lượng khoảng đệm được thêm vào ở cấp thấp/cấp cao/bên trong được truyền qua các tensor đầu vào.

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
padding_value	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
edge_padding_low	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit
edge_padding_high	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit
interior_padding	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

Hoạt động định hình lại động

Cú pháp:

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

Hoạt động này có chức năng giống hệt với việc định hình lại op, nhưng hình dạng kết quả được chỉ định động thông qua output_shape .

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

Đặc điểm: AlwaysSpeculatableImplTrait

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
output_shape	Tenor 1D của chỉ số hoặc các giá trị số nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

Hoạt động DynamicSlice

Trích xuất một lát cắt từ operand bằng cách sử dụng các chỉ số bắt đầu được tính toán động và tạo ra một tenxơ result .

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

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
slice_sizes	::mlir::DenseIntElementsAttr	Thuộc tính phần tử số nguyên không dấu 64-bit

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
start_indices	biến thể của tenxơ 0D có giá trị nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor được xếp hạng của float hoặc bool 4/6/8/16/32/64-bit hoặc số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

Hoạt động DynamicUpdateSlice

Cú pháp:

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

Tạo ra một tenxơ result bằng với tenxơ toán operand ngoại trừ lát cắt bắt đầu tại start_indices được cập nhật với các giá trị trong update .

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

Đặc điểm: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
update	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
start_indices	biến thể của tenxơ 0D có giá trị nguyên 2/4/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.einsum (mhlo::EinsumOp)

hoạt động einsum

Hoạt động này sắp được đưa ra khỏi StableHLO nên không có trong thông số 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 thực hiện tương tự như einsum của TF: 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>

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
einsum_config	::mlir::StringAttr	thuộc tính chuỗi

Toán hạng:

Toán hạng	Sự miêu tả
lhs	tensor được xếp hạng của float hoặc bool 4/6/8/16/32/64-bit hoặc số nguyên hoặc loại phức 2/4/8/16/32/64-bit với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục
rhs	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor xếp hạng của 4/6/8/16/32/64-bit float hoặc bool hoặc 2/4/8/16/32/64-bit số nguyên hoặc loại phức với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor hoặc các giá trị được lượng tử hóa trên mỗi trục

mhlo.erf (mhlo::ErfOp)

Hoạt động Erf

Cú pháp:

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

Thực hiện thao tác erf theo phần tử trên tensor operand và tạo ra tensor result .

Ví dụ:

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

Đặ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:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng của các giá trị float 4/6/8/16/32/64-bit

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng của các giá trị float 4/6/8/16/32/64-bit

mhlo.exponential (mhlo::ExpOp)

hoạt động kinh nghiệm

Cú pháp:

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

Thực hiện phép toán hàm mũ 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#exponential

Ví dụ:

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

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

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

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

Thuộc tính:

Thuộc tính	Loại MLIR	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Độ chính xác được yêu cầu cho các hoạt động đơn nhất.

Toán hạng:

Toán hạng	Sự miêu tả
operand	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor

Kết quả:

Kết quả	Sự miêu tả
result	tensor xếp hạng 4/6/8/16/32/64-bit float hoặc loại phức tạp với các phần tử float 32/64-bit hoặc các giá trị lượng tử hóa số nguyên trên mỗi tensor

mhlo.exponential_minus_one (mhlo::Expm1Op)

Hoạt động Expm1

Cú pháp:

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

Thực hiện hàm mũ trừ một phần tử trên tenxơ toán operand và tạo ra một tenxơ result .

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

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

Thuộc tính	MLIR Type	Sự miêu tả
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

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:

Thuộc tính	MLIR Type	Sự miêu tả
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Kết quả:

Kết quả

Sự miêu tả

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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:

Thuộc tính	MLIR Type	Sự miêu tả
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

Thuộc tính	MLIR Type	Sự miêu tả
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	tensor of 32-bit signless integer values

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

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Toán hạng

Sự miêu tả

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

Giao diện: InferTypeOpInterface

Operands:

Toán hạng	Sự miêu tả
pred	ranked tensor of bool values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

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:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float values

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)

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Toán hạng	Sự miêu tả
token	mã thông báo

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

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

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Kết quả:

Kết quả	Sự miêu tả
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

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:

Toán hạng	Sự miêu tả
x	ranked tensor of 4/6/8/16/32/64-bit float values

Kết quả:

Kết quả	Sự miêu tả
y	ranked tensor of bool values

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

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

Cú pháp:

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

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

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

Ví dụ:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

Ví dụ:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

Cú pháp:

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

Cú pháp:

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

Cú pháp:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
shapes	variadic of 1D tensor of index values

Kết quả:

Kết quả	Sự miêu tả
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Cú pháp:

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

Cú pháp:

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

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

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

Ví dụ:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

Cú pháp:

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

Ví dụ:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Cú pháp:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

Ví dụ:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Kết quả:

Kết quả	Sự miêu tả
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

Cú pháp:

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

Ví dụ:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Giao diện: InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	mã thông báo

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	mã thông báo

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

Ví dụ:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

Cú pháp:

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

Produces partition_id of the current process.

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

Ví dụ:

%result = mhlo.partition_id : tensor<ui32>

Giao diện: InferTypeOpInterface

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Cú pháp:

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

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

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

Ví dụ:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Cú pháp:

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

Ví dụ:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Cú pháp:

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

Ví dụ:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

Ví dụ:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
token	mã thông báo

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

Ví dụ:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

Cú pháp:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

Ví dụ:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Kết quả:

Kết quả	Sự miêu tả
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

Hoạt động ReduceScatter

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

Ví dụ:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	thuộc tính đơn vị

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

Ví dụ:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

Cú pháp:

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

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

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

Ví dụ:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

Cú pháp:

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

Produces replica_id of the current process.

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

Ví dụ:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Cú pháp:

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

Performs reshape of operand tensor to a result tensor.

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

Ví dụ:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

Ví dụ:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Toán hạng	Sự miêu tả
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

Ví dụ:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

Toán hạng	Sự miêu tả
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

Kết quả:

Kết quả	Sự miêu tả
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

Cú pháp:

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Cú pháp:

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Cú pháp:

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

Ví dụ:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Giao diện: InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

Cú pháp:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

Ví dụ:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

Ví dụ:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Giao diện: InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

Ví dụ:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Giao diện: InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	mã thông báo

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	mã thông báo

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

Ví dụ:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

Cú pháp:

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Ví dụ:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Cú pháp:

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Ví dụ:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Cú pháp:

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Ví dụ:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Cú pháp:

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

Returns the sign of the operand element-wise and produces a result tensor.

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

Ví dụ:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

Cú pháp:

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

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

Ví dụ:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Toán hạng	Sự miêu tả
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Kết quả:

Kết quả	Sự miêu tả
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

Ví dụ:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

Ví dụ:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Toán hạng	Sự miêu tả
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

Cú pháp:

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

Cú pháp:

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

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

Informally, this operation returns Tan(operand) element-wise.

Ví dụ:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

Cú pháp:

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

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

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

Ví dụ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

Cú pháp:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

Ví dụ:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

Ví dụ:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

Cú pháp:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

Ví dụ:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
tag	::mlir::StringAttr	string attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

Ví dụ:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

Ví dụ:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

Toán hạng	Sự miêu tả
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

Cú pháp:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

Ví dụ:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng

Sự miêu tả

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả

Sự miêu tả

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

Cú pháp:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

Ví dụ:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Cú pháp:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

Ví dụ:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

Ví dụ:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

Toán hạng

Sự miêu tả

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Kết quả:

Kết quả

Sự miêu tả

"vô danh"

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

Cú pháp:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Giao diện: InferTypeOpInterface

Thuộc tính:

Thuộc tính	MLIR Type	Sự miêu tả
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Kết quả:

Kết quả	Sự miêu tả
"vô danh"	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Cú pháp:

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

Ví dụ:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Toán hạng	Sự miêu tả
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Kết quả:

Kết quả	Sự miêu tả
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Thuộc tính

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

Các thông số:

Tham số	C++ type	Sự miêu tả
argTupleIndices	::llvm::ArrayRef<int64_t>	Kích thước
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Kích thước
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Cú pháp:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Các thông số:

Tham số	C++ type	Sự miêu tả
xử lý	int64_t
kiểu	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Cú pháp:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Cú pháp:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Các thông số:

Tham số	C++ type	Sự miêu tả
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Kích thước
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Kích thước
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Kích thước

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Cú pháp:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

Ví dụ,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

Các thông số:

Tham số	C++ type	Sự miêu tả
tham số	int64_t
chỉ số	::llvm::ArrayRef<int64_t>	Kích thước
bù lại	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Cú pháp:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Cú pháp:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Cú pháp:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Cú pháp:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Các thông số:

Tham số	C++ type	Sự miêu tả
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

Các thông số:

Tham số	C++ type	Sự miêu tả
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Kích thước
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Kích thước
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Kích thước
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Kích thước

FftTypeAttr

XLA fast fourier transform type.

Cú pháp:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Cú pháp:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Các thông số:

Tham số	C++ type	Sự miêu tả
offsetDims	::llvm::ArrayRef<int64_t>	Kích thước
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Kích thước
operandBatchingDims	::llvm::ArrayRef<int64_t>	Kích thước
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Kích thước
startIndexMap	::llvm::ArrayRef<int64_t>	Kích thước
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Cú pháp:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

Các thông số:

Tham số	C++ type	Sự miêu tả
outputTupleIndices	::llvm::ArrayRef<int64_t>	Kích thước
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Kích thước

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Cú pháp:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Các thông số:

Tham số	C++ type	Sự miêu tả
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Kích thước
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Kích thước

ResultAccuracyAttr

The requested accuracy for unary ops.

Các thông số:

Tham số	C++ type	Sự miêu tả
atol	APFloat
rtol	APFloat
ulps	int64_t
cách thức	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Cú pháp:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Cú pháp:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Cú pháp:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Các thông số:

Tham số	C++ type	Sự miêu tả
updateWindowDims	::llvm::ArrayRef<int64_t>	Kích thước
insertedWindowDims	::llvm::ArrayRef<int64_t>	Kích thước
inputBatchingDims	::llvm::ArrayRef<int64_t>	Kích thước
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Kích thước
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Kích thước
indexVectorDim	int64_t

TransposeAttr

Transpose options

Cú pháp:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Các thông số:

Tham số	C++ type	Sự miêu tả
giá trị	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Cú pháp:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

Các thông số:

Tham số	C++ type	Sự miêu tả
ranh giới	::llvm::ArrayRef<int64_t>

Các loại

AsyncBundleType

Opaque collection of other types

Cú pháp:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Các thông số:

Tham số	C++ type	Sự miêu tả
các loại	::llvm::ArrayRef<Type>

Enum

ComparisonDirection

Which comparison operation to perform.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
EQ	0	EQ
Đông Bắc	1	Đông Bắc
GE	2	GE
GT	3	GT
LE	4	LE
Trung úy	5	Trung úy

ComparisonType

Which comparison type to use.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
NOTYPE	0	NOTYPE
TRÔI NỔI	1	TRÔI NỔI
TOTALORDER	2	TOTALORDER
ĐÃ KÝ	3	ĐÃ KÝ
CHƯA ĐĂNG KÝ	4	CHƯA ĐĂNG KÝ

CustomCallApiVersion

Custom call API version

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
KHÔNG CÓ	0	KHÔNG CÓ
MỚI NHẤT	1	MỚI NHẤT
SỚM NHẤT	2	SỚM NHẤT

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
phân mảnh	0	phân mảnh

FftType

XLA fast fourier transform type.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Độ chính xác

XLA precision for an operand. Has backend specific meaning.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
MẶC ĐỊNH	0	MẶC ĐỊNH
CAO	1	CAO
CAO NHẤT	2	CAO NHẤT

ResultAccuracyMode

XLA result accuracy mode.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
MẶC ĐỊNH	0	MẶC ĐỊNH
CAO NHẤT	1	CAO NHẤT
SỨC CHỊU ĐỰNG	2	SỨC CHỊU ĐỰNG

RngAlgorithm

XLA PRNG algorithm to be used.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
MẶC ĐỊNH	0	MẶC ĐỊNH
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
ĐỒNG PHỤC	1	ĐỒNG PHỤC
BÌNH THƯỜNG	2	BÌNH THƯỜNG

Chuyển vị

Transpose options

Các trường hợp:

Biểu tượng	Giá trị	Sợi dây
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRANSPOSE	2	TRANSPOSE
ADJOINT	3	ADJOINT