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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 2/4/8/16/32/64 סיביות חסר סימנים או מספר שלם 4/6/8/16/32/64 סיביות צף או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או 2/4/8/16/32 סיביות אחיד עם סימן שלם או 2/4/2/8/16 סימן שלם אחיד 2/4/8/16 2/4/8/16/32 סיביות אחיד מכומד ללא סימן או 2/4/8/16/32 סיביות אחיד מכומד לכל ציר ערכי מספר שלם ללא סימן

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור מדורג של 2/4/8/16/32/64 סיביות חסר סימנים או 4/6/8/16/32/64 סיביות ציפה או 2/4/8/16/32 סיביות אחידה כמותית סימנים שלם או 2/4/8/16/32 סיביות אחידה מכומדת שלם/8 סיביות/8 סיביות אחידה לכל ציר/8 סיביות. ערכי מספר שלם ללא סימן מכומת או 2/4/8/16/32 סיביות אחיד בקומות לכל ציר ללא סימן

mhlo.acos (mhlo::AcosOp)

מבצע אקוס

תַחבִּיר:

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

מבצע פעולת acos מבחינת אלמנט על טנסור operand ומייצר טנזור result .

דוּגמָה:

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

תכונות: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

mhlo.acosh (mhlo::AcoshOp)

מבצע עכוש

תַחבִּיר:

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

מבצע פעולת אקוש מבחינה אלמנטית על טנסור operand ומייצר טנזור result .

דוּגמָה:

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

תכונות: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

mhlo.add (mhlo::AddOp)

הוסף פעולה

תַחבִּיר:

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

מבצע הוספת אלמנט של שני טנסורים lhs ו- rhs ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר
rhs	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.add_dependency (mhlo::AddDependencyOp)

פעולת AddDependency

תַחבִּיר:

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

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

באופן לא רשמי, הפעולה הזו שני אופרנדים: אופרנד נתונים ואסימון. הפלט של הפעולה הוא אופרנד הנתונים. בשימוש עם AfterAll פעולה זו מאפשרת הזמנת פעולות שאינן משפיעות לוואי (אלו שאינן מייצרות ערכי אסימון).

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float 32/64-bit או ערכים מכומדים של מספר שלם לכל טנסור או טנסור מדורג של ערכים מכוימים לכל ציר שלם token token or sthlo
token	token או stablehlo token

תוצאות:

תוֹצָאָה	תֵאוּר
output	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float 32/64-bit או ערכים מכומדים של מספר שלם לכל טנסור או טנסור מדורג של ערכים מכוימים לכל ציר שלם token token or sthlo

mhlo.after_all (mhlo::AfterAllOp)

מבצע אחרי הכל

תַחבִּיר:

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

מבטיח שהפעולות המייצרות את inputs מבוצעות לפני כל פעולות התלויות result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

אופרנדים:

אופרנד	תֵאוּר
inputs	וריאדית של אסימון

תוצאות:

תוֹצָאָה	תֵאוּר
result	אֲסִימוֹן

mhlo.all_gather (mhlo::AllGatherOp)

פעולת AllGather

בתוך כל קבוצת תהליך ברשת התהליך, משרשרת את הערכים של טנסור האופרנד מכל תהליך לאורך all_gather_dim ומייצר טנזור תוצאה. computation מיושם בנפרד עבור כל אופרנד operands , ומפיק תוצאה אחת לכל אופרנד.

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

דוּגמָה:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

תכונות: SameOperandsAndResultElementType

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
all_gather_dim	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי
replica_groups	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות
channel_handle	::mlir::mhlo::ChannelHandleAttr	שני מספרים שלמים של 64 סיביות 'ידית' ו'סוג'
use_global_device_ids	::mlir::UnitAttr	תכונת יחידה

אופרנדים:

אופרנד	תֵאוּר
operands	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

mhlo.all_reduce (mhlo::AllReduceOp)

AllReduce פעולה

בתוך כל קבוצת תהליך ברשת התהליך, מיישמת computation פונקציית הפחתה על הערכים של טנסור אופרנד מכל תהליך ומפיקה טנזור תוצאה. computation מיושם בנפרד עבור כל אופרנד operands , ומפיק תוצאה אחת לכל אופרנד.

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

דוּגמָה:

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

תכונות: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
replica_groups	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות
channel_handle	::mlir::mhlo::ChannelHandleAttr	שני מספרים שלמים של 64 סיביות 'ידית' ו'סוג'
use_global_device_ids	::mlir::UnitAttr	תכונת יחידה

אופרנדים:

אופרנד	תֵאוּר
operands	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

mhlo.all_to_all (mhlo::AllToAllOp)

פעולת AllToAll

בתוך כל קבוצת תהליכים ברשת התהליך, מפצל את ערכי הטנזור operand לאורך split_dimension לחלקים, מפזר את החלקים המפוצלים בין התהליכים, משרשר את החלקים המפוזרים לאורך concat_dimension ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
split_dimension	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי
concat_dimension	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי
split_count	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שערכה חיובי
replica_groups	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות
channel_handle	::mlir::mhlo::ChannelHandleAttr	שני מספרים שלמים של 64 סיביות 'ידית' ו'סוג'

אופרנדים:

אופרנד	תֵאוּר
operand	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

mhlo.and (mhlo::AndOp)

וגם תפעול

תַחבִּיר:

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

מבצע AND מבחינה אלמנטית של שני טנסורים lhs ו- rhs ומייצר טנזור result

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
lhs	טנסור מדורג של bool או 2/4/8/16/32/64 סיביות ערכים שלמים
rhs	טנסור מדורג של bool או 2/4/8/16/32/64 סיביות ערכים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.asin (mhlo::AsinOp)

מבצע אסין

תַחבִּיר:

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

מבצע פעולת Asin מבחינה אלמנטית על טנסור operand ומייצר טנזור result .

דוּגמָה:

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

תכונות: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

mhlo.async_done (mhlo::AsyncDoneOp)

פעולת AsyncDone

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

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

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

ממשקים: InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
bundle	async_bundle עם כל שילוב של טנסור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם 32/64-bit float elements או לכל-tensor מספר שלם quantized או לכל ציר shlo token ערך quantized

תוצאות:

תוֹצָאָה

תֵאוּר

"ללא שם"

וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או מספר שלם לפי טנסור מכומתי או לכל ציר שלם מכומת ערכים או אסימון סטוק או שילוב של אסימון או אסימון קבוע או שילוב כל שהוא. של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או memref של 4/6/8/16/32/64-bit bool/64-bit/6/4 float/64-bit או float. או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים של מספר שלם לכל טנסור או טנזור מדורג של ערכים כמותיים או ערכים סמליים לכל ציר

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.

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
called_computation	::mlir::FlatSymbolRefAttr	תכונת הפניה לסמל שטוח
execution_thread	::mlir::StringAttr	תכונת מחרוזת

אופרנדים:

אופרנד

תֵאוּר

inputs

וריאדי של טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או מספר שלם לפי טנסור מכומתי או לכל ציר שלם מכומת ערכים או אסימון סטוק או שילוב של אסימון או אסימון קבוע או שילוב כל שהוא. של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או memref של 4/6/8/16/32/64-bit bool/64-bit/6/4 float/64-bit או float. או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים של מספר שלם לכל טנסור או טנזור מדורג של ערכים כמותיים או ערכים סמליים לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	async_bundle עם כל שילוב של טנסור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם 32/64-bit float elements או לכל-tensor מספר שלם quantized או לכל ציר shlo token ערך quantized

mhlo.async_update (mhlo::AsyncUpdateOp)

פעולת AsyncUpdate

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

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

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

ממשקים: InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
bundle	async_bundle עם כל שילוב של טנסור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם 32/64-bit float elements או לכל-tensor מספר שלם quantized או לכל ציר shlo token ערך quantized

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	async_bundle עם כל שילוב של טנסור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם 32/64-bit float elements או לכל-tensor מספר שלם quantized או לכל ציר shlo token ערך quantized

mhlo.atan2 (mhlo::Atan2Op)

מבצע Atan2

תַחבִּיר:

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

מבצע פעולת atan2 מבחינת אלמנט על טנזור lhs ו- rhs ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים לכל טנסור
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים לכל טנסור

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים לכל טנסור

mhlo.atanh (mhlo::AtanhOp)

מבצע Atanh

תַחבִּיר:

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

מבצע את פעולת atanh מבחינה אלמנטית על טנסור operand ומייצר טנזור result .

דוּגמָה:

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

תכונות: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

פעולת BatchNormGrad

מחשב גרדיאנטים של מספר כניסות של BatchNormTrainingOp המתפשטות בחזרה מ- grad_output , ומייצר טנסורים grad_operand , grad_scale ו- grad_offset .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
epsilon	::mlir::FloatAttr	תכונת ציפה של 32 סיביות
feature_index	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות
scale	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
mean	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
variance	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
grad_output	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
grad_operand	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות
grad_scale	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
grad_offset	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

פעולת BatchNormInference

מנרמל את טנסור operand על פני כל הממדים מלבד הממד feature_index ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
epsilon	::mlir::FloatAttr	תכונת ציפה של 32 סיביות
feature_index	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות
scale	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
offset	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
mean	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
variance	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

פעולת BatchNormTraining

מחשב את הממוצע והשונות על פני מימדים אצווה ומרחביים ומנרמל את טנסור operand , עבור כל תכונה בממד feature_index ומייצר טנסור output , batch_mean ו- batch_var .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
epsilon	::mlir::FloatAttr	תכונת ציפה של 32 סיביות
feature_index	::mlir::IntegerAttr	תכונת מספר שלם ללא סימן של 64 סיביות שהערך שלה אינו שלילי

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות
scale	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
offset	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
output	טנסור מדורג של ערכי ציפה של 4/6/8/16/32/64 סיביות
batch_mean	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות
batch_var	טנסור 1D של ערכי ציפה של 4/6/8/16/32/64 סיביות

mhlo.bitcast (mhlo::BitcastOp)

פעולת Bitcast

תַחבִּיר:

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

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

באופן לא רשמי, פעולה זו משנה את צורת הקלט באופן שבו הסידור הפיזי של האלמנטים אינו משתנה.

פעולה זו זקוקה למידע על פריסה כדי להבין "סידור פיזי של אלמנטים", ותמיכה בפריסה ב-MHLO נמצאת כעת בתהליך.

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
broadcast_sizes	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

פעולת BroadcastInDim

מרחיב את הממדים ו/או הדירוג של טנזור קלט על ידי שכפול הנתונים בטנזור operand ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
broadcast_dimensions	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור ממד בעל צורה סטטית או מוגבלת יחידה של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כומתיים לכל טנסור או מספר שלם לכל ציר

mhlo.case (mhlo::CaseOp)

תפעול מקרה

מפיקה את הפלט מביצוע function אחת בדיוק branches בהתאם לערך של index .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

דוּגמָה:

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

תכונות: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ממשקים: InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
index	טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	וריאדי של טנזור מדורג של 4/6/8/16/32/64 סיביות ציפה או bool או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים מכומתיים לכל טנסור או טנסור מדורג של ערך שלם לכל ציר קוואנטי

mhlo.cbrt (mhlo::CbrtOp)

פעולת Cbrt

תַחבִּיר:

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

מבצע פעולת שורש מעוקב מבחינת אלמנט על טנסור operand ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	הדיוק המבוקש עבור פעולות לא נכונות.

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים לכל טנסור

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם רכיבי ציפה של 32/64 סיביות או ערכים כמותיים לכל טנסור

mhlo.ceil (mhlo::CeilOp)

תפעול תקרה

תַחבִּיר:

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

מבצע תקרה אלמנט של טנזור operand ומפיק טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או ערכים כמותיים לכל טנסור

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנסור מדורג של 4/6/8/16/32/64 סיביות ציפה או ערכים כמותיים לכל טנסור

mhlo.cholesky (mhlo::CholeskyOp)

ניתוח כושל

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

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
lower	::mlir::BoolAttr	תכונת bool

אופרנדים:

אופרנד	תֵאוּר
a	טנסור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנסור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי רכיבי ציפה של 32/64 סיביות

mhlo.clamp (mhlo::ClampOp)

פעולת מהדק

תַחבִּיר:

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

מהדק כל אלמנט של טנסור operand בין ערך מינימלי למקסימום ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

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

אופרנדים:

אופרנד	תֵאוּר
min	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר
max	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

פעולת Collective Broadcast

בתוך כל קבוצת תהליך ברשת התהליך, שלח את הערך של טנסור operand מתהליך המקור לתהליכי היעד והפק טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

דוּגמָה:

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

תכונות: CompatibleOperandsAndResultType

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
replica_groups	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות
channel_handle	::mlir::mhlo::ChannelHandleAttr	שני מספרים שלמים של 64 סיביות 'ידית' ו'סוג'

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.collective_permute (mhlo::CollectivePermuteOp)

פעולת CollectivePermute

בתוך כל קבוצת תהליך ברשת התהליך, שולח את הערך של טנסור operand מתהליך המקור לתהליך היעד ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
source_target_pairs	::mlir::DenseIntElementsAttr	תכונת רכיבי מספר שלם ללא סימן של 64 סיביות
channel_handle	::mlir::mhlo::ChannelHandleAttr	שני מספרים שלמים של 64 סיביות 'ידית' ו'סוג'

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

mhlo.compare (mhlo::CompareOp)

השווה פעולה

תַחבִּיר:

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

מבצע השוואה מבחינה אלמנטית של טנסור lhs ו- rhs לפי comparison_direction ו- compare_type , ומפיק טנסור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	איזו פעולת השוואה לבצע.
compare_type	::mlir::mhlo::ComparisonTypeAttr	באיזה סוג השוואה להשתמש.

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר
rhs	טנזור מדורג של 4/6/8/16/32/64-bit float או bool או 2/4/8/16/32/64-bit מספר שלם או סוג מורכב עם רכיבי float של 32/64-bit או ערכים כומתיים לכל טנסור או לכל ציר

תוצאות:

תוֹצָאָה	תֵאוּר
"ללא שם"	טנסור מדורג של ערכי bool

mhlo.complex (mhlo::ComplexOp)

פעולה מורכבת

תַחבִּיר:

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

מבצע המרה אלמנטרית לערך מורכב מצמד ערכים אמיתיים ודמיוניים, lhs ו- rhs , ומייצר טנזור result .

ראה: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

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

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של ערכי ציפה של 32/64 סיביות
rhs	טנזור מדורג של ערכי ציפה של 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג מסוג מורכב עם ערכי אלמנטים צפים של 32/64 סיביות

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
name	:: mlir :: stringattr	תכונה מחרוזת
composite_attributes	:: mlir :: Dictionaryattr	מילון ערכי תכונה ששמו
decomposition	:: mlir :: flatsymbolrefattr	תכונה התייחסות לסמל שטוח
version	:: mlir :: integerattr	תכונה שלם שלם ללא אותות 32 סיביות

אופרנדים:

אופרנד

תֵאוּר

inputs

משתנה של טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או בול או 2/4/8/16/32/64 סיביות או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם שלם או טנסור לשילוב שלם או לשילוב שלם של משך שלם או טנסור מקורב או טנסור משולב של משלמה של דרגה או TEDSOR או TEDSOR עם כל שילוב של RAGEDED של RAGEDER של INTER או TEDSOR TERKED או TEDKEN TERKED או TEDKEN TERKED או TEDKEKED TERKED או TEKEN DEKEN או TEKEN DEKEN TERKED TENEDS. 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של מספר שלם או תמ"ג או 2/6/64/6/6/16/32/64-bit או Bood או 2/6/64/64/64/16/32/64-bit Float או Bood או 2/16/622222222222/32-622 סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים שלם שלם או טנזור מדורגים של ערכים כמותיים או ערכי אסימון שלם לכל ציר או ערכי אסימון

תוצאות:

תוֹצָאָה

תֵאוּר

«ללא שם»

משתנה של טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או בול או 2/4/8/16/32/64 סיביות או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם שלם או טנסור לשילוב שלם או לשילוב שלם של משך שלם או טנסור מקורב או טנסור משולב של משלמה של דרגה או TEDSOR או TEDSOR עם כל שילוב של RAGEDED של RAGEDER של INTER או TEDSOR TERKED או TEDKEN TERKED או TEDKEN TERKED או TEDKEKED TERKED או TEKEN DEKEN או TEKEN DEKEN TERKED TENEDS. 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של מספר שלם או תמ"ג או 2/6/64/6/6/16/32/64-bit או Bood או 2/6/64/64/64/16/32/64-bit Float או Bood או 2/16/622222222222/32-622 סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים שלם שלם או טנזור מדורגים של ערכים כמותיים או ערכי אסימון שלם לכל ציר או ערכי אסימון

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
dimension	:: mlir :: integerattr	תכונה שלם שלם של מספר שלם 64 סיביות שערכתה אינה שלילית

אופרנדים:

אופרנד	תֵאוּר
val	משתנה של טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות מספר שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.constant (mhlo :: constantop)

פעולה מתמדת

מייצר output פלט value קבוע.

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait את הדיוקן, ConstantLike

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
value	:: mlir :: ElementSattr	תכונה וקטורית/טנזור קבועה

תוצאות:

תוֹצָאָה	תֵאוּר
output	טנזור בצורת סטטי של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.convert (mhlo :: convertop)

המרת פעולה

תַחבִּיר:

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

מבצע המרה מבחינה אלמנטית מסוג אלמנט אחד למשנהו על טנזור operand ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait Elementwise SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.convolution (mhlo :: convolutionOp)

פעולת התפתחות

תַחבִּיר:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

מחשב מוצרי DOT בין חלונות lhs לפרוסות rhs ומייצר result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
window_strides	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
padding	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
lhs_dilation	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
rhs_dilation	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
window_reversal	:: mlir :: denseelementsattr	תכונה וקטורית בוליאנית/טנסור קבועה
dimension_numbers	:: mlir :: mhlo :: convdimensionnumbersattr	מבנה מידע על מימד עבור conv op
feature_group_count	:: mlir :: integerattr	תכונה שלמה שלמה חסרת סיביות של 64 סיביות שערכתה חיובית
batch_group_count	:: mlir :: integerattr	תכונה שלמה שלמה חסרת סיביות של 64 סיביות שערכתה חיובית
precision_config	:: mlir :: arrayattr	תכונה של תצורת דיוק

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.copy (mhlo :: copyop)

פעולת העתק

תַחבִּיר:

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

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

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

דוּגמָה:

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

תכונות Elementwise AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
cross_program_prefetch_index	:: mlir :: integerattr	תכונה שלם שלם ללא אותות 32 סיביות

אופרנדים:

אופרנד

תֵאוּר

operand

טנסור מדורג של 4/6/8/16/32/64 סיביות צף או Bool או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם שלם או שלם שלם שלם של שלב או אסימון או קיננו עם כל שילוב של טנח מדורג של דרגה שלם מדגם או אסימון או טופל מקומן עם שילוב של דרגת מדגם מדגם מדגם. 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של מספר שלם או תמ"ג או 2/6/64/6/6/16/32/64-bit או Bood או 2/6/64/64/64/16/32/64-bit Float או Bood או 2/16/622222222222/32-622 סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים שלם שלם או טנזור מדורגים של ערכים כמותיים או ערכי אסימון שלם לכל ציר או ערכי אסימון

תוצאות:

תוֹצָאָה

תֵאוּר

result

טנסור מדורג של 4/6/8/16/32/64 סיביות צף או Bool או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם שלם או שלם שלם שלם של שלב או אסימון או קיננו עם כל שילוב של טנח מדורג של דרגה שלם מדגם או אסימון או טופל מקומן עם שילוב של דרגת מדגם מדגם מדגם. 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של מספר שלם או תמ"ג או 2/6/64/6/6/16/32/64-bit או Bood או 2/6/64/64/64/16/32/64-bit Float או Bood או 2/16/622222222222/32-622 סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים שלם שלם או טנזור מדורגים של ערכים כמותיים או ערכי אסימון שלם לכל ציר או ערכי אסימון

mhlo.cosh (mhlo :: coshop)

פעולת COSH

תַחבִּיר:

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

מבצע פעולת COSH מבחינה אלמנטית ב- operand Tensor ומייצר טנזור result .

דוּגמָה:

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

תכונות SameOperandsAndResultShape CompatibleOperandsAndResultType Elementwise

ממשקים: InferShapedTypeOpInterface , InferTypeOpInterface

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי אלמנטים צף 32/64 סיביות

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם ערכי אלמנטים צף 32/64 סיביות

mhlo.cosine (mhlo :: cosineop)

פעולה קוסינוסית

תַחבִּיר:

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

מבצע פעולת cosine מבחינה אלמנטית ב- operand Tensor ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType , Elementwise SameOperandsAndResultShape

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
result_accuracy	:: mlir :: mhlo :: actureccuracyattr	הדיוק המבוקש עבור Unary Ops.

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם אלמנטים צפים של 32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או סוג מורכב עם אלמנטים צפים של 32/64 סיב

mhlo.count_leading_zeros (mhlo :: clzop)

פעולת CLZ

תַחבִּיר:

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

מבצע ספירת אלמנט מבחינה אלמנטית של מספר חתיכות האפס המובילות במתחם operand ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType , Elementwise SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 2/4/8/16/32/64 סיביות ערכים שלם

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 2/4/8/16/32/64 סיביות ערכים שלם

mhlo.create_token (mhlo :: createTokenop)

מבצע CreateToken

תַחבִּיר:

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

פעולה זו בדרך החוצה מ- StableHlo, כך שהיא אינה כלולה במפרט: https://github.com/openxla/stablehlo/issues/3

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו Afterellop עם 0 כניסות: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

דוּגמָה:

%output = mhlo.create_token : !mhlo.token

תכונות: AlwaysSpeculatableImplTrait

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

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

תוצאות:

תוֹצָאָה	תֵאוּר
output	אֲסִימוֹן

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

פעולת CrossReplicasum

פעולה זו בדרך החוצה מ- StableHlo, כך שהיא אינה כלולה במפרט: https://github.com/openxla/stablehlo/issues/3

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו allroduceop עם channel_id = 0 , use_global_device_ids = false computation יישום תוספת: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduceuce

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
replica_groups	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.custom_call (mhlo :: customcallop)

פעולת CustomCall

תַחבִּיר:

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

מכסה פעולה מוגדרת על ידי יישום call_target_name שלוקח inputs called_computations ומניב results .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

דוּגמָה:

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

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

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

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

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

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

ממשקים: MemoryEffectOpInterface

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
call_target_name	:: mlir :: stringattr	תכונה מחרוזת
has_side_effect	:: mlir :: boolattr	תכונה Bool
backend_config	:: mlir :: תכונה	תכונה מחרוזת או מילון של ערכי תכונה ששמו
api_version	:: mlir :: mhlo :: CustomCallapiversionattr	גרסת API לשיחה בהתאמה אישית
called_computations	:: mlir :: arrayattr	תכונה של מערך סמל שטוח
custom_call_schedule	:: mlir :: mhlo :: customcallscheduleattr	מציין את לוח הזמנים הרצוי עבור השיחה המותאמת אישית.
operand_layouts	:: mlir :: arrayattr	מערך הפריסה (טנזור 1D מסוג אינדקס) תכונות
result_layouts	:: mlir :: arrayattr	מערך הפריסה (טנזור 1D מסוג אינדקס) תכונות
output_operand_aliases	:: mlir :: arrayattr	תכונה של Aliasing עבור תפוקות ואופרות של CustomCall

אופרנדים:

אופרנד

תֵאוּר

inputs

משתנה של טנזור של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם או שלם שלם או 62/64/64/64/64/64/64/64/64/64/64-bit או 624/6 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או לטיפל שלם שלם או טופל אסימון או מקונן עם כל שילוב של טנסור של 4/6/8/16/32/64 סיביות או בול או 2/4/4/16/32/64 סיביות עם סוג 32/64 סיביות עם סוג 32/64-bib-32/64-bib או 64-bib-32/64-bit 32/64-bib או 64-bib או 264-64-64-64-644-644, מורכב, אלמנטים צפים או מספר שלם של מספר כמותי או לכל ציר שלם ערכים כמותיים או memRef של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה

תֵאוּר

«ללא שם»

משתנה של טנזור של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או שלם שלם או שלם שלם או 62/64/64/64/64/64/64/64/64/64/64-bit או 624/6 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או לטיפל שלם שלם או טופל אסימון או מקונן עם כל שילוב של טנסור של 4/6/8/16/32/64 סיביות או בול או 2/4/4/16/32/64 סיביות עם סוג 32/64 סיביות עם סוג 32/64-bib-32/64-bib או 64-bib-32/64-bit 32/64-bib או 64-bib או 264-64-64-64-644-644, מורכב, אלמנטים צפים או מספר שלם של מספר כמותי או לכל ציר שלם ערכים כמותיים או memRef של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.divide (mhlo :: divop)

פעולת DIV

תַחבִּיר:

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

מבצע את חלוקת האלמנטים של דיבידנד lhs ו- Tensors rhs מחלקים ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType , Elementwise SameOperandsAndResultShape

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

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

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של מספר שלם של מספר 2/4/8/16/32/64 סיביות או 4/6/8/16/32/64 סיב
rhs	טנזור מדורג של מספר שלם של מספר 2/4/8/16/32/64 סיביות או 4/6/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של מספר שלם של מספר 2/4/8/16/32/64 סיביות או 4/6/8/16/32/64 סיב

mhlo.domain (mhlo :: domainop)

פעולת דומיין

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

באופן לא פורמלי, פעולות אלה משמשות לקבוצת הוראות עם אותו נכס DomainMetadata. ShardingMetadata הוא מקרה השימוש העיקרי כיום כדי לקבץ הוראות באותו מכשיר. הוראות תחום מספקות שני יתרונות עיקריים:

• למנוע מיטוב של הוראות מיטוב שלא בכוונה על תחומים.
• הקצה אוטומטית את המטא נתונים של ההוראות שנוצרו בתחום. ללא הוראות תחום, כל מעבר אופטימיזציה של HLO יצטרך לבדוק ולהפיץ את המטא נתונים, שיהיה קל להחמיץ וגם מוסיף מורכבות למהדר. מכיוון שהוראות הדומיין מחברות בין שני תחומים שונים, כל הוראות תחום קשורות לשני DOMAINMETADATA - אחד בצד האופרנד ואחד בצד המשתמש של הדומיין.

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
kind	:: mlir :: mhlo :: domainkindattr	סוג של תחום metatdata המחובר לתחום HLO.
entry_metadata	:: mlir :: stringattr	תכונה מחרוזת
exit_metadata	:: mlir :: stringattr	תכונה מחרוזת

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או Bool או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של שלם שלם או טנסור מדורגים של מספר שלם של שלל ציר או אריזור או אריזור או אריקים או אריקים או אריקים או אריקים או אריקים או אריקים או אריקים או Deke Deke או Deke Deke או Deke Deke או Tenked Akkיר או Tenked Ackerice Couther ערכים שלם של ציר.

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או Bool או 2/4/8/16/32/64 סיביות שלם או סוג מורכב עם אלמנטים צפים של 32/64 סיביות או ערכים כמותיים של שלם שלם או טנסור מדורגים של מספר שלם של שלל ציר או אריזור או אריזור או אריקים או אריקים או אריקים או אריקים או אריקים או אריקים או אריקים או Deke Deke או Deke Deke או Deke Deke או Tenked Akkיר או Tenked Ackerice Couther ערכים שלם של ציר.

mhlo.dot (mhlo :: dotop)

פעולת נקודה

פעולה זו בדרך החוצה מ- StableHlo, כך שהיא אינה כלולה במפרט: https://github.com/openxla/stablehlo/issues/3

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו הנקודה של XLA: https://www.tensorflow.org/xla/operation_semantics#dot

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
precision_config	:: mlir :: arrayattr	תכונה של תצורת דיוק

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dot_general (mhlo :: dotgeneralop)

מבצע דו -דקנרלי

מחשב מוצרי DOT בין פרוסות lhs לפרוסות rhs ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
dot_dimension_numbers	:: mlir :: mhlo :: dotdimensionnumbersattr	מייחס שמדגים את מידע הממד עבור DOT.
precision_config	:: mlir :: arrayattr	תכונה של תצורת דיוק
algorithm	:: mlir :: mhlo :: dotalgorithmattr	מייחס שמדגם את מגבלות האלגוריתמים שישמשו למחשוב נקודה.

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_broadcast_in_dim (mhlo :: dynamicbroadcastindimop)

פעולת DynamicBroadcastIndim

פעולה זו זהה באופן פונקציונלי ל- Broadcast_in_dim OP, אך צורת התוצאה מוגדרת באופן דינמי באמצעות output_dimensions .

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

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
broadcast_dimensions	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
known_expanding_dimensions	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
known_nonexpanding_dimensions	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
output_dimensions	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_conv (mhlo :: dynamicconvop)

פעולת DynamicConv

פעולה זו היא עבודה שמתבצעת, כך שהיא עדיין לא כלולה במפרט: https://github.com/openxla/stablehlo/issues/8

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו convolutionop פרט לכך padding מוגדר באופן דינמי באמצעות d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convultion

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
window_strides	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
padding	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
lhs_dilation	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
rhs_dilation	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות
window_reversal	:: mlir :: denseelementsattr	תכונה וקטורית בוליאנית/טנסור קבועה
dimension_numbers	:: mlir :: mhlo :: convdimensionnumbersattr	מבנה מידע על מימד עבור conv op
feature_group_count	:: mlir :: integerattr	תכונה שלמה שלמה חסרת סיביות של 64 סיביות שערכתה חיובית
batch_group_count	:: mlir :: integerattr	תכונה שלמה שלמה חסרת סיביות של 64 סיביות שערכתה חיובית
precision_config	:: mlir :: arrayattr	תכונה של תצורת דיוק

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
d_padding	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_gather (mhlo :: dynamicgatherop)

פעולת Dynamicgather

פעולה זו היא עבודה שמתבצעת, כך שהיא עדיין לא כלולה במפרט: https://github.com/openxla/stablehlo/issues/8

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו איסוף פרט לכך ש- slice_sizes מוגדרים באופן דינמי: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
dimension_numbers	:: mlir :: mhlo :: asdlicdimensionNumberSattr	מייחס שמדגמן את מידע הממד לאיסוף
indices_are_sorted	:: mlir :: boolattr	תכונה Bool

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
start_indices	טנזור מדורג של 2/4/8/16/32/64 סיביות ערכים שלם
slice_sizes	טנזור שלם שלם של מספר דו-ממדי מעוצב סטטי של 2/4/8/16/32/64 סיביות ערכים שלמים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_iota (mhlo :: dynamiciotaop)

פעולת Dynamiciota

פעולה זו זהה באופן פונקציונלי ל- IOTA OP, אך צורת התוצאה מוגדרת באופן דינמי באמצעות output_shape .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
iota_dimension	:: mlir :: integerattr	תכונה שלם שלם של מספר שלם 64 סיביות שערכתה אינה שלילית

אופרנדים:

אופרנד	תֵאוּר
output_shape	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_pad (mhlo :: dynamicpadop)

פעולת DynamicPad

תַחבִּיר:

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

באופן דינמי רפידות את operand , עם כמות הריפוד שנוספה בקצה נמוך/מקצה/פנים מועבר דרך טנזורי קלט.

תכונות: AlwaysSpeculatableImplTrait

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
padding_value	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
edge_padding_low	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים
edge_padding_high	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים
interior_padding	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_reshape (mhlo :: dynamicreshapeop)

פעולת DynamicReshape

תַחבִּיר:

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

פעולה זו זהה באופן פונקציונלי לעיצוב מחדש של OP, אך צורת התוצאה מוגדרת באופן דינמי באמצעות output_shape .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
output_shape	טנזור 1D של אינדקס או 2/4/8/16/32/64 סיביות ערכים שלמים

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_slice (mhlo :: dynamicsliceop)

פעולת Dynamicslice

מחלץ פרוסה operand באמצעות מדדי התחלה מחושבים באופן דינמי ומייצר טנזור result .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
slice_sizes	:: mlir :: densintelementsattr	תכונה של תכונה של מספר שלם שלם 64 סיביות

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
start_indices	variadic של טנזור 0D של 2/4/8/16/32/64 סיביות ערכי מספר שלם

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.dynamic_update_slice (mhlo :: dynamicupdatesliceop)

פעולת DynamicupDatesLice

תַחבִּיר:

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

מייצר טנזור result השווה לטנזור operand פרט לכך שהפרוסת המתחילה ב- start_indices מתעדכנת עם הערכים update .

ראו: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType

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

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

אופרנדים:

אופרנד	תֵאוּר
operand	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
update	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
start_indices	variadic של טנזור 0D של 2/4/8/16/32/64 סיביות ערכי מספר שלם

תוצאות:

תוֹצָאָה	תֵאוּר
result	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.einsum (mhlo :: einsumop)

פעולת EINSUM

פעולה זו בדרך החוצה מ- StableHlo, כך שהיא אינה כלולה במפרט: https://github.com/openxla/stablehlo/issues/3

באופן לא פורמלי, פעולה זו עושה את אותו הדבר כמו ה- Einsum של TF: https://www.tensorflow.org/api_docs/python/tf/einsum

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait

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

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

תכונות:

תְכוּנָה	סוג MLIR	תֵאוּר
einsum_config	:: mlir :: stringattr	תכונה מחרוזת

אופרנדים:

אופרנד	תֵאוּר
lhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב
rhs	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

תוצאות:

תוֹצָאָה	תֵאוּר
«ללא שם»	טנזור מדורג של 4/6/8/16/32/64 סיביות צף או בול או 2/4/8/16/32/64 סיב

mhlo.erf (mhlo :: erfop)

פעולת ERF

תַחבִּיר:

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

מבצע פעולת ERF מבחינה אלמנטית ב- operand Tensor ומייצר טנזור result .

דוּגמָה:

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

תכונות: AlwaysSpeculatableImplTrait CompatibleOperandsAndResultType , Elementwise SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.exponential (mhlo::ExpOp)

Exp operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

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

דוּגמָה:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.floor (mhlo::FloorOp)

Floor operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

mhlo.fusion (mhlo::FusionOp)

Fusion operation

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

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

תוצאות:

תוֹצָאָה

תֵאוּר

results

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

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

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

דוּגמָה:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

תַחבִּיר:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)

Extracts element at index position of the operand tuple and produces a result .

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

דוּגמָה:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operand

תֵאוּר

operand

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

תוצאות:

תוֹצָאָה

תֵאוּר

«unnamed»

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

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

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

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

Operand	תֵאוּר
pred	ranked tensor of bool values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.imag (mhlo::ImagOp)

Imag operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

דוּגמָה:

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

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Operand	תֵאוּר
token	אֲסִימוֹן

תוצאות:

תוֹצָאָה

תֵאוּר

«unnamed»

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

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

תוצאות:

תוֹצָאָה	תֵאוּר
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

תַחבִּיר:

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

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
x	ranked tensor of 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

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

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

דוּגמָה:

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

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

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

תַחבִּיר:

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

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

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

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

Here is an example with two input shapes:

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

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
shapes	variadic of 1D tensor of index values

תוצאות:

תוֹצָאָה	תֵאוּר
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

תוצאות:

תוֹצָאָה	תֵאוּר
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

דוּגמָה:

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

Interfaces: InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	אֲסִימוֹן

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	אֲסִימוֹן

mhlo.pad (mhlo::PadOp)

Pad operation

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

תַחבִּיר:

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

Produces partition_id of the current process.

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

דוּגמָה:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

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

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

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

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

תַחבִּיר:

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

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

Informally, this operation does the same thing as SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

דוּגמָה:

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

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
token	אֲסִימוֹן

תוצאות:

תוֹצָאָה

תֵאוּר

«unnamed»

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

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

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

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

דוּגמָה:

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

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

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

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

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

דוּגמָה:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x4xf32>) -> tensor<2x2xf32>

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

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

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

דוּגמָה:

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

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

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

תַחבִּיר:

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

Produces replica_id of the current process.

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

דוּגמָה:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

תַחבִּיר:

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

Performs reshape of operand tensor to a result tensor.

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

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

Example:

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

Syntax:

```

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

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

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

Effects: `MemoryEffects::Effect{}`

#### Operands:

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



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

_Reverse operation_

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

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

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

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

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

דוּגמָה:

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

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Operand	תֵאוּר
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

Operand	תֵאוּר
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

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

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

דוּגמָה:

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

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

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

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

דוּגמָה:

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

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

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

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

דוּגמָה:

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

Interfaces: InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	אֲסִימוֹן

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	אֲסִימוֹן

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize operation

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

תַחבִּיר:

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

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

דוּגמָה:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Operand	תֵאוּר
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

תוצאות:

תוֹצָאָה	תֵאוּר
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

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

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

דוּגמָה:

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

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Operand	תֵאוּר
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

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

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

תַחבִּיר:

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

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

Informally, this operation returns Tan(operand) element-wise.

דוּגמָה:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

תַחבִּיר:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

דוּגמָה:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect operation

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

Informally, this operation does the same thing as PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

דוּגמָה:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

תַחבִּיר:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

דוּגמָה:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
tag	::mlir::StringAttr	string attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

דוּגמָה:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

דוּגמָה:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

Operand	תֵאוּר
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

תַחבִּיר:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

דוּגמָה:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand

תֵאוּר

val

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

תוצאות:

תוֹצָאָה

תֵאוּר

result

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

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

תַחבִּיר:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

דוּגמָה:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

תַחבִּיר:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

דוּגמָה:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

דוּגמָה:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

Operand

תֵאוּר

operand

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

תוצאות:

תוֹצָאָה

תֵאוּר

«unnamed»

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

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

תַחבִּיר:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

Attributes:

תְכוּנָה	MLIR Type	תֵאוּר
delta	::mlir::IntegerAttr	64-bit signless integer attribute

תוצאות:

תוֹצָאָה	תֵאוּר
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

תַחבִּיר:

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

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

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

דוּגמָה:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	תֵאוּר
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

תוצאות:

תוֹצָאָה	תֵאוּר
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

תכונות

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
argTupleIndices	::llvm::ArrayRef<int64_t>	מֵמַד
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	מֵמַד
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

תַחבִּיר:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
יָדִית	int64_t
סוּג	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

תַחבִּיר:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

תַחבִּיר:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	מֵמַד

CrossProgramPrefetchAttr

Argument that is prefetched from another program

תַחבִּיר:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

לְדוּגמָה,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
פָּרָמֶטֶר	int64_t
indices	::llvm::ArrayRef<int64_t>	מֵמַד
לְקַזֵז	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

תַחבִּיר:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

תַחבִּיר:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

תַחבִּיר:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

תַחבִּיר:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	מֵמַד

FftTypeAttr

XLA fast fourier transform type.

תַחבִּיר:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

תַחבִּיר:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
offsetDims	::llvm::ArrayRef<int64_t>	מֵמַד
collapsedSliceDims	::llvm::ArrayRef<int64_t>	מֵמַד
operandBatchingDims	::llvm::ArrayRef<int64_t>	מֵמַד
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	מֵמַד
startIndexMap	::llvm::ArrayRef<int64_t>	מֵמַד
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

תַחבִּיר:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
outputTupleIndices	::llvm::ArrayRef<int64_t>	מֵמַד
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	מֵמַד

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

תַחבִּיר:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	מֵמַד
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	מֵמַד

ResultAccuracyAttr

The requested accuracy for unary ops.

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
atol	APFloat
rtol	APFloat
ulps	int64_t
מצב	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

תַחבִּיר:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

תַחבִּיר:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

תַחבִּיר:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
updateWindowDims	::llvm::ArrayRef<int64_t>	מֵמַד
insertedWindowDims	::llvm::ArrayRef<int64_t>	מֵמַד
inputBatchingDims	::llvm::ArrayRef<int64_t>	מֵמַד
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	מֵמַד
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	מֵמַד
indexVectorDim	int64_t

TransposeAttr

Transpose options

תַחבִּיר:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
עֵרֶך	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

תַחבִּיר:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
גבולות	::llvm::ArrayRef<int64_t>

סוגים

AsyncBundleType

Opaque collection of other types

תַחבִּיר:

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

פרמטרים:

פָּרָמֶטֶר	C++ type	תֵאוּר
סוגים	::llvm::ArrayRef<Type>

Enums

ComparisonDirection

Which comparison operation to perform.

Cases:

סֵמֶל	עֵרֶך	חוּט
EQ	0	EQ
NE	1	NE
GE	2	GE
GT	3	GT
LE	4	LE
LT	5	LT

ComparisonType

Which comparison type to use.

Cases:

סֵמֶל	עֵרֶך	חוּט
NOTYPE	0	NOTYPE
לָצוּף	1	לָצוּף
TOTALORDER	2	TOTALORDER
חָתוּם	3	חָתוּם
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Cases:

סֵמֶל	עֵרֶך	חוּט
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Cases:

סֵמֶל	עֵרֶך	חוּט
אַף לֹא אֶחָד	0	אַף לֹא אֶחָד
האחרון	1	האחרון
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Cases:

סֵמֶל	עֵרֶך	חוּט
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Cases:

סֵמֶל	עֵרֶך	חוּט
ריסוק	0	ריסוק

FftType

XLA fast fourier transform type.

Cases:

סֵמֶל	עֵרֶך	חוּט
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Cases:

סֵמֶל	עֵרֶך	חוּט
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

דִיוּק

XLA precision for an operand. Has backend specific meaning.

Cases:

סֵמֶל	עֵרֶך	חוּט
בְּרִירַת מֶחדָל	0	בְּרִירַת מֶחדָל
גָבוֹהַ	1	גָבוֹהַ
הֲכִי גָבוֹהַ	2	הֲכִי גָבוֹהַ

ResultAccuracyMode

XLA result accuracy mode.

Cases:

סֵמֶל	עֵרֶך	חוּט
בְּרִירַת מֶחדָל	0	בְּרִירַת מֶחדָל
הֲכִי גָבוֹהַ	1	הֲכִי גָבוֹהַ
סוֹבלָנוּת	2	סוֹבלָנוּת

RngAlgorithm

XLA PRNG algorithm to be used.

Cases:

סֵמֶל	עֵרֶך	חוּט
בְּרִירַת מֶחדָל	0	בְּרִירַת מֶחדָל
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Cases:

סֵמֶל	עֵרֶך	חוּט
אָחִיד	1	אָחִיד
נוֹרמָלִי	2	נוֹרמָלִי

לְשַׁרבֵּב

Transpose options

Cases:

סֵמֶל	עֵרֶך	חוּט
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
לְשַׁרבֵּב	2	לְשַׁרבֵּב
ADJOINT	3	ADJOINT