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

פעולת 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{}

אופרנדים:

תוצאות:

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

אופרנדים:

תוצאות:

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)

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

תכונות:

אופרנדים:

תוצאות:

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 מהדר, ולכן אין לה עדיין מפרט.

באופן לא רשמי, פעולה זו מתחילה חישוב אסינכרוני.

זה משמש כאשר יש פונקציות המכילות גם המתנה אסינכרונית (כגון DMAs) וגם חישוב על-פתיל. לדוגמה, פונקציה עשויה להיות מורכבת מחישוב, DMA, חישוב אחר, DMA שני וחישוב סופי. זה יוצג כ-async_start ואחריו ו-async_update ו-async_done. ה-async_start יבצע את החישוב הראשון על השרשור ולאחר מכן יתחיל את ה-DMA. ה-async_update ימתין להשלמת ה-DMA אם הוא עדיין לא נעשה, ואז יבצע את החישוב השני בפונקציה, ויתחיל את ה-DMA השני. לבסוף, ה-async_done ימתין ב-DMA האחרון הזה, ולאחר מכן יריץ את החישוב האחרון שצריך להפעיל ב-thread ויחזיר את התוצאה של החישוב הסופי הזה.

operands מועברים לחישוב ישירות called_computation היא הפונקציה שתופעל באופן אסינכרוני execution_thread הוא שם השרשור בו הוא יופעל. החוט הראשי נקרא "ראשי". לכל האשכולות יש שמות.

זה מחזיר את כל המצב הדרוש בין פעולות אסינכרון. לאחר הקצאת מאגר, ערכי ההחזרה מייצגים את השטח הדרוש כדי להחזיק את הקלט, התוצאות וכל משטחי הגירוד הדרושים או נערכו על ידי ה-async op.

תכונות:

אופרנדים:

תוצאות:

mhlo.async_update (mhlo::AsyncUpdateOp)

פעולת AsyncUpdate

פעולה זו פרטית ל-XLA מהדר, ולכן אין לה עדיין מפרט.

באופן לא רשמי, פעולה זו חוסמת חישוב אסינכרוני עד למחסום סנכרון. זה מחזיר bundle לאחר הפעלתו.

עיין בתיעוד עבור AsyncStart למידע נוסף.

Interfaces: 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 המתפשטות בחזרה מ- 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)

מבצע פעולת טיסה ב- operand Tensor ומייצר טנזור result בו מתפרשים חתיכות של Tensor operand כולו באמצעות סוג Tensor 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 .

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

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait Elementwise , CompatibleOperandsAndResultType 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 Elementwise , CompatibleOperandsAndResultType SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

אפקטים: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

mhlo.cholesky (mhlo :: choleskyop)

מבצע צ'ולסקי

מחשב את הפירוק של צ'ולסקי של חבורה של מטריצות.

ראו: 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 speculatableimpltrait, HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

אפקטים: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

mhlo.collective_broadcast (mhlo :: collectivebroadcastop)

פעולת קולקטיביות משודרת

בתוך כל קבוצת תהליכים ברשת התהליך, שלח את הערך של Tendor 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 :: oldivepermuteop)

פעולה קולקטיבית

בתוך כל קבוצת תהליכים ברשת התהליך, שולח את הערך של Tensor 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 בהתאם 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 SpeculatableImpltrait, 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)

עוטף פעולה המורכבת (מורכבת) של פעולות אחרות של StavelHlo, נטילת inputs composite_attributes ומייצרת results . הסמנטיקה של ה- OP מיושמת על ידי תכונת decomposition . ניתן להחליף את ה- OP composite בפירוק שלה מבלי לשנות סמנטיקה של התוכנית. במקרים שבהם הפירוק הפירוק אינו מספק את אותה סמנטיקה של 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

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תוצאות:

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

Attributes:

Operands:

תוצאות:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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.

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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)

Attributes:

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

Attributes:

תוצאות:

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:

תוצאות: