'mhlo' ภาษาถิ่น

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

mhlo.abs (mhlo::AbsOp)

การผ่าตัด ABS

ไวยากรณ์:

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

ทำการหาค่าสัมบูรณ์แบบทีละองค์ประกอบบนเทนเซอร์ 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 บิต หรือจำนวนทศนิยม 4/6/8/16/32/64 บิต หรือชนิดข้อมูลเชิงซ้อนที่มีองค์ประกอบเป็นจำนวนทศนิยม 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 หรือ complex ขนาด 4/6/8/16/32/64 บิต ที่มีค่าองค์ประกอบเป็น float ขนาด 32/64 บิต

ผลลัพธ์:

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

mhlo.acosh (mhlo::AcoshOp)

ปฏิบัติการอะโคช

ไวยากรณ์:

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 หรือ complex ขนาด 4/6/8/16/32/64 บิต ที่มีค่าองค์ประกอบเป็น float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ชนิด float หรือ complex ขนาด 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)

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

ไวยากรณ์:

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	โทเค็นหรือโทเค็น Stablehlo

ผลลัพธ์:

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

mhlo.after_all (mhlo::AfterAllOp)

หลังจากการผ่าตัดทั้งหมด

ไวยากรณ์:

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::UnitAttr	คุณลักษณะของหน่วย

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

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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่ระบุชื่อ»	variadic ของเทนเซอร์จัดอันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็มหรือชนิดเชิงซ้อนขนาด 2/4/8/16/32/64 บิต ที่มีองค์ประกอบ 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::UnitAttr	คุณลักษณะของหน่วย

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

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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่ระบุชื่อ»	variadic ของเทนเซอร์จัดอันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็มหรือชนิดเชิงซ้อนขนาด 2/4/8/16/32/64 บิต ที่มีองค์ประกอบ 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	variadic ของเทนเซอร์จัดอันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็มหรือชนิดเชิงซ้อนขนาด 2/4/8/16/32/64 บิต ที่มีองค์ประกอบ float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์ หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อแกน

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่ระบุชื่อ»	variadic ของเทนเซอร์จัดอันดับของ float หรือ bool ขนาด 4/6/8/16/32/64 บิต หรือจำนวนเต็มหรือชนิดเชิงซ้อนขนาด 2/4/8/16/32/64 บิต ที่มีองค์ประกอบ 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#and

ตัวอย่าง:

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

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

ไวยากรณ์:

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 หรือ complex ขนาด 4/6/8/16/32/64 บิต ที่มีค่าองค์ประกอบเป็น float ขนาด 32/64 บิต

ผลลัพธ์:

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

mhlo.asinh (mhlo::AsinhOp)

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

ไวยากรณ์:

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

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

ตัวอย่าง:

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

คุณสมบัติ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

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

ผลลัพธ์:

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

mhlo.async_done (mhlo::AsyncDoneOp)

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

การดำเนินการนี้เป็นเอกสิทธิ์เฉพาะของคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อกำหนดเฉพาะ

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

โปรดดูเอกสารประกอบสำหรับ AsyncStart เพื่อดูรายละเอียดเพิ่มเติม

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

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

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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«ไม่ระบุชื่อ»

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

mhlo.async_start (mhlo::AsyncStartOp)

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

การดำเนินการนี้เป็นเอกสิทธิ์เฉพาะของคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อกำหนดเฉพาะ

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

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

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

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

คุณลักษณะ:

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

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

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

คำอธิบาย

inputs

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

ผลลัพธ์:

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

mhlo.async_update (mhlo::AsyncUpdateOp)

การดำเนินการอัปเดตแบบอะซิงโครนัส

การดำเนินการนี้เป็นเอกสิทธิ์เฉพาะของคอมไพเลอร์ XLA ดังนั้นจึงยังไม่มีข้อกำหนดเฉพาะ

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

โปรดดูเอกสารประกอบสำหรับ AsyncStart เพื่อดูรายละเอียดเพิ่มเติม

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

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

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

ผลลัพธ์:

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

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	เทนเซอร์ที่มีลำดับชั้นของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีองค์ประกอบเป็น float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์
rhs	เทนเซอร์ที่มีลำดับชั้นของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีองค์ประกอบเป็น float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์

ผลลัพธ์:

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

mhlo.atanh (mhlo::AtanhOp)

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

ไวยากรณ์:

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

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

ตัวอย่าง:

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

คุณสมบัติ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

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

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ชนิด float หรือ complex ขนาด 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	เทนเซอร์ที่จัดอันดับของค่าทศลอย 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
mean	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
variance	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
grad_output	เทนเซอร์ที่จัดอันดับของค่าทศลอย 4/6/8/16/32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
grad_operand	เทนเซอร์ที่จัดอันดับของค่าทศลอย 4/6/8/16/32/64 บิต
grad_scale	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
grad_offset	เทนเซอร์ 1 มิติของค่าทศลอย 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	เทนเซอร์ที่จัดอันดับของค่าทศลอย 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
offset	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
mean	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
variance	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต

ผลลัพธ์:

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

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

การดำเนินการฝึกอบรม BatchNorm

คำนวณค่าเฉลี่ยและความแปรปรวนข้ามมิติแบทช์และมิติเชิงพื้นที่ และปรับค่าเทนเซอร์ 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	เทนเซอร์ที่จัดอันดับของค่าทศลอย 4/6/8/16/32/64 บิต
scale	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต
offset	เทนเซอร์ 1 มิติของค่าทศลอย 4/6/8/16/32/64 บิต

ผลลัพธ์:

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

mhlo.bitcast (mhlo::BitcastOp)

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

ไวยากรณ์:

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 บิต

ผลลัพธ์:

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

mhlo.cbrt (mhlo::CbrtOp)

ปฏิบัติการซีบีอาร์ที

ไวยากรณ์:

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	เทนเซอร์ที่มีลำดับชั้นของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีองค์ประกอบเป็น float ขนาด 32/64 บิต หรือค่าจำนวนเต็มแบบควอนไทซ์ต่อเทนเซอร์

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	เทนเซอร์ที่มีลำดับชั้นของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีองค์ประกอบเป็น float ขนาด 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

คำนวณการแยกตัวประกอบ 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	เทนเซอร์จัดอันดับของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีค่าองค์ประกอบเป็น float ขนาด 32/64 บิต

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
«ไม่ระบุชื่อ»	เทนเซอร์จัดอันดับของชนิดข้อมูล float หรือ complex ขนาด 4/6/8/16/32/64 บิต โดยมีค่าองค์ประกอบเป็น float ขนาด 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{}

Operands:

ตัวถูกดำเนินการ	คำอธิบาย
lhs	ranked tensor of 32/64-bit float values
rhs	ranked tensor of 32/64-bit float values

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
result	ranked tensor of complex type with 32/64-bit float elements values

mhlo.composite (mhlo::CompositeOp)

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

ไวยากรณ์:

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

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

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

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

ตัวอย่าง:

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

Interfaces: SymbolUserOpInterface

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
name	::mlir::StringAttr	string attribute
composite_attributes	::mlir::DictionaryAttr	dictionary of named attribute values
decomposition	::mlir::FlatSymbolRefAttr	flat symbol reference attribute
version	::mlir::IntegerAttr	32-bit signless integer 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 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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

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

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

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

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

ผลลัพธ์:

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

Constant operation

Produces an output tensor from a constant value .

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
value	::mlir::ElementsAttr	constant vector/tensor attribute

ผลลัพธ์:

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

mhlo.convert (mhlo::ConvertOp)

Convert operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
lhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
rhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_reversal	::mlir::DenseElementsAttr	constant boolean vector/tensor attribute
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Structure of dimension information for conv op
feature_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
batch_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
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

ผลลัพธ์:

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

Copy operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

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

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

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

mhlo.cosh (mhlo::CoshOp)

Cosh operation

ไวยากรณ์:

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

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

ตัวอย่าง:

%result = mhlo.cosh %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.cosine (mhlo::CosineOp)

Cosine operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

%result = mhlo.cosine %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.count_leading_zeros (mhlo::ClzOp)

Clz operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

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.create_token (mhlo::CreateTokenOp)

CreateToken operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ผลลัพธ์:

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

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

CrossReplicaSum operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
replica_groups	::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.custom_call (mhlo::CustomCallOp)

CustomCall operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

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

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

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

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

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

Interfaces: MemoryEffectOpInterface

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
call_target_name	::mlir::StringAttr	string attribute
has_side_effect	::mlir::BoolAttr	bool attribute
backend_config	::mlir::Attribute	string attribute or dictionary of named attribute values
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Custom call API version
called_computations	::mlir::ArrayAttr	flat symbol ref array attribute
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Specifies the desired schedule for the custom-call.
operand_layouts	::mlir::ArrayAttr	Array of layout (1D tensor of index type) attributes
result_layouts	::mlir::ArrayAttr	Array of layout (1D tensor of index type) attributes
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of CustomCall

Operands:

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

คำอธิบาย

inputs

variadic of 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 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 token or nested tuple with any combination of 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 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 token values

ผลลัพธ์:

ผลลัพธ์

คำอธิบาย

«unnamed»

variadic of 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 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 token or nested tuple with any combination of 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 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 token values

mhlo.divide (mhlo::DivOp)

Div operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

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.domain (mhlo::DomainOp)

Domain operation

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

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

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
kind	::mlir::mhlo::DomainKindAttr	Kind of domain metatdata attached to an HLO domain.
entry_metadata	::mlir::StringAttr	string attribute
exit_metadata	::mlir::StringAttr	string 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 values or ranked tensor of per-axis integer quantized values or token

ผลลัพธ์:

ผลลัพธ์	คำอธิบาย
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 or ranked tensor of per-axis integer quantized values or token

mhlo.dot (mhlo::DotOp)

Dot operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

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

ผลลัพธ์:

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

DotGeneral operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute
algorithm	::mlir::mhlo::DotAlgorithmAttr	Attribute that models the algorithm constraints to use for computing dot.

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

ผลลัพธ์:

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

DynamicBroadcastInDim operation

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
broadcast_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
known_expanding_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
known_nonexpanding_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
output_dimensions	1D tensor of index or 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.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
lhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
rhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_reversal	::mlir::DenseElementsAttr	constant boolean vector/tensor attribute
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Structure of dimension information for conv op
feature_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
batch_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
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
d_padding	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.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
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
slice_sizes	statically shaped 1-dimensional integer 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.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

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

Operands:

ตัวถูกดำเนินการ	คำอธิบาย
output_shape	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.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

ไวยากรณ์:

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

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ตัวถูกดำเนินการ	คำอธิบาย
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
edge_padding_low	1D tensor of index or 2/4/8/16/32/64-bit integer values
edge_padding_high	1D tensor of index or 2/4/8/16/32/64-bit integer values
interior_padding	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.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ตัวถูกดำเนินการ	คำอธิบาย
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
output_shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

ผลลัพธ์:

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

DynamicSlice operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
slice_sizes	::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
start_indices	variadic of 0D tensor of 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.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

ตัวถูกดำเนินการ	คำอธิบาย
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
update	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	variadic of 0D tensor of 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.einsum (mhlo::EinsumOp)

Einsum operation

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

คุณลักษณะ:

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

ผลลัพธ์:

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

Erf operation

ไวยากรณ์:

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

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

ตัวอย่าง:

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

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.exponential (mhlo::ExpOp)

Exp operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

%result = mhlo.exponential %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.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)

การดำเนินงานบนพื้น

ไวยากรณ์:

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	string attribute
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	string 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.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.scan (mhlo::ScanOp)

Scan operation

Applies a reduction function body to inputs and inits along the dimension and produces results (comprising outputs and carries ).

If is_reverse is true, the scan is performed in reverse order. is_associative indicates whether the reduction function is associative.

See: https://www.tensorflow.org/xla/operation_semantics#scan

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

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

คุณลักษณะ:

คุณลักษณะ	MLIR Type	คำอธิบาย
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
is_reverse	::mlir::BoolAttr	bool attribute
is_associative	::mlir::mhlo::AssociativityAttr	Associativity of the scan operation.

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

ผลลัพธ์:

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

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

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

AssociativityAttr

Associativity of the scan operation.

ไวยากรณ์:

#mhlo.associativity<
  ::mlir::mhlo::Associativity   # value
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ค่า	::mlir::mhlo::Associativity	an enum of type Associativity

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
อัลป์ส	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	คำอธิบาย
ขอบเขต	::llvm::ArrayRef<int64_t>

ประเภท

AsyncBundleType

Opaque collection of other types

ไวยากรณ์:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

พารามิเตอร์:

พารามิเตอร์	C++ type	คำอธิบาย
ประเภท	::llvm::ArrayRef<Type>

เอนัม

ความสัมพันธ์

Associativity of the scan operation.

กรณีศึกษา:

เครื่องหมาย	ค่า	สตริง
อาจจะ	0	อาจจะ
จริง	1	จริง
เท็จ	2	เท็จ

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
SIGNED	3	SIGNED
ไม่มีลายเซ็น	4	ไม่มีลายเซ็น

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.

กรณีศึกษา:

เครื่องหมาย	ค่า	สตริง
การแบ่งส่วน	0	การแบ่งส่วน

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.

กรณีศึกษา:

เครื่องหมาย	ค่า	สตริง
UNIFORM	1	UNIFORM
ปกติ	2	ปกติ

สลับตำแหน่ง

Transpose options

กรณีศึกษา:

เครื่องหมาย	ค่า	สตริง
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
ทรานสโพส	2	ทรานสโพส
ADJOINT	3	ADJOINT