'mhlo' ภาษาถิ่น

การดำเนินงาน

mhlo.abs (mhlo::AbsOp)

การทำงานของ ABS

รูปแบบประโยค:

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

ดำเนินการการดำเนินการ abs แบบแยกตามองค์ประกอบบนเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ

คำอธิบาย

operand

เทนเซอร์อันดับของจำนวนเต็มไม่มีเครื่องหมาย 2/4/8/16/32/64 บิต หรือ float 4/6/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือจำนวนเต็มมีเครื่องหมายแบบควอนไทซ์สม่ำเสมอ 2/4/8/16/32 บิต หรือจำนวนเต็มมีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต หรือจำนวนเต็มไม่มีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต หรือจำนวนเต็มไม่มีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของจำนวนเต็มไม่มีเครื่องหมาย 2/4/8/16/32/64 บิต หรือจำนวนเต็มลอยตัว 4/6/8/16/32/64 บิต หรือจำนวนเต็มมีเครื่องหมายแบบควอนไทซ์สม่ำเสมอ 2/4/8/16/32 บิต หรือจำนวนเต็มมีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต หรือจำนวนเต็มไม่มีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต หรือจำนวนเต็มไม่มีเครื่องหมายแบบควอนไทซ์สม่ำเสมอต่อแกน 2/4/8/16/32 บิต

mhlo.acos (mhlo::AcosOp)

การดำเนินงาน Acos

รูปแบบประโยค:

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

ดำเนินการ acos แบบเรียงตามองค์ประกอบบนเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

ตัวอย่าง:

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

ลักษณะ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

mhlo.acosh (mhlo::AcoshOp)

การดำเนินงานของ Acosh

รูปแบบประโยค:

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

ดำเนินการ acosh แบบเรียงตามองค์ประกอบบนเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

ตัวอย่าง:

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

ลักษณะ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

mhlo.add (mhlo::AddOp)

เพิ่มการดำเนินการ

รูปแบบประโยค:

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

ดำเนินการบวกทีละองค์ประกอบของเทนเซอร์สองตัวคือ lhs และ rhs และสร้าง result เป็นเทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน
rhs	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.add_dependency (mhlo::AddDependencyOp)

การดำเนินการเพิ่มการอ้างอิง

รูปแบบประโยค:

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

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อมูลจำเพาะ

โดยทั่วไปแล้ว การดำเนินการนี้ประกอบด้วยตัวถูกดำเนินการสองตัว ได้แก่ ตัวถูกดำเนินการข้อมูลและโทเค็น ผลลัพธ์ของการดำเนินการคือตัวถูกดำเนินการข้อมูล เมื่อใช้ร่วมกับ AfterAll การดำเนินการนี้จะช่วยให้สามารถจัดลำดับการดำเนินการที่ไม่ก่อให้เกิดผลข้างเคียง (การดำเนินการที่ไม่สร้างค่าโทเค็น) ได้

ตัวอย่าง:

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

ลักษณะนิสัย: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์ หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกน หรือโทเค็น หรือโทเค็น stablehlo
token	โทเค็นหรือโทเค็นเสถียร

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
output	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์ หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกน หรือโทเค็น หรือโทเค็น stablehlo

mhlo.after_all (mhlo::AfterAllOp)

การดำเนินการ AfterAll

รูปแบบประโยค:

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

รับประกันว่าการดำเนินการที่สร้าง inputs จะถูกดำเนินการก่อนการดำเนินการใดๆ ที่ขึ้นอยู่กับ result

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

ตัวอย่าง:

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

ลักษณะนิสัย: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
inputs	ตัวแปรของโทเค็น

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	โทเค็น

mhlo.all_gather (mhlo::AllGatherOp)

การดำเนินงาน AllGather

ภายในแต่ละกลุ่มกระบวนการในตารางกระบวนการ จะมีการต่อค่าของเทนเซอร์ตัวถูกดำเนินการจากแต่ละกระบวนการตาม all_gather_dim และสร้างเทนเซอร์ผลลัพธ์ computation จะถูกนำไปใช้แยกกันสำหรับแต่ละตัวถูกดำเนินการใน operands โดยให้ผลลัพธ์หนึ่งรายการต่อหนึ่งตัวถูกดำเนินการ

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

ตัวอย่าง:

%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>

ลักษณะ: SameOperandsAndResultElementType

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
all_gather_dim	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ
replica_groups	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต
channel_handle	::mlir::mhlo::ChannelHandleAttr	จำนวนเต็ม 64 บิตสองตัวคือ 'handle' และ 'type'
use_global_device_ids	::mlir::หน่วยแอตทริบิวต์	แอตทริบิวต์ของหน่วย

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operands	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.all_reduce (mhlo::AllReduceOp)

การดำเนินการ AllReduce

ภายในแต่ละกลุ่มกระบวนการในตารางกระบวนการ จะใช้ computation แบบลดรูปกับค่าของเทนเซอร์ตัวถูกดำเนินการจากแต่ละกระบวนการ และให้ผลลัพธ์เป็นเทนเซอร์ computation นี้จะถูกนำไปใช้แยกกันสำหรับแต่ละตัวถูกดำเนินการใน operands โดยให้ผลลัพธ์หนึ่งรายการต่อตัวถูกดำเนินการหนึ่งรายการ

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

ตัวอย่าง:

%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>

ลักษณะ: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
replica_groups	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต
channel_handle	::mlir::mhlo::ChannelHandleAttr	จำนวนเต็ม 64 บิตสองตัวคือ 'handle' และ 'type'
use_global_device_ids	::mlir::หน่วยแอตทริบิวต์	แอตทริบิวต์ของหน่วย

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operands	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.all_to_all (mhlo::AllToAllOp)

การดำเนินการ AllToAll

ภายในแต่ละกลุ่มกระบวนการในกริดกระบวนการ จะแบ่งค่าของเทนเซอร์ operand ตาม split_dimension ออกเป็นส่วนๆ กระจายส่วนที่แยกออกไประหว่างกระบวนการ ต่อส่วนที่กระจัดกระจายตาม concat_dimension และสร้างเทนเซอร์ result

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
split_dimension	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ
concat_dimension	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ
split_count	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งมีค่าเป็นบวก
replica_groups	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต
channel_handle	::mlir::mhlo::ChannelHandleAttr	จำนวนเต็ม 64 บิตสองตัวคือ 'handle' และ 'type'

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	ตัวแปรของเทนเซอร์อันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต integer หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.and (mhlo::AndOp)

และการดำเนินงาน

รูปแบบประโยค:

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

ดำเนินการ AND แบบองค์ประกอบต่อองค์ประกอบของเทนเซอร์สองตัว lhs และ rhs และสร้าง result เทนเซอร์

ดู: https://github.com/openxla/stablehlo/blob/main/docs/spec.md# และ

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของค่าบูลีนหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต
rhs	เทนเซอร์อันดับของค่าบูลีนหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.asin (mhlo::AsinOp)

การดำเนินงานอาซิน

รูปแบบประโยค:

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

ดำเนินการตามองค์ประกอบ asin บนเทนเซอร์ตัว operand การและสร้าง result เป็นเทนเซอร์

ตัวอย่าง:

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

ลักษณะ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

mhlo.async_done (mhlo::AsyncDoneOp)

การดำเนินการแบบ AsyncDone

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อมูลจำเพาะ

โดยทั่วไป การดำเนินการนี้จะบล็อกไว้จนกว่าจะสิ้นสุดการคำนวณแบบอะซิงโครนัส โดยจะส่งคืนผลลัพธ์สุดท้ายของการคำนวณแบบอะซิงโครนัส

ดูเอกสารสำหรับ AsyncStart เพื่อดูข้อมูลเพิ่มเติม

อินเทอร์เฟซ: InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
bundle	async_bundle ที่มีการรวมค่าเทนเซอร์ที่มีอันดับใดๆ ของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน หรือค่าโทเค็นหรือค่าโทเค็นแบบเสถียร

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

"ไม่มีชื่อ"

ตัวแปรของเทนเซอร์ที่มีอันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มเชิงปริมาณต่อเทนเซอร์ หรือค่าจำนวนเต็มเชิงปริมาณต่อแกน หรือโทเค็นหรือโทเค็น stablehlo หรือทูเพิลซ้อนกันที่มีการรวมกันของเทนเซอร์ที่มีอันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มเชิงปริมาณต่อเทนเซอร์ หรืออ้างอิงหน่วยความจำของ float หรือ bool 4/6/8/16/32/64 บิต หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มี 32/64 บิต องค์ประกอบ float หรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

mhlo.async_start (mhlo::AsyncStartOp)

การดำเนินการ AsyncStart

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อมูลจำเพาะ

โดยไม่เป็นทางการ การดำเนินการนี้จะเริ่มการคำนวณแบบอะซิงโครนัส

ฟังก์ชันนี้ใช้เมื่อมีฟังก์ชันที่มีทั้งการรอแบบอะซิงโครนัส (เช่น DMA) และการคำนวณแบบ on-thread ตัวอย่างเช่น ฟังก์ชันอาจประกอบด้วยการคำนวณ, DMA, การคำนวณอื่น, DMA ที่สอง และการคำนวณขั้นสุดท้าย ซึ่งจะแสดงเป็น async_start ตามด้วย async_update และ async_done โดย async_start จะทำการคำนวณ on-thread ครั้งแรก แล้วจึงเริ่ม DMA ส่วน async_update จะรอให้ DMA เสร็จสมบูรณ์หากยังไม่เสร็จ จากนั้นจึงดำเนินการคำนวณครั้งที่สองในฟังก์ชัน แล้วจึงเริ่ม DMA ครั้งที่สอง สุดท้าย async_done จะรอ DMA สุดท้ายนี้ แล้วจึงรันการคำนวณครั้งสุดท้ายที่ต้องรัน on-thread และส่งคืนผลลัพธ์ของการคำนวณขั้นสุดท้ายนั้น

operands จะถูกส่งต่อไปยังการคำนวณโดยตรง called_computation คือฟังก์ชันที่จะทำงานแบบอะซิงโครนัส execution_thread คือชื่อของเธรดที่จะทำงาน เธรดหลักเรียกว่า "main" เธรดทั้งหมดมีชื่อ

คำสั่งนี้จะคืนค่าสถานะทั้งหมดที่จำเป็นระหว่างการดำเนินการแบบอะซิงโครนัส หลังจากกำหนดค่าบัฟเฟอร์แล้ว ค่าที่ส่งคืนจะแสดงพื้นที่ที่จำเป็นสำหรับเก็บอินพุต ผลลัพธ์ และสแครชแพดใดๆ ที่จำเป็นหรือแก้ไขโดยการดำเนินการแบบอะซิงโครนัส

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
called_computation	::mlir::FlatSymbolRefAttr	แอตทริบิวต์อ้างอิงสัญลักษณ์แบบแบน
execution_thread	::mlir::StringAttr	แอตทริบิวต์ของสตริง

ตัวดำเนินการ:

ตัวดำเนินการ

คำอธิบาย

inputs

ตัวแปรของเทนเซอร์ที่มีอันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มเชิงปริมาณต่อเทนเซอร์ หรือค่าจำนวนเต็มเชิงปริมาณต่อแกน หรือโทเค็นหรือโทเค็น stablehlo หรือทูเพิลซ้อนกันที่มีการรวมกันของเทนเซอร์ที่มีอันดับ 4/6/8/16/32/64 บิต float หรือ bool หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มเชิงปริมาณต่อเทนเซอร์ หรืออ้างอิงหน่วยความจำของ float หรือ bool 4/6/8/16/32/64 บิต หรือ 2/4/8/16/32/64 บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มี 32/64 บิต องค์ประกอบ float หรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	async_bundle ที่มีการรวมค่าเทนเซอร์ที่มีอันดับใดๆ ของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน หรือค่าโทเค็นหรือค่าโทเค็นแบบเสถียร

mhlo.async_update (mhlo::AsyncUpdateOp)

การดำเนินการ AsyncUpdate

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อมูลจำเพาะ

โดยทั่วไป การดำเนินการนี้จะบล็อกการคำนวณแบบอะซิงโครนัสจนกว่าจะถึงขีดจำกัดการซิงค์ ซึ่งจะส่งคืน bundle หลังจากดำเนินการแล้ว

ดูเอกสารสำหรับ AsyncStart เพื่อดูข้อมูลเพิ่มเติม

อินเทอร์เฟซ: InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
bundle	async_bundle ที่มีการรวมค่าเทนเซอร์ที่มีอันดับใดๆ ของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน หรือค่าโทเค็นหรือค่าโทเค็นแบบเสถียร

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	async_bundle ที่มีการรวมค่าเทนเซอร์ที่มีอันดับใดๆ ของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน หรือค่าโทเค็นหรือค่าโทเค็นแบบเสถียร

mhlo.atan2 (mhlo::Atan2Op)

การดำเนินการ Atan2

รูปแบบประโยค:

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

ดำเนินการ atan2 แบบองค์ประกอบต่อองค์ประกอบบนเทนเซอร์ lhs และ rhs และสร้าง result เป็นเทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมองค์ประกอบแบบลอยตัว 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์
rhs	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมองค์ประกอบแบบลอยตัว 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมองค์ประกอบแบบลอยตัว 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

mhlo.atanh (mhlo::AtanhOp)

ปฏิบัติการอาตันห์

รูปแบบประโยค:

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

ดำเนินการตามองค์ประกอบทีละองค์ประกอบบนเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

ตัวอย่าง:

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

ลักษณะ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของ float ขนาด 4/6/8/16/32/64 บิต หรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบ float ขนาด 32/64 บิต

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

การดำเนินการ BatchNormGrad

คำนวณการไล่ระดับของอินพุตหลายรายการของ BatchNormTrainingOp ที่แพร่กระจายกลับจาก grad_output และสร้างเทนเซอร์ grad_operand grad_scale และ grad_offset

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

ตัวอย่าง:

%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>)

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
epsilon	::mlir::FloatAttr	แอตทริบิวต์ float 32 บิต
feature_index	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
mean	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
variance	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
grad_output	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
grad_operand	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต
grad_scale	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
grad_offset	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

การดำเนินการ BatchNormInference

ทำให้เทนเซอร์ตัว operand เป็นมาตรฐานในทุกมิติ ยกเว้นมิติ feature_index และสร้างเทนเซอร์ result

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
epsilon	::mlir::FloatAttr	แอตทริบิวต์ float 32 บิต
feature_index	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
offset	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
mean	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
variance	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

การดำเนินการ BatchNormTraining

คำนวณค่าเฉลี่ยและความแปรปรวนระหว่างมิติชุดและมิติเชิงพื้นที่ และทำให้เทนเซอร์ operand ดำเนินการเป็นมาตรฐานสำหรับแต่ละฟีเจอร์ในมิติ feature_index และสร้าง output เป็นเทนเซอร์ batch_mean และ batch_var

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

ตัวอย่าง:

%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>)

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
epsilon	::mlir::FloatAttr	แอตทริบิวต์ float 32 บิต
feature_index	::mlir::IntegerAttr	แอตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตซึ่งค่าไม่เป็นลบ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
offset	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
output	เทนเซอร์อันดับค่า float 4/6/8/16/32/64 บิต
batch_mean	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต
batch_var	เทนเซอร์ 1 มิติของค่า float ขนาด 4/6/8/16/32/64 บิต

mhlo.bitcast (mhlo::BitcastOp)

การดำเนินการบิตแคสต์

รูปแบบประโยค:

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

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อมูลจำเพาะ

โดยไม่เป็นทางการ การดำเนินการนี้จะเปลี่ยนรูปร่างของอินพุตในลักษณะที่การจัดเรียงทางกายภาพขององค์ประกอบไม่มีการเปลี่ยนแปลง

การดำเนินการนี้ต้องการข้อมูลเค้าโครงเพื่อให้เข้าใจถึง "การจัดเรียงองค์ประกอบทางกายภาพ" และการสนับสนุนเค้าโครงใน MHLO ยังอยู่ในระหว่างดำเนินการ

ตัวอย่าง:

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

ลักษณะนิสัย: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

การดำเนินการ BitcastConvert

รูปแบบประโยค:

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

ดำเนินการบิตแคสต์บนเทนเซอร์ operand และสร้างเทนเซอร์ result โดยที่บิตของเทนเซอร์ตัว operand ทั้งหมดจะถูกตีความใหม่โดยใช้ประเภทของเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะนิสัย: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.broadcast (mhlo::BroadcastOp)

การดำเนินการออกอากาศ

การดำเนินการนี้กำลังจะออกจาก StableHLO ดังนั้นจึงไม่ได้รวมอยู่ในข้อมูลจำเพาะ: https://github.com/openxla/stablehlo/issues/3

โดยไม่เป็นทางการ การดำเนินการนี้จะดำเนินการแบบเดียวกับ Broadcast ของ XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
broadcast_sizes	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

การดำเนินการ BroadcastInDim

ขยายมิติและ/หรืออันดับของเทนเซอร์อินพุตโดยการทำซ้ำข้อมูลในเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
broadcast_dimensions	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์มิติที่มีรูปร่างคงที่หรือขอบเขตเดียวของค่า float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.case (mhlo::CaseOp)

การดำเนินการกรณี

สร้างเอาต์พุตจากการดำเนินการ function หนึ่งอย่างแม่นยำจาก branches ขึ้นอยู่กับค่าของ index

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

ตัวอย่าง:

%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>)

ลักษณะเฉพาะ: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

อินเทอร์เฟซ: InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
index	เทนเซอร์ของค่าจำนวนเต็มไร้เครื่องหมาย 32 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	ตัวแปรของเทนเซอร์ที่มีอันดับของค่า float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าปริมาณจำนวนเต็มต่อเทนเซอร์ หรือเทนเซอร์ที่มีอันดับของค่าปริมาณจำนวนเต็มต่อแกน หรือโทเค็น

mhlo.cbrt (mhlo::CbrtOp)

ปฏิบัติการ CBRT

รูปแบบประโยค:

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

ดำเนินการรากที่สามแบบแยกตามองค์ประกอบบนเทนเซอร์ operand และสร้างเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	ความแม่นยำที่ร้องขอสำหรับการดำเนินการแบบยูนารี

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมองค์ประกอบแบบลอยตัว 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมองค์ประกอบแบบลอยตัว 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

mhlo.ceil (mhlo::CeilOp)

การดำเนินงานเพดาน

รูปแบบประโยค:

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

ดำเนินการตามองค์ประกอบของเทนเซอร์ตัว operand และสร้างเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มแบบลอยตัว 4/6/8/16/32/64 บิตหรือต่อเทนเซอร์

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มแบบลอยตัว 4/6/8/16/32/64 บิตหรือต่อเทนเซอร์

mhlo.cholesky (mhlo::CholeskyOp)

การดำเนินงานของโคลสกี

คำนวณการสลายตัวของ Cholesky ของชุดเมทริกซ์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
lower	::mlir::BoolAttr	แอตทริบิวต์บูลีน

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
a	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบแบบลอยตัว 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับ 4/6/8/16/32/64 บิตแบบลอยตัวหรือชนิดที่ซับซ้อนพร้อมค่าองค์ประกอบแบบลอยตัว 32/64 บิต

mhlo.clamp (mhlo::ClampOp)

การทำงานของแคลมป์

รูปแบบประโยค:

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

ยึดทุกองค์ประกอบของเทนเซอร์ operand การระหว่างค่าต่ำสุดและค่าสูงสุดและสร้าง result เป็นเทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
min	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน
max	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

การดำเนินงานการออกอากาศแบบรวม

ภายในแต่ละกลุ่มกระบวนการในกริดกระบวนการ ส่งค่าของเทนเซอร์ operand จากกระบวนการต้นทางไปยังกระบวนการเป้าหมาย และสร้างเทนเซอร์ result

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

ตัวอย่าง:

%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>

ลักษณะ: CompatibleOperandsAndResultType

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
replica_groups	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต
channel_handle	::mlir::mhlo::ChannelHandleAttr	จำนวนเต็ม 64 บิตสองตัวคือ 'handle' และ 'type'

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.collective_permute (mhlo::CollectivePermuteOp)

การดำเนินการรวมการสับเปลี่ยน

ภายในแต่ละกลุ่มกระบวนการในกริดกระบวนการ จะส่งค่าของเทนเซอร์ operand จากกระบวนการต้นทางไปยังกระบวนการเป้าหมาย และสร้างเทนเซอร์ result

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
source_target_pairs	::mlir::DenseIntElementsAttr	แอตทริบิวต์องค์ประกอบจำนวนเต็มแบบไม่มีเครื่องหมาย 64 บิต
channel_handle	::mlir::mhlo::ChannelHandleAttr	จำนวนเต็ม 64 บิตสองตัวคือ 'handle' และ 'type'

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

mhlo.compare (mhlo::CompareOp)

การเปรียบเทียบการดำเนินการ

รูปแบบประโยค:

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

ดำเนินการเปรียบเทียบเทนเซอร์ lhs และ rhs แบบแยกองค์ประกอบตาม comparison_direction และ compare_type และสร้าง result เป็นเทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	จะต้องดำเนินการเปรียบเทียบใด
compare_type	::mlir::mhlo::ประเภทการเปรียบเทียบAttr	ควรใช้การเปรียบเทียบประเภทใด

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน
rhs	เทนเซอร์อันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็ม 2/4/8/16/32/64 บิต หรือชนิดเชิงซ้อนที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
"ไม่มีชื่อ"	เทนเซอร์อันดับของค่าบูลีน

mhlo.complex (mhlo::ComplexOp)

การดำเนินการที่ซับซ้อน

รูปแบบประโยค:

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

ดำเนินการแปลงองค์ประกอบเป็นค่าเชิงซ้อนจากค่าจริงและค่าจินตภาพคู่หนึ่ง lhs และ rhs และสร้าง result เป็นเทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

ผลกระทบ: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับค่า float 32/64 บิต
rhs	เทนเซอร์อันดับค่า float 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของประเภทที่ซับซ้อนพร้อมค่าองค์ประกอบ float 32/64 บิต

mhlo.composite (mhlo::CompositeOp)

การดำเนินการแบบผสม

รูปแบบประโยค:

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

สรุปการดำเนินการที่ประกอบขึ้น (ประกอบด้วย) ของการดำเนินการ StableHLO อื่นๆ โดยรับ inputs และ composite_attributes และสร้าง results ความหมายของ op ถูกนำมาใช้โดยแอตทริบิวต์ decomposition composite op สามารถถูกแทนที่ด้วยการสลายตัวโดยไม่ต้องเปลี่ยนซีแมนทิกส์ของโปรแกรม ในกรณีที่การอินไลน์การแบ่งแยกไม่ได้จัดเตรียมซีแมนทิกส์ op เดียวกัน แนะนำให้ใช้ custom_call

ฟิลด์ version (ค่าเริ่มต้นคือ 0 ) ใช้เพื่อแสดงว่าซีแมนทิกส์ของคอมโพสิตเปลี่ยนแปลงเมื่อใด

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

ตัวอย่าง:

%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>

อินเทอร์เฟซ: SymbolUserOpInterface

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
name	::mlir::StringAttr	แอตทริบิวต์ของสตริง
composite_attributes	::mlir::DictionaryAttr	พจนานุกรมของค่าแอตทริบิวต์ที่มีชื่อ
decomposition	::mlir::FlatSymbolRefAttr	คุณลักษณะการอ้างอิงสัญลักษณ์แบบแบน
version	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 32 บิต

ตัวดำเนินการ:

ตัวดำเนินการ

คำอธิบาย

inputs

variadic ของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ quantized หรือจำนวนเต็มต่อแกน ค่าเชิงปริมาณหรือโทเค็นหรือ tuple ที่ซ้อนกันด้วยการรวมกันของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-bit float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็ม หรือเชิงซ้อน พิมพ์ด้วยองค์ประกอบ float 32/64 บิตหรือ ค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«ไม่มีชื่อ»

variadic ของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ quantized หรือจำนวนเต็มต่อแกน ค่าเชิงปริมาณหรือโทเค็นหรือ tuple ที่ซ้อนกันด้วยการรวมกันของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-bit float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็ม หรือเชิงซ้อน พิมพ์ด้วยองค์ประกอบ float 32/64 บิตหรือ ค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

mhlo.concatenate (mhlo::เชื่อมต่อ Op)

เชื่อมต่อการดำเนินการ

เชื่อมต่อจำนวนเทนเซอร์แปรผันใน inputs ตามมิติ dimension ตามลำดับเดียวกับอาร์กิวเมนต์ที่กำหนดและสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
dimension	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าไม่เป็นลบ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
val	variadic ของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือ bool หรือจำนวนเต็ม 2/4/8/16/32/64-บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.constant (mhlo::ConstantOp)

การดำเนินงานอย่างต่อเนื่อง

สร้าง output เทนเซอร์จาก value คงที่

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , ConstantLike

อินเทอร์เฟซ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
value	::mlir::ElementsAttr	คุณลักษณะเวกเตอร์/เทนเซอร์คงที่

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
output	เทนเซอร์ที่มีรูปทรงคงที่ของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทเชิงซ้อนที่มีองค์ประกอบลอย 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์หรือค่าจำนวนเต็มต่อแกน

mhlo.convert (mhlo::ConvertOp)

การดำเนินการแปลง

รูปแบบประโยค:

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

ทำการแปลงตามองค์ประกอบจากองค์ประกอบประเภทหนึ่งไปยังอีกประเภทหนึ่งบน operand เทนเซอร์และสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.convolution (mhlo::ConvolutionOp)

การดำเนินการคอนโวลูชั่น

รูปแบบประโยค:

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)

คำนวณผลคูณดอทระหว่างหน้าต่างของ lhs และส่วนของ rhs และสร้าง result

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
window_strides	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
padding	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
lhs_dilation	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
rhs_dilation	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
window_reversal	::mlir::DenseElementsAttr	แอ็ตทริบิวต์บูลีนเวกเตอร์/เทนเซอร์คงที่
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	โครงสร้างของข้อมูลมิติสำหรับ Conv op
feature_group_count	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าเป็นบวก
batch_group_count	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าเป็นบวก
precision_config	::mlir::ArrayAttr	คุณลักษณะการกำหนดค่าที่แม่นยำ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.copy (mhlo::CopyOp)

การดำเนินการคัดลอก

รูปแบบประโยค:

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

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อกำหนด

อย่างไม่เป็นทางการ การดำเนินการนี้เป็นสำเนาของ operand ขึ้นอยู่กับข้อมูลเมตาที่แนบมากับการดำเนินการ อาจมีพฤติกรรมแตกต่างไปจากการไม่ดำเนินการ

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
cross_program_prefetch_index	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 32 บิต

ตัวดำเนินการ:

ตัวดำเนินการ

คำอธิบาย

operand

เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบลอย 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือจำนวนเต็มต่อแกนค่าเชิงปริมาณหรือโทเค็นหรือ tuple ที่ซ้อนกันด้วยการรวมกันของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-bit float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็ม หรือเชิงซ้อน พิมพ์ด้วยองค์ประกอบ float 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

result

เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบลอย 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือจำนวนเต็มต่อแกนค่าเชิงปริมาณหรือโทเค็นหรือ tuple ที่ซ้อนกันด้วยการรวมกันของเทนเซอร์อันดับของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-bit float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็ม หรือเชิงซ้อน พิมพ์ด้วยองค์ประกอบ float 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์ ค่าเชิงปริมาณหรือเทนเซอร์อันดับของค่าเชิงปริมาณจำนวนเต็มต่อแกนหรือค่าโทเค็น

mhlo.cosh (mhlo::CoshOp)

การดำเนินงานคอส

รูปแบบประโยค:

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

ดำเนินการ cosh ที่ชาญฉลาดตามองค์ประกอบบน operand เทนเซอร์และสร้าง result เทนเซอร์

ตัวอย่าง:

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

ลักษณะ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: InferShapedTypeOpInterface , InferTypeOpInterface

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของโฟลต 4/6/8/16/32/64 บิตหรือประเภทซับซ้อนพร้อมค่าองค์ประกอบโฟลต 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของโฟลต 4/6/8/16/32/64 บิตหรือประเภทซับซ้อนพร้อมค่าองค์ประกอบโฟลต 32/64 บิต

mhlo.cosine (mhlo::CosineOp)

การดำเนินการโคไซน์

รูปแบบประโยค:

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

ดำเนินการโคไซน์ตามองค์ประกอบกับ operand เทนเซอร์และสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
result_accuracy	::mlir::mhlo::ผลลัพธ์ความแม่นยำ Attr	ความแม่นยำที่ร้องขอสำหรับการดำเนินการแบบเอกภาค

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลต 4/6/8/16/32/64 บิตหรือประเภทที่ซับซ้อนพร้อมองค์ประกอบโฟลต 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลต 4/6/8/16/32/64 บิตหรือประเภทที่ซับซ้อนพร้อมองค์ประกอบโฟลต 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์

mhlo.count_leading_zeros (mhlo::ClzOp)

การทำงานของ Clz

รูปแบบประโยค:

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

ดำเนินการนับจำนวนบิตศูนย์นำหน้าตามองค์ประกอบในเทนเซอร์ operand และสร้างเทนเซอร์ result

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

mhlo.create_token (mhlo::CreateTokenOp)

การดำเนินการ CreateToken

รูปแบบประโยค:

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

การดำเนินการนี้กำลังจะออกจาก StableHLO ดังนั้นจึงไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/3

การดำเนินการนี้ทำสิ่งเดียวกับ AfterAllOp อย่างไม่เป็นทางการโดยมีอินพุต 0 รายการ: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

ตัวอย่าง:

%output = mhlo.create_token : !mhlo.token

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
output	โทเค็น

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

การดำเนินการ CrossReplicaSum

การดำเนินการนี้กำลังจะออกจาก StableHLO ดังนั้นจึงไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/3

การดำเนินการนี้ทำสิ่งเดียวกันกับ AllReduceOp อย่างไม่เป็นทางการด้วย channel_id = 0 , use_global_device_ids = false และ computation ดำเนินการเพิ่มเติม: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
replica_groups	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.custom_call (mhlo::CustomCallOp)

การดำเนินการ CustomCall

รูปแบบประโยค:

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

สรุปการดำเนินการที่กำหนดโดยการใช้งาน call_target_name ที่รับ inputs และ called_computations และสร้าง results

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

ตัวอย่าง:

%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.

อินเทอร์เฟซ: MemoryEffectOpInterface

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
call_target_name	::mlir::StringAttr	แอตทริบิวต์ของสตริง
has_side_effect	::mlir::BoolAttr	คุณลักษณะบูล
backend_config	::mlir::แอตทริบิวต์	แอตทริบิวต์สตริงหรือพจนานุกรมของค่าแอตทริบิวต์ที่มีชื่อ
api_version	::mlir::mhlo::CustomCallApiVersionAttr	เวอร์ชัน API การโทรที่กำหนดเอง
called_computations	::mlir::ArrayAttr	แอตทริบิวต์อาร์เรย์อ้างอิงสัญลักษณ์แบน
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	ระบุกำหนดเวลาที่ต้องการสำหรับการโทรแบบกำหนดเอง
operand_layouts	::mlir::ArrayAttr	แอ็ตทริบิวต์อาร์เรย์ของโครงร่าง (เทนเซอร์ 1D ของประเภทดัชนี)
result_layouts	::mlir::ArrayAttr	แอ็ตทริบิวต์อาร์เรย์ของโครงร่าง (เทนเซอร์ 1D ของประเภทดัชนี)
output_operand_aliases	::mlir::ArrayAttr	แอตทริบิวต์นามแฝงสำหรับเอาต์พุตและตัวถูกดำเนินการของ CustomCall

ตัวดำเนินการ:

ตัวดำเนินการ

คำอธิบาย

inputs

ตัวแปรของเทนเซอร์ของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ quantized หรือจำนวนเต็มต่อแกน ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-บิต float หรือ bool หรือ จำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มต่อเทนเซอร์หรือโทเค็นหรือทูเปิลที่ซ้อนกันด้วยการรวมกันของเทนเซอร์ของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทที่ซับซ้อนด้วย 32/64-บิต องค์ประกอบลอยตัวหรือต่อเทนเซอร์ จำนวนเต็ม quantized หรือต่อแกน จำนวนเต็ม quantized ค่าหรือ memref ของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทที่ซับซ้อนด้วย 32/64-บิต องค์ประกอบ float หรือ per-tensor จำนวนเต็ม quantized ค่าหรือค่าโทเค็น

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«ไม่มีชื่อ»

ตัวแปรของเทนเซอร์ของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์ quantized หรือจำนวนเต็มต่อแกน ค่าเชิงปริมาณหรือ memref ของ 4/6/8/16/32/64-บิต float หรือ bool หรือ จำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทเชิงซ้อนที่มีองค์ประกอบ float 32/64 บิต หรือค่าจำนวนเต็มต่อเทนเซอร์หรือโทเค็นหรือทูเปิลที่ซ้อนกันด้วยการรวมกันของเทนเซอร์ของ 4/6/8/16/32/64-บิต float หรือบูล หรือจำนวนเต็ม 2/4/8/16/32/64-บิต หรือประเภทที่ซับซ้อนด้วย 32/64-บิต องค์ประกอบลอยตัวหรือต่อเทนเซอร์ จำนวนเต็ม quantized หรือต่อแกน จำนวนเต็ม quantized ค่าหรือ memref ของ 4/6/8/16/32/64-บิต float หรือ bool หรือ 2/4/8/16/32/64-บิต จำนวนเต็มหรือประเภทที่ซับซ้อนด้วย 32/64-บิต องค์ประกอบ float หรือ per-tensor จำนวนเต็ม quantized ค่าหรือค่าโทเค็น

mhlo.divide (mhlo::DivOp)

การดำเนินการ Div

รูปแบบประโยค:

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

ดำเนินการหารเงินปันผล lhs และตัวหาร rhs เทนเซอร์ตามองค์ประกอบ และสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของจำนวนเต็ม 2/4/8/16/32/64-บิต หรือ 4/6/8/16/32/64-บิต float หรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของจำนวนเต็ม 2/4/8/16/32/64-บิต หรือ 4/6/8/16/32/64-บิต float หรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของจำนวนเต็ม 2/4/8/16/32/64-บิต หรือ 4/6/8/16/32/64-บิต float หรือประเภทที่ซับซ้อนด้วยองค์ประกอบ float 32/64-บิต หรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.domain (mhlo::DomainOp)

การดำเนินการโดเมน

การดำเนินการนี้เป็นแบบส่วนตัวสำหรับคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อกำหนด

การดำเนินการเหล่านี้ใช้เพื่อจัดกลุ่มคำสั่งที่มีคุณสมบัติ DomainMetadata เดียวกันอย่างไม่เป็นทางการ ShardingMetadata เป็นกรณีการใช้งานหลักในปัจจุบันเพื่อจัดกลุ่มคำสั่งบนอุปกรณ์เดียวกัน คำแนะนำโดเมนให้ประโยชน์หลักสองประการ:

• ป้องกันการเพิ่มประสิทธิภาพคำสั่งข้ามโดเมนโดยไม่ได้ตั้งใจ
• กำหนดข้อมูลเมตาของคำแนะนำที่สร้างในโดเมนโดยอัตโนมัติ หากไม่มีคำแนะนำเกี่ยวกับโดเมน การส่งผ่านการปรับให้เหมาะสม HLO แต่ละรายการจะต้องตรวจสอบและเผยแพร่ข้อมูลเมตา ซึ่งจะพลาดได้ง่าย และยังเพิ่มความซับซ้อนให้กับคอมไพเลอร์อีกด้วย เนื่องจากคำสั่งโดเมนเชื่อมต่อสองโดเมนที่แตกต่างกัน แต่ละคำสั่งโดเมนจึงเชื่อมโยงกับ DomainMetadata สองรายการ - รายการหนึ่งอยู่ที่ฝั่งตัวถูกดำเนินการและอีกรายการหนึ่งอยู่ที่ฝั่งผู้ใช้ของโดเมน

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
kind	::mlir::mhlo::DomainKindAttr	ประเภทข้อมูลเมตาของโดเมนที่แนบกับโดเมน HLO
entry_metadata	::mlir::StringAttr	แอตทริบิวต์ของสตริง
exit_metadata	::mlir::StringAttr	แอตทริบิวต์ของสตริง

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบลอย 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าจำนวนเต็มจำนวนเต็มต่อแกนหรือโทเค็น

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบลอย 32/64 บิตหรือค่าเชิงปริมาณจำนวนเต็มต่อเทนเซอร์หรือเทนเซอร์อันดับของค่าจำนวนเต็มจำนวนเต็มต่อแกนหรือโทเค็น

mhlo.dot (mhlo::DotOp)

การดำเนินการแบบจุด

การดำเนินการนี้กำลังจะออกจาก StableHLO ดังนั้นจึงไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/3

การดำเนินการนี้ทำสิ่งเดียวกับ Dot ของ XLA อย่างไม่เป็นทางการ: https://www.tensorflow.org/xla/operation_semantics#dot

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
precision_config	::mlir::ArrayAttr	คุณลักษณะการกำหนดค่าที่แม่นยำ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dot_general (mhlo::DotGeneralOp)

การดำเนินการ DotGeneral

คำนวณดอทโปรดัคระหว่างสไลซ์ของ lhs และสไลซ์ของ rhs และสร้าง result เทนเซอร์

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	แอตทริบิวต์ที่สร้างแบบจำลองข้อมูลมิติสำหรับจุด
precision_config	::mlir::ArrayAttr	คุณลักษณะการกำหนดค่าที่แม่นยำ
algorithm	::mlir::mhlo::DotAlgorithmAttr	แอตทริบิวต์ที่สร้างโมเดลข้อจำกัดของอัลกอริทึมเพื่อใช้สำหรับการคำนวณดอท

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

การดำเนินการ DynamicBroadcastInDim

การดำเนินการนี้มีฟังก์ชันการทำงานเหมือนกับ Broadcast_in_dim op แต่รูปร่างผลลัพธ์จะถูกระบุแบบไดนามิกผ่าน output_dimensions

นอกจากนี้ยังยอมรับแอตทริบิวต์ทางเลือกเพื่อแสดงความรู้แบบคงที่เกี่ยวกับพฤติกรรมการขยายของมิติ หากไม่ได้ระบุ มิติข้อมูลทั้งหมดจะถือว่าอาจมีการขยาย ชุดของมิติที่ทราบว่ากำลังขยายและชุดของมิติที่ทราบว่าไม่ขยายจะต้องแยกจากกัน และจะต้องเป็นส่วนย่อยของมิติของตัวถูกดำเนินการ

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

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
broadcast_dimensions	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
known_expanding_dimensions	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
output_dimensions	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_conv (mhlo::DynamicConvOp)

การดำเนินการ DynamicConv

การดำเนินการนี้อยู่ระหว่างดำเนินการ ดังนั้นจึงยังไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/8

การดำเนินการนี้ทำสิ่งเดียวกันกับ ConvolutionOp อย่างไม่เป็นทางการ ยกเว้นว่ามีการระบุ padding ภายในแบบไดนามิกผ่าน d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
window_strides	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
padding	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
lhs_dilation	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
rhs_dilation	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต
window_reversal	::mlir::DenseElementsAttr	แอ็ตทริบิวต์บูลีนเวกเตอร์/เทนเซอร์คงที่
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	โครงสร้างของข้อมูลมิติสำหรับ Conv op
feature_group_count	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าเป็นบวก
batch_group_count	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าเป็นบวก
precision_config	::mlir::ArrayAttr	คุณลักษณะการกำหนดค่าที่แม่นยำ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
d_padding	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

การดำเนินการ DynamicGather

การดำเนินการนี้อยู่ระหว่างดำเนินการ ดังนั้นจึงยังไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/8

การดำเนินการนี้ทำสิ่งเดียวกันกับ GatherOp อย่างไม่เป็นทางการ ยกเว้นว่า slice_sizes จะถูกระบุแบบไดนามิก: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

ตัวอย่าง:

%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>

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	แอ็ตทริบิวต์ที่สร้างโมเดลข้อมูลมิติสำหรับการรวบรวม
indices_are_sorted	::mlir::BoolAttr	คุณลักษณะบูล

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
start_indices	เทนเซอร์อันดับของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต
slice_sizes	เทนเซอร์จำนวนเต็ม 1 มิติที่มีรูปทรงคงที่ของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

การดำเนินการ DynamicIota

การดำเนินการนี้มีฟังก์ชันการทำงานเหมือนกับ iota op แต่รูปร่างผลลัพธ์จะถูกระบุแบบไดนามิกผ่าน output_shape

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
iota_dimension	::mlir::IntegerAttr	แอ็ตทริบิวต์จำนวนเต็มไร้เครื่องหมาย 64 บิตที่มีค่าไม่เป็นลบ

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
output_shape	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_pad (mhlo::DynamicPadOp)

การทำงานของไดนามิกแพด

รูปแบบประโยค:

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

แพด operand การแบบไดนามิก โดยจำนวนการแพ็ดที่เพิ่มที่ระดับล่าง/สูง-เอนด์/ภายในจะถูกส่งผ่านเทนเซอร์อินพุต

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
padding_value	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
edge_padding_low	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต
edge_padding_high	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต
interior_padding	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

การดำเนินการปรับรูปร่างแบบไดนามิก

รูปแบบประโยค:

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

การดำเนินการนี้มีฟังก์ชันการทำงานเหมือนกับ การปรับรูปร่าง op ใหม่ แต่รูปร่างผลลัพธ์จะถูกระบุแบบไดนามิกผ่าน output_shape

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์ของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
output_shape	เทนเซอร์ 1D ของดัชนีหรือค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

การดำเนินการ DynamicSlice

แยกชิ้นส่วนออกจาก operand โดยใช้ดัชนีเริ่มต้นที่คำนวณแบบไดนามิกและสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
slice_sizes	::mlir::DenseIntElementsAttr	แอ็ตทริบิวต์องค์ประกอบจำนวนเต็มไร้เครื่องหมาย 64 บิต

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
start_indices	ตัวแปรของเทนเซอร์ 0D ของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

การดำเนินการ DynamicUpdateSlice

รูปแบบประโยค:

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

สร้าง result เทนเซอร์ซึ่งเท่ากับตัว operand เทนเซอร์ ยกเว้นว่าส่วนที่เริ่มต้นที่ start_indices จะได้รับการอัปเดตด้วยค่าใน update

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
update	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
start_indices	ตัวแปรของเทนเซอร์ 0D ของค่าจำนวนเต็ม 2/4/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.einsum (mhlo::EinsumOp)

การดำเนินงานของ Einsum

การดำเนินการนี้กำลังจะออกจาก StableHLO ดังนั้นจึงไม่รวมอยู่ในข้อกำหนด: https://github.com/openxla/stablehlo/issues/3

การดำเนินการนี้ทำสิ่งเดียวกับ einsum ของ TF อย่างไม่เป็นทางการ: https://www.tensorflow.org/api_docs/python/tf/einsum

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait

อินเทอร์เฟซ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
einsum_config	::mlir::StringAttr	แอตทริบิวต์ของสตริง

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
lhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน
rhs	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่มีชื่อ»	เทนเซอร์อันดับของโฟลตหรือบูล 4/6/8/16/32/64 บิตหรือจำนวนเต็ม 2/4/8/16/32/64 บิตหรือประเภทที่ซับซ้อนด้วยองค์ประกอบโฟลต 32/64 บิตหรือจำนวนเต็มต่อเทนเซอร์เชิงปริมาณหรือค่าเชิงปริมาณจำนวนเต็มต่อแกน

mhlo.erf (mhlo::ErfOp)

การดำเนินการเอิร์ฟ

รูปแบบประโยค:

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

ดำเนินการ erf ตามองค์ประกอบบน operand ถูกดำเนินการเทนเซอร์และสร้าง result เทนเซอร์

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

ตัวดำเนินการ:

ตัวดำเนินการ	คำอธิบาย
operand	เทนเซอร์อันดับของค่าทศนิยม 4/6/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์อันดับของค่าทศนิยม 4/6/8/16/32/64 บิต

mhlo.exponential (mhlo::ExpOp)

ปฏิบัติการประสบการณ์

รูปแบบประโยค:

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

ดำเนินการเอ็กซ์โปเนนเชียลตามองค์ประกอบบน operand เทนเซอร์และสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

อินเทอร์เฟซ: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

เอฟเฟ็กต์: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	ประเภท MLIR	คำอธิบาย
result_accuracy	::mlir::mhlo::ผลลัพธ์ความแม่นยำ Attr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

รูปแบบประโยค:

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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.

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

ตัวดำเนินการ

คำอธิบาย

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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«unnamed»

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

Interfaces: InferTypeOpInterface

Operands:

ตัวดำเนินการ	คำอธิบาย
pred	ranked tensor of bool values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
infeed_config	::mlir::StringAttr	แอตทริบิวต์ของสตริง
layout	::mlir::ArrayAttr	array attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
token	โทเค็น

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«unnamed»

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
x	ranked tensor of 4/6/8/16/32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

%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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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:

ตัวดำเนินการ	คำอธิบาย
shapes	variadic of 1D tensor of index values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

Interfaces: InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
outfeed_config	::mlir::StringAttr	แอตทริบิวต์ของสตริง

Operands:

ตัวดำเนินการ	คำอธิบาย
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	โทเค็น

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	โทเค็น

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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

%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)

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
token	โทเค็น

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«unnamed»

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

ตัวอย่าง:

%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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

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

ตัวอย่าง:

%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>

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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	unit attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

%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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

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

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

ตัวดำเนินการ	คำอธิบาย
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of 4/6/8/16/32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

%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

Interfaces: InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

%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

Interfaces: InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

%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

Interfaces: InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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	โทเค็น

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	โทเค็น

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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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.

ตัวอย่าง:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

ตัวดำเนินการ	คำอธิบาย
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

%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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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.

ตัวอย่าง:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

รูปแบบประโยค:

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

ตัวอย่าง:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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.

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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.

ตัวอย่าง:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
tag	::mlir::StringAttr	แอตทริบิวต์ของสตริง

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

ตัวอย่าง:

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

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
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:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	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

รูปแบบประโยค:

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

ตัวอย่าง:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ

คำอธิบาย

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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

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

รูปแบบประโยค:

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

ตัวอย่าง:

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

ตัวดำเนินการ	คำอธิบาย
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

ตัวอย่าง:

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

ตัวดำเนินการ

คำอธิบาย

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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«unnamed»

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

รูปแบบประโยค:

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.

Interfaces: InferTypeOpInterface

คุณสมบัติ:

คุณลักษณะ	MLIR Type	คำอธิบาย
delta	::mlir::IntegerAttr	64-bit signless integer attribute

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

รูปแบบประโยค:

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวดำเนินการ	คำอธิบาย
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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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

คุณสมบัติ

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++ type	คำอธิบาย
argTupleIndices	::llvm::ArrayRef<int64_t>	มิติ
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	มิติ
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

รูปแบบประโยค:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
รับมือ	int64_t
พิมพ์	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

รูปแบบประโยค:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

รูปแบบประโยค:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	มิติ
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	มิติ
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	มิติ

CrossProgramPrefetchAttr

Argument that is prefetched from another program

รูปแบบประโยค:

#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.

ตัวอย่างเช่น,

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++ type	คำอธิบาย
พารามิเตอร์	int64_t
ดัชนี	::llvm::ArrayRef<int64_t>	มิติ
ออฟเซ็ต	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

รูปแบบประโยค:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

รูปแบบประโยค:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

รูปแบบประโยค:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

รูปแบบประโยค:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
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++ type	คำอธิบาย
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	มิติ
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	มิติ
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	มิติ
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	มิติ

FftTypeAttr

XLA fast fourier transform type.

รูปแบบประโยค:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

รูปแบบประโยค:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
offsetDims	::llvm::ArrayRef<int64_t>	มิติ
collapsedSliceDims	::llvm::ArrayRef<int64_t>	มิติ
operandBatchingDims	::llvm::ArrayRef<int64_t>	มิติ
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	มิติ
startIndexMap	::llvm::ArrayRef<int64_t>	มิติ
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

รูปแบบประโยค:

#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++ type	คำอธิบาย
outputTupleIndices	::llvm::ArrayRef<int64_t>	มิติ
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	มิติ

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

รูปแบบประโยค:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	มิติ
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	มิติ

ResultAccuracyAttr

The requested accuracy for unary ops.

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
อาตอล	APFloat
rtol	APFloat
ulps	int64_t
โหมด	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

รูปแบบประโยค:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

รูปแบบประโยค:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

รูปแบบประโยค:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
updateWindowDims	::llvm::ArrayRef<int64_t>	มิติ
insertedWindowDims	::llvm::ArrayRef<int64_t>	มิติ
inputBatchingDims	::llvm::ArrayRef<int64_t>	มิติ
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	มิติ
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	มิติ
indexVectorDim	int64_t

TransposeAttr

Transpose options

รูปแบบประโยค:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

รูปแบบประโยค:

#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++ type	คำอธิบาย
bounds	::llvm::ArrayRef<int64_t>

ประเภท

AsyncBundleType

Opaque collection of other types

รูปแบบประโยค:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ประเภท	::llvm::ArrayRef<Type>

การแจงนับ

ComparisonDirection

Which comparison operation to perform.

กรณี:

เครื่องหมาย	ค่า	สตริง
อีคิว	0	อีคิว
ตะวันออกเฉียงเหนือ	1	ตะวันออกเฉียงเหนือ
จีอี	2	จีอี
จีที	3	จีที
เล	4	เล
ล.ต.	5	ล.ต.

ComparisonType

Which comparison type to use.

กรณี:

เครื่องหมาย	ค่า	สตริง
NOTYPE	0	NOTYPE
ลอย	1	ลอย
TOTALORDER	2	TOTALORDER
ลงชื่อ	3	ลงชื่อ
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

กรณี:

เครื่องหมาย	ค่า	สตริง
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.

กรณี:

เครื่องหมาย	ค่า	สตริง
ไม่มี	0	ไม่มี
ล่าสุด	1	ล่าสุด
เร็วที่สุด	2	เร็วที่สุด

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

กรณี:

เครื่องหมาย	ค่า	สตริง
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

กรณี:

เครื่องหมาย	ค่า	สตริง
sharding	0	sharding

FftType

XLA fast fourier transform type.

กรณี:

เครื่องหมาย	ค่า	สตริง
เอฟเอฟที	0	เอฟเอฟที
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

กรณี:

เครื่องหมาย	ค่า	สตริง
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

ความแม่นยำ

XLA precision for an operand. Has backend specific meaning.

กรณี:

เครื่องหมาย	ค่า	สตริง
ค่าเริ่มต้น	0	ค่าเริ่มต้น
สูง	1	สูง
สูงสุด	2	สูงสุด

ResultAccuracyMode

XLA result accuracy mode.

กรณี:

เครื่องหมาย	ค่า	สตริง
ค่าเริ่มต้น	0	ค่าเริ่มต้น
สูงสุด	1	สูงสุด
ความอดทน	2	ความอดทน

RngAlgorithm

XLA PRNG algorithm to be used.

กรณี:

เครื่องหมาย	ค่า	สตริง
ค่าเริ่มต้น	0	ค่าเริ่มต้น
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

กรณี:

เครื่องหมาย	ค่า	สตริง
เครื่องแบบ	1	เครื่องแบบ
ปกติ	2	ปกติ

ทรานสโพส

Transpose options

กรณี:

เครื่องหมาย	ค่า	สตริง
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
ทรานสโพส	2	ทรานสโพส
ADJOINT	3	ADJOINT