ניב 'chlo'

Client HLO Ops

הניב הזה מכיל פעולות שדומות מאוד לאזור של ממשק ה-API של XlaBuilder C++, שבו יש לפעולות האלה סמנטיקה שחורגת ממה שקיים בניבים ברמה נמוכה יותר (כמו stablehlo). בעצם, בכל פעם שספריית הלקוח משתמשת בסוכר תחבירי או בהרכבה של כמה פעולות לקריאה ל-API, הניב הזה מנסה ליצור מודל של הקריאה ל-API ולספק דפוסי המרה כדי להמיר אותה באופן מלא לניבים ברמה נמוכה יותר.

תפעול

‫chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

אופרטור AsinAcosKernel

תחביר:

operation ::= `chlo._asin_acos_kernel` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך AsinAcosKernel(operand) לכל רכיב.

If
  w = _asin_acos_kernel(z)
  w' = _asin_acos_kernel(I * z)
Then
  asin(z) = complex(atan2(z.real, w.real), sign(z.imag) * w.imag)
  acos(z) = complex(atan2(w.real, z.real), -sign(z.imag) * w.imag)
  asinh(z) = complex(sign(z.real) * w'.imag, atan2(z.imag, w'.real))
  acosh(z) = complex(w.imag, sign(z.imag) * atan2(w.real, z.real))

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

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.acos (chlo::AcosOp)

אופרטור Acos

תחביר:

operation ::= `chlo.acos` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Acos(operand) לכל רכיב.

\[ \acos(x) = 2 * \atan(\sqrt(1 - x^2) / (1 + x)) if x != -1 = pi if x == -1 \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.acosh (chlo::AcoshOp)

פעולת Acosh

תחביר:

operation ::= `chlo.acosh` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Acosh(operand) לכל רכיב.

\[ \acosh(x) = log(x + sqrt(x^2 - 1)) if x >= -1 \acosh(x) = nan if x < -1 \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.asin (chlo::AsinOp)

אופרטור ASIN

תחביר:

operation ::= `chlo.asin` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Asin(operand) לכל רכיב.

\[ \asin(x) = 2 * atan(x / (1 + sqrt(1 - x^2))) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.asinh (chlo::AsinhOp)

פעולת Asinh

תחביר:

operation ::= `chlo.asinh` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Asinh(operand) לכל רכיב.

\[ \asinh(x) = log(x + sqrt(x^2 + 1)) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.atan (chlo::AtanOp)

אופרטור Atan

תחביר:

operation ::= `chlo.atan` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Atan(operand) לכל רכיב.

\[ \atan(x) = \atan2(x, 1) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.atanh (chlo::AtanhOp)

אופרטור Atanh

תחביר:

operation ::= `chlo.atanh` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Atanh(operand) לכל רכיב.

\[ \atanh(x) = 0.5 * log((1 + x) / (1 - x)) if abs(x) <= 1 = nan otherwise \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.bessel_i1e (chlo::BesselI1eOp)

פונקציית בסל מסדר 1

תחביר:

operation ::= `chlo.bessel_i1e` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך bessel_i1e(operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.broadcast_add (chlo::BroadcastAddOp)

אופרטור חיבור (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_add` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs + rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_and (chlo::BroadcastAndOp)

אופרטור לוגי מסוג AND (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_and` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך logical_and(lhs, rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

‫chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

אופרטור Atan2 (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_atan2` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך atan2(lhs/rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

אופרטור השוואה (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_compare` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה משווה בין lhs לבין rhs ברמת הרכיב בהתאם לcomparison_direction ולcompare_type. אם לא מציינים ערך, compare_type הוא FLOAT לסוגי רכיבי float, ‏ SIGNED לסוגי רכיבים עם סימן ו-UNSIGNED לסוגי רכיבים ללא סימן.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CHLO_Broadcasting, ‏ HLO_BroadcastingElementwise, ‏ InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

אופרטור מורכב (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_complex` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

מבצעת המרה של זוג ערכים ממשיים ומדומים לערך מרוכב, לפי רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CHLO_Broadcasting, ‏ HLO_BroadcastingElementwise, ‏ InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_divide (chlo::BroadcastDivOp)

אופרטור חילוק (עם אפשרות שידור)

תחביר:

operation ::= `chlo.broadcast_divide` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs / rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

אופרטור מקסימלי (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_maximum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך max(lhs, rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

מפעיל מינימלי (עם אפשרות שידור)

תחביר:

operation ::= `chlo.broadcast_minimum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך min(lhs, rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

אופרטור כפל (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_multiply` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs * rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

אופרטור Std::nextafter (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_next_after` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

מחזירה את הערך הבא שניתן לייצוג של lhs בכיוון של rhs, לפי רכיבים. היא יכולה גם להחזיר מספר תת-נורמלי.

מקבילה לפונקציה std::nextafter ב-C++.

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

‫chlo.broadcast_or (chlo::BroadcastOrOp)

אופרטור לוגי or (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_or` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך logical_or(lhs, rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

פונקציית פוליגמה (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_polygamma` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך Polygamma(operand, operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_power (chlo::BroadcastPowOp)

אופרטור עם אפשרות שידור

תחביר:

operation ::= `chlo.broadcast_power` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs ^ rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

‫chlo.broadcast_remainder (chlo::BroadcastRemOp)

אופרטור השארית (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_remainder` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs % rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_select (chlo::BroadcastSelectOp)

בחירת אופרטור (עם שידור בסגנון numpy אופציונלי)

תחביר:

operation ::= `chlo.broadcast_select` $pred `,` $on_true `,` $on_false attr-dict `:`
              `(` type($pred) `,` type($on_true) `,` type($on_false) `)` `->` type(results)

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

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#select

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CHLO_Broadcasting, ‏ HLO_BroadcastingElementwise, ‏ InferTensorType

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

אופרטור הזזה שמאלה (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_shift_left` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs << rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

אופרטור הזזה ימינה (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_shift_right_arithmetic` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs >> rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

הזזה ימינה של אופרטור לוגי (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_shift_right_logical` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs >> rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

אופרטור חיסור (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_subtract` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך lhs - rhs לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_xor (chlo::BroadcastXorOp)

אופרטור לוגי xor (עם שידור אופציונלי)

תחביר:

operation ::= `chlo.broadcast_xor` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך logical_xor(lhs, rhs) לכל רכיב.

מידע נוסף זמין בכתובת https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

פונקציית זטא של הורביץ

תחביר:

operation ::= `chlo.broadcast_zeta` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

הפונקציה מחזירה את הערך Zeta(operand, operand) לכל רכיב.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.conj (chlo::ConjOp)

אופרטור של צירוף

תחביר:

operation ::= `chlo.conj` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Conj(operand) לכל רכיב.

\[ \conj(x) = (\real(x), \neg(\imag(x))) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.constant (chlo::ConstantOp)

אופרטור קבוע

תחביר:

operation ::= `chlo.constant` attr-dict $value

מייצג ערך קבוע.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ ConstantLike

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

תוצאות:

chlo.constant_like (chlo::ConstantLikeOp)

אופרטור קבוע מסוג LIKE

הפונקציה מחזירה קבוע splat באותה צורה כמו האופרנד.

מאפיינים: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.cosh (chlo::CoshOp)

אופרטור Cosh

תחביר:

operation ::= `chlo.cosh` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Cosh(operand) לכל רכיב.

\[ \cosh(x) = (e^x + e^-x) / 2 \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.digamma (chlo::DigammaOp)

פונקציית דיגמה

תחביר:

operation ::= `chlo.digamma` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Digamma(operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.erf (chlo::ErfOp)

האופרטור Erfc

תחביר:

operation ::= `chlo.erf` $operand attr-dict `:` type($operand) `->` type($result)

מחשבת את פונקציית השגיאה הגאוסיאנית של x לפי רכיבים.

‫erf(x) = erf_impl(x) if |x| < 1 = 1 - erfc_impl(x) otherwise

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.erf_inv (chlo::ErfInvOp)

Inverse Erf

תחביר:

operation ::= `chlo.erf_inv` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך ErfInv(operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.erfc (chlo::ErfcOp)

האופרטור Erfc

תחביר:

operation ::= `chlo.erfc` $operand attr-dict `:` type($operand) `->` type($result)

מחשבת קירוב של פונקציית השגיאה המשלימה (1 - erf(x)).

‫erfc(x) = erfc_impl(x) if |x| > 1 = 1 - erf_impl(x) otherwise

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.is_inf (chlo::IsInfOp)

הפרדיקט IsInf

תחביר:

operation ::= `chlo.is_inf` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה תשובה אם ערך נתון הוא +/-inf ברמת האלמנט.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.is_neg_inf (chlo::IsNegInfOp)

הפרדיקט IsNegInf

תחביר:

operation ::= `chlo.is_neg_inf` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה תשובה אם ערך נתון הוא ‎-inf‎ ברמת האלמנט.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.is_pos_inf (chlo::IsPosInfOp)

הפרדיקט IsPosInf

תחביר:

operation ::= `chlo.is_pos_inf` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה תשובה אם ערך נתון הוא +inf ברמת האלמנט.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.lgamma (chlo::LgammaOp)

פונקציית Lgamma

תחביר:

operation ::= `chlo.lgamma` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Lgamma(operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.next_after (chlo::NextAfterOp)

האופרטור Std::nextafter

תחביר:

operation ::= `chlo.next_after` $x `,` $y attr-dict `:` type($x) `,` type($y) `->` type(results)

מחזירה את הערך הבא שניתן לייצוג של x בכיוון של y, לפי רכיבים. היא יכולה גם להחזיר מספר תת-נורמלי.

מקבילה לפונקציה std::nextafter ב-C++.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.polygamma (chlo::PolygammaOp)

פונקציית פוליגמה

תחביר:

operation ::= `chlo.polygamma` $n `,` $x attr-dict `:` type($n) `,` type($x) `->` type(results)

הפונקציה מחזירה את הערך Polygamma(operand, operand) לכל רכיב.

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

chlo.ragged_dot (chlo::RaggedDotOp)

מחשב matmul על פני ממד משונן יחיד

הפעולה הזו מקבלת שלושה ארגומנטים של טנסור – lhs,‏ rhs ו-group_sizes – ומאפיין ragged_dot_dimension_numbers. בדומה ל-dot_general, אפשר להשתמש ב-lhs וב-rhs עם מימדים שרירותיים של אצווה ומימדים מצטמצמים. בנוסף, בצד שמאל של המשוואה צריך להיות ממד אחד לא סדיר, ובצד ימין יכול להיות לכל היותר ממד קבוצה אחד. לאופרטור יש שלושה מצבים, בהתאם לסוג המאפיין המדורג בצד ימין.

במצב 1, חתימת הצורה היא [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. בדוגמה הזו, המאפיין הלא סדיר הוא מאפיין שאינו מתכווץ בצד ימין (m). המאפיינים b ו-k מייצגים מאפיינים של קבוצות ושל התכווצות, בהתאמה. בצד שמאל של המשוואה צריך להיות מאפיין של קבוצה (g).

במצב 2, חתימת הצורה היא [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. במקרה הזה, המאפיין הלא סדיר הוא מאפיין מתכווץ בצד ימין או בצד שמאל (k).

במצב 3, חתימת הצורה היא [b,m,k], [b,k,n], [g] -> [b,m,n]. כאן, המאפיין הלא אחיד הוא מאפיין של אצווה בצד ימין או בצד שמאל (b).

מאפיינים: AlwaysSpeculatableImplTrait

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.scan (chlo::ScanOp)

פעולת סריקה

מחיל פונקציית צמצום body על inputs ו-inits לאורך dimension ומפיק את results (שכולל את outputs ו-carries).

אם הערך של is_reverse הוא True, הסריקה מתבצעת בסדר הפוך. ‫is_associative מציין אם פונקציית הצמצום היא אסוציאטיבית.

למידע נוסף: https://www.tensorflow.org/xla/operation_semantics#scan

ל-ScanOp אין כרגע פירוק ל-StableHLO.

מאפיינים: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

ממשקי משתמש: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

מאפיינים:

אופרנדים:

תוצאות:

chlo.sinh (chlo::SinhOp)

פעולת Sinh

תחביר:

operation ::= `chlo.sinh` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Sinh(operand) לכל רכיב.

\[ \sinh(x) = (e^x - e^-x) / 2 if |x| < 1 = e^(x + log(1/2)) - e^(-x + log(1/2)) otherwise. \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.square (chlo::SquareOp)

פעולת ריבוע

תחביר:

operation ::= `chlo.square` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Square(operand) לכל רכיב.

\[ \square(x) = complex((x.real - x.imag) * (x.real + x.imag), x.real * x.imag * 2) if x is a complex number = x * x otherwise \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.tan (chlo::TanOp)

פעולת tan

תחביר:

operation ::= `chlo.tan` $operand attr-dict `:` type($operand) `->` type($result)

הפונקציה מחזירה את הערך Tan(operand) לכל רכיב.

\[ \tan(x) = \sin(x) / \cos(x) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType, ‏ Elementwise, ‏ SameOperandsAndResultShape

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

‫chlo.top_k (chlo::TopKOp)

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

תחביר:

operation ::= `chlo.top_k` `(`$operand `,` `k` `=` $k`)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

אם הקלט הוא וקטור (דרגה 1), הפונקציה מוצאת את k הרשומות הגדולות ביותר בווקטור ומחזירה את הערכים והאינדקסים שלהן כווקטורים. לכן, values[j] הוא הערך הגדול ביותר j ב-input, והאינדקס שלו הוא indices[j].

עבור מטריצות (או קלט בדרגה גבוהה יותר), הפונקציה מחשבת את k הרשומות העליונות בכל שורה (או וקטור לאורך המאפיין האחרון). לכן,

values.shape = indices.shape = input.shape[:-1] + [k]

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

מאפיינים: AlwaysSpeculatableImplTrait, ‏ InferTensorType

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

השפעות: MemoryEffects::Effect{}

מאפיינים:

אופרנדים:

תוצאות:

chlo.zeta (chlo::ZetaOp)

פונקציית זטא של הורביץ

תחביר:

operation ::= `chlo.zeta` $x `,` $q attr-dict `:` type($x) `,` type($q) `->` type(results)

הפונקציה מחזירה את הערך Zeta(operand, operand) לכל רכיב.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

מאפיינים: AlwaysSpeculatableImplTrait, ‏ CompatibleOperandsAndResultType

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

השפעות: MemoryEffects::Effect{}

אופרנדים:

תוצאות:

מאפיינים

ComparisonDirectionAttr

איזו פעולת השוואה לבצע.

תחביר:

#chlo.comparison_direction<
  ::mlir::chlo::ComparisonDirection   # value
>

פרמטרים:

ComparisonTypeAttr

באיזה סוג השוואה להשתמש.

תחביר:

#chlo.comparison_type<
  ::mlir::chlo::ComparisonType   # value
>

פרמטרים:

PrecisionAttr

דיוק XLA לאופרנד. יש לו משמעות ספציפית בבק-אנד.

תחביר:

#chlo.precision<
  ::mlir::chlo::Precision   # value
>

פרמטרים:

RaggedDotDimensionNumbersAttr

מאפיין שמדמה את פרטי המאפיין עבור נקודה משוננת.

פרמטרים:

טיפוסים בני מנייה (enum)

ComparisonDirection

איזו פעולת השוואה לבצע.

מקרים:

ComparisonType

באיזה סוג השוואה להשתמש.

מקרים:

דיוק

דיוק XLA לאופרנד. יש לו משמעות ספציפית בבק-אנד.

מקרים: