'mhlo' ภาษาถิ่น

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

mhlo.abs (mhlo::AbsOp)

การผ่าตัดหน้าท้อง

ไวยากรณ์:

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

ดำเนินการ ABS แบบใช้องค์ประกอบกับ operand เทนเซอร์และสร้าง result เทนเซอร์

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

ตัวอย่าง:

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

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

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

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

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.add_dependency (mhlo::AddDependencyOp)

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

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

ลักษณะ: ลักษณะ AlwaysSpeculatableImplTrait

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

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

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

ผลลัพธ์:

mhlo.after_all (mhlo::AfterAllOp)

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

ไวยากรณ์:

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

ตรวจสอบให้แน่ใจว่าการดำเนินการที่สร้าง inputs นั้นได้รับการดำเนินการก่อนการดำเนินการใดๆ ที่ขึ้นอยู่กับ result

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

ตัวอย่าง:

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

ลักษณะ: ลักษณะ AlwaysSpeculatableImplTrait

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

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

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.all_reduce (mhlo::AllReduceOp)

ลดการดำเนินการทั้งหมด

ภายในกลุ่มกระบวนการแต่ละกลุ่มในตารางกระบวนการ ใช้ 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

คุณสมบัติ:

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.async_done (mhlo::AsyncDoneOp)

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

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

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

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

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

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

ผลลัพธ์:

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 เป็นชื่อของเธรดที่มันจะถูกเรียกใช้ เธรดหลักเรียกว่า "หลัก" กระทู้ทั้งหมดมีชื่อ

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.async_update (mhlo::AsyncUpdateOp)

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

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

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

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

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

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

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

คำนวณการไล่ระดับสีของอินพุตหลายตัวของ BatchNormTrainingOp backpropagating จาก 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{}

คุณสมบัติ:

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

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

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

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , InferTensorType

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

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

คุณสมบัติ:

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.bitcast_convert (mhlo :: bitcastconvertop)

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

ไวยากรณ์:

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

ดำเนินการ bitcast บน 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{}

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

ผลลัพธ์:

mhlo.broadcast (mhlo :: broadcastop)

การออกอากาศ

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

อย่างไม่เป็นทางการการดำเนินการนี้ทำสิ่งเดียวกันกับการออกอากาศของ 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{}

คุณสมบัติ:

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.cbrt (mhlo :: cbrtop)

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

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

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

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

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

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

ผลลัพธ์:

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

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.collective_broadcast (mhlo :: collectivebroadcastop)

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

ภายในแต่ละกลุ่มกระบวนการในกริดกระบวนการส่งค่าของ 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

คุณสมบัติ:

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

ผลลัพธ์:

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.compare (mhlo :: compareop)

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

ไวยากรณ์:

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

ทำการเปรียบเทียบองค์ประกอบที่ชาญฉลาดของ lhs และ rhs Tensors ตาม 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{}

คุณสมบัติ:

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

ผลลัพธ์:

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

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

ผลลัพธ์:

mhlo.composite (MHLO :: CompositeOp)

การทำงานแบบคอมโพสิต

ไวยากรณ์:

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

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

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

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

ตัวอย่าง:

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

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.concatenate (mhlo :: concatenateop)

การดำเนินการต่อ

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

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

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

คุณสมบัติ:

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

ผลลัพธ์:

mhlo.constant (MHLO :: Constantop)

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

ผลิตเทนเซอร์ output จาก value คงที่

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

ตัวอย่าง:

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

ลักษณะ: AlwaysSpeculatableImplTrait , ConstantLike

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

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

คุณสมบัติ:

ผลลัพธ์:

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:

ผลลัพธ์:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

ไวยากรณ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

mhlo.copy (mhlo::CopyOp)

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

ไวยากรณ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

Operands:

ผลลัพธ์:

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:

ผลลัพธ์:

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

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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:

ผลลัพธ์:

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:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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.

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ผลลัพธ์:

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

Operands:

ผลลัพธ์:

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

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

mhlo.floor (mhlo::FloorOp)

Floor operation

ไวยากรณ์:

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

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

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

ตัวอย่าง:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ผลลัพธ์:

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.

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

Operands:

ผลลัพธ์:

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:

ผลลัพธ์:

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:

ผลลัพธ์:

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)

คุณสมบัติ:

Operands:

ผลลัพธ์:

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

คุณสมบัติ:

ผลลัพธ์:

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:

ผลลัพธ์:

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

Operands:

ผลลัพธ์: