סמנטיקה של פעולה

בקטע הבא מתוארת הסמנטיקה של הפעולות שמוגדרות בממשק XlaBuilder. בדרך כלל, הפעולות האלה ממופות אחת לאחת לפעולות שמוגדרות בממשק RPC ב-xla_data.proto.

הערה לגבי מינוח: סוג הנתונים הכללי XLA מתייחס למערך N-ממדי שמכיל רכיבים מסוג אחיד כלשהו (כמו float של 32 ביט). לאורך התיעוד, המונח מערך משמש לציון מערך רב-ממדי. כדי לפשט את הדברים, למקרים מיוחדים יש שמות ספציפיים ומוכרים יותר. לדוגמה, וקטור הוא מערך חד-ממדי ומטריצה היא מערך דו-ממדי.

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

חשיפות

מידע נוסף זמין במאמר בנושא XlaBuilder::Abs.

ערך מוחלט של כל רכיב x -> |x|.

Abs(operand)

מידע על StableHLO זמין במאמר StableHLO - abs.

הוספה

מידע נוסף זמין במאמר בנושא XlaBuilder::Add.

מבצעת חיבור של lhs ו-rhs לפי רכיבים.

Add(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בשידור מממדים שונים לפעולה Add:

Add(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר בנושא StableHLO – add.

AddDependency

מידע נוסף זמין במאמר בנושא HloInstruction::AddDependency.

יכול להיות ש-AddDependency יופיעו בקובצי dump של HLO, אבל הם לא מיועדים לבנייה ידנית על ידי משתמשי קצה.

AfterAll

מידע נוסף זמין במאמר בנושא XlaBuilder::AfterAll.

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

AfterAll(tokens)

למידע על StableHLO, ראו StableHLO – after_all.

AllGather

מידע נוסף זמין במאמר בנושא XlaBuilder::AllGather.

מבצע שרשור בין רפליקות.

AllGather(operand, all_gather_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• ‫replica_groups היא רשימה של קבוצות רפליקות שביניהן מתבצעת השרשור (אפשר לאחזר את מזהה הרפליקה של הרפליקה הנוכחית באמצעות ReplicaId). הסדר של הרפליקות בכל קבוצה קובע את הסדר שבו הקלט שלהן מופיע בתוצאה. replica_groups חייבת להיות ריקה (במקרה כזה כל הרפליקות שייכות לקבוצה אחת, בסדר מ-0 עד N - 1), או להכיל את אותו מספר של רכיבים כמו מספר הרפליקות. לדוגמה, replica_groups = {0, 2}, {1, 3} מבצעת שרשור בין הרפליקות 0 ו-2, ובין 1 ו-3.
• ‫shard_count הוא הגודל של כל קבוצת עותקים. אנחנו צריכים את זה במקרים שבהם replica_groups ריק.
• ‫channel_id משמש לתקשורת בין מודולים: רק פעולות all-gather עם אותו channel_id יכולות לתקשר זו עם זו.
• use_global_device_ids מחזירה true אם המזהים בהגדרות של ReplicaGroup מייצגים מזהה גלובלי של (replica_id * partition_count + partition_id) במקום מזהה רפליקה. כך אפשר לקבץ מכשירים בצורה גמישה יותר אם הפעולה all-reduce היא גם חוצת מחיצות וגם חוצת עותקים.

צורת הפלט היא צורת הקלט שהוגדלה פי all_gather_dimension.shard_count לדוגמה, אם יש שני עותקים והאופרנד הוא [1.0, 2.5] ו-[3.0, 5.25] בהתאמה בשני העותקים, ערך הפלט מהפעולה הזו שבה all_gather_dim הוא 0 יהיה [1.0, 2.5, 3.0,5.25] בשני העותקים.

ממשק ה-API של AllGather מפורק באופן פנימי ל-2 הוראות HLO ‏(AllGatherStart ו-AllGatherDone).

מידע נוסף זמין במאמר בנושא HloInstruction::CreateAllGatherStart.

‫AllGatherStart, AllGatherDone משמשות כפרימיטיבים ב-HLO. יכול להיות שהפעולות האלה יופיעו בקובצי dump של HLO, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

מידע על StableHLO זמין במאמר StableHLO - all_gather.

AllReduce

מידע נוסף זמין במאמר בנושא XlaBuilder::AllReduce.

מבצעת חישוב בהתאמה אישית בין העותקים.

AllReduce(operand, computation, replica_groups, channel_id, shape_with_layout, use_global_device_ids)

• אם operand הוא טאפל של מערכים, הפעולה all-reduce מתבצעת על כל רכיב בטאפל.
• ‫replica_groups היא רשימה של קבוצות עותקים שביניהן מתבצעת הפעולה (אפשר לאחזר את מזהה העותק של העותק הנוכחי באמצעות ReplicaId). הרשימה replica_groups חייבת להיות ריקה (במקרה כזה כל העותקים שייכים לקבוצה אחת) או להכיל את אותו מספר של רכיבים כמו מספר העותקים. לדוגמה, replica_groups = {0, 2}, {1, 3} מבצעת צמצום בין העותקים 0 ו-2, ובין 1 ו-3.
• ‫channel_id משמש לתקשורת בין מודולים: רק פעולות all-reduce עם אותו channel_id יכולות לתקשר זו עם זו.
• ‫shape_with_layout: כופה את הפריסה של AllReduce לפריסה שצוינה. הפרמטר הזה משמש כדי להבטיח את אותו פריסה לקבוצה של פעולות AllReduce שעברו קומפילציה בנפרד.
• use_global_device_ids מחזירה true אם המזהים בהגדרות של ReplicaGroup מייצגים מזהה גלובלי של (replica_id * partition_count + partition_id) במקום מזהה רפליקה. כך אפשר לקבץ מכשירים בצורה גמישה יותר אם הפעולה all-reduce היא גם חוצת מחיצות וגם חוצת עותקים.

צורת הפלט זהה לצורת הקלט. לדוגמה, אם יש שני עותקים והאופרנד הוא [1.0, 2.5] ו-[3.0, 5.25] בהתאמה בשני העותקים, ערך הפלט מהאופרציה הזו וחישוב הסכום יהיה [4.0, 7.75] בשני העותקים. אם הקלט הוא טאפל, הפלט יהיה גם הוא טאפל.

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

ממשק ה-API של AllReduce מפורק באופן פנימי ל-2 הוראות HLO ‏(AllReduceStart ו-AllReduceDone).

מידע נוסף זמין במאמר בנושא HloInstruction::CreateAllReduceStart.

‫AllReduceStart ו-AllReduceDone משמשים כפרימיטיבים ב-HLO. יכול להיות שהפעולות האלה יופיעו בקובצי dump של HLO, אבל הן לא מיועדות ליצירה ידנית על ידי משתמשי קצה.

CrossReplicaSum

מידע נוסף זמין במאמר בנושא XlaBuilder::CrossReplicaSum.

מבצעת את הפעולה AllReduce עם חישוב סכום.

CrossReplicaSum(operand, replica_groups)

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

AllToAll

מידע נוסף זמין במאמר בנושא XlaBuilder::AllToAll.

‫AllToAll היא פעולה קולקטיבית ששולחת נתונים מכל הליבות לכל הליבות. התהליך כולל שני שלבים:

1. שלב הפיזור. בכל ליבה, האופרנד מחולק ל-split_count מספר בלוקים לאורך split_dimensions, והבלוקים מפוזרים לכל הליבות, לדוגמה, הבלוק ה-i נשלח לליבה ה-i.
2. שלב האיסוף. כל ליבה משרשרת את הבלוקים שהתקבלו לאורך concat_dimension.

אפשר להגדיר את הליבות המשתתפות באמצעות:

• ‫replica_groups: כל ReplicaGroup מכיל רשימה של מזהי רפליקות שמשתתפות בחישוב (אפשר לאחזר את מזהה הרפליקה של הרפליקה הנוכחית באמצעות ReplicaId). הפעולה AllToAll תתבצע בתוך קבוצות משנה בסדר שצוין. לדוגמה, replica_groups = { {1,2,3}, {4,5,0} } פירושו ש-AllToAll יוחל בתוך העותקים המשוכפלים {1, 2, 3}, ובשלב האיסוף, והבלוקים שהתקבלו יורכבו באותו סדר של 1, 2, 3. לאחר מכן, עוד פעולת AllToAll תתבצע בין העותקים 4, 5, 0, וסדר השרשור יהיה גם 4, 5, 0. אם השדה replica_groups ריק, כל העותקים שייכים לקבוצה אחת, לפי סדר השרשור של המופעים שלהם.

דרישות מוקדמות:

• גודל המימד של האופרנד ב-split_dimension מתחלק ב-split_count.
• הצורה של האופרנד היא לא טאפל.

AllToAll(operand, split_dimension, concat_dimension, split_count, replica_groups, layout, channel_id)

מידע נוסף על צורות ופריסות זמין במאמר בנושא xla::shapes.

למידע על StableHLO, ראו StableHLO - all_to_all.

‫AllToAll – דוגמה 1.

XlaBuilder b("alltoall");
auto x = Parameter(&b, 0, ShapeUtil::MakeShape(F32, {4, 16}), "x");
AllToAll(
    x,
    /*split_dimension=*/ 1,
    /*concat_dimension=*/ 0,
    /*split_count=*/ 4);

בדוגמה שלמעלה, יש 4 ליבות שמשתתפות בפעולת Alltoall. בכל ליבה, האופרנד מפוצל ל-4 חלקים לאורך מימד 1, כך שלכל חלק יש צורה f32[4,4]. 4 החלקים מפוזרים לכל הליבות. לאחר מכן, כל ליבה משרשרת את החלקים שהתקבלו לאורך מימד 0, בסדר של ליבה 0 עד 4. לכן, הפלט בכל ליבה הוא בצורה f32[16,4].

‫AllToAll – דוגמה 2 – StableHLO

בדוגמה שלמעלה, יש 2 רפליקות שמשתתפות ב-AllToAll. בכל עותק, לאופרנד יש צורה f32[2,4]. האופרנד מפוצל לשני חלקים לאורך מימד 1, כך שלכל חלק יש צורה f32[2,2]. לאחר מכן, שני החלקים מועברים בין העותקים בהתאם למיקום שלהם בקבוצת העותקים. כל רפליקה אוספת את החלק המתאים לה משני האופרנדים ומשרשרת אותם לאורך מימד 0. כתוצאה מכך, הפלט בכל עותק זהה בצורה f32[4,2].

RaggedAllToAll

מידע נוסף זמין במאמר בנושא XlaBuilder::RaggedAllToAll.

‫RaggedAllToAll מבצע פעולה קולקטיבית של all-to-all, שבה הקלט והפלט הם טנסורים משוננים.

RaggedAllToAll(input, input_offsets, send_sizes, output, output_offsets, recv_sizes, replica_groups, channel_id)

טנסורים משוננים מוגדרים על ידי קבוצה של שלושה טנסורים:

• ‫data: הטנזור data הוא 'משונן' לאורך הממד החיצוני ביותר שלו, ולאורך הממד הזה לכל רכיב באינדקס יש גודל משתנה.
• ‫offsets': הטנזור offsets מבצע אינדוקס של הממד החיצוני ביותר של הטנזור data, ומייצג את ההיסטארט של כל רכיב לא סדיר של הטנזור data.
• ‫sizes: טנסור sizes מייצג את הגודל של כל רכיב לא סדיר בטנסור data, כאשר הגודל מצוין ביחידות של רכיבי משנה. רכיב משנה מוגדר כסיומת של צורת טנסור הנתונים שמתקבלת מהסרת המימד החיצוני ביותר 'הלא אחיד'.
• הטנסורים offsets ו-sizes חייבים להיות באותו גודל.

דוגמה לטנזור לא אחיד:

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

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

עבור היסט הפלט ה-i, העותק הנוכחי ישלח עדכון input[input_offsets[i]:input_offsets[i]+send_sizes[i]] לעותק ה-i שייכתב ל-output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] בעותק ה-i output.

לדוגמה, אם יש לנו 2 רפליקות:

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

ה-HLO המקוטע all-to-all כולל את הארגומנטים הבאים:

• ‫input: טנסור של נתוני קלט לא אחידים.
• ‫output: טנסור של נתוני פלט לא אחידים.
• ‫input_offsets: טנזור של היסטים של קלט לא אחיד.
• ‫send_sizes: טנזור של גדלים לא אחידים של שליחת נתונים.
• ‫output_offsets: מערך של היסטים לא סדירים בפלט של העותק המשוכפל של היעד.
• ‫recv_sizes: טנסור של גדלים לא אחידים של recv.

לכל הטנסורים *_offsets ו-*_sizes צריך להיות אותו צורה.

יש תמיכה בשתי צורות של טנסורים *_offsets ו-*_sizes:

• ‫[num_devices] שבו יכול להיות שיישלח עדכון אחד לכל מכשיר שמחובר לרשת אחרת בקבוצת העותקים. לדוגמה:

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] שבו יכול להיות שעדכונים של num_updates יישלחו עד num_updates לאותו מכשיר שמחובר לרשת אחרת (כל אחד בהיסט שונה), לכל מכשיר שמחובר לרשת אחרת בקבוצת העותקים.

לדוגמה:

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

וגם

מידע נוסף זמין במאמר בנושא XlaBuilder::And.

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

And(lhs, rhs)

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

קיים וריאנט חלופי עם תמיכה בהרחבה לממדים שונים עבור And:

And(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמרים StableHLO ו-StableHLO –.

אסינכרוני

ראו גם HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone.

‫AsyncDone,‏ AsyncStart ו-AsyncUpdate הן הוראות HLO פנימיות שמשמשות לפעולות אסינכרוניות, והן פרימיטיבים ב-HLO. יכול להיות שהפעולות האלה יופיעו בפריקות של HLO, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

Atan2

מידע נוסף זמין במאמר בנושא XlaBuilder::Atan2.

מבצעת פעולת atan2 לפי רכיבים ב-lhs וב-rhs.

Atan2(lhs, rhs)

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

קיימת גרסה חלופית עם תמיכה בשידור עם ממדים שונים של Atan2:

Atan2(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר בנושא StableHLO – atan2.

BatchNormGrad

תיאור מפורט של האלגוריתם מופיע גם במאמרים XlaBuilder::BatchNormGrad והמקורי בנושא נורמליזציה של קבוצות.

מחשבת את הגרדיאנטים של נורמליזציית אצווה.

BatchNormGrad(operand, scale, batch_mean, batch_var, grad_output, epsilon, feature_index)

לכל מאפיין במאפיין התכונה (feature_index הוא האינדקס של מאפיין התכונה ב-operand), הפעולה מחשבת את הגרדיאנטים ביחס ל-operand,‏ offset ו-scale בכל שאר המאפיינים. feature_index חייב להיות אינדקס תקין של מאפיין התכונה ב-operand.

שלושת הגרדיאנטים מוגדרים באמצעות הנוסחאות הבאות (בהנחה שמערך 4 ממדי כ-operand, עם אינדקס ממד התכונה l, גודל אצווה m וגדלים מרחביים w ו-h):

\[ \begin{split} c_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sigma^2_l+\epsilon} \right) \\\\ d_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\\\ \nabla x_{ijkl} &= \frac{\gamma_{l} }{\sqrt{\sigma^2_{l}+\epsilon} } \left( \nabla y_{ijkl} - d_l - c_l (x_{ijkl} - \mu_{l}) \right) \\\\ \nabla \gamma_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sqrt{\sigma^2_{l}+\epsilon} } \right) \\\\\ \nabla \beta_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \end{split} \]

הערכים batch_mean ו-batch_var מייצגים ערכי רגעים במאפיינים של קבוצות ומרחבים.

סוג הפלט הוא טאפל של שלושה אובייקטים מסוג handle:

מידע על StableHLO זמין במאמר StableHLO – batch_norm_grad.

BatchNormInference

תיאור מפורט של האלגוריתם מופיע גם במאמרים XlaBuilder::BatchNormInference והמקורי בנושא נורמליזציה של קבוצות.

מנרמלת מערך על פני מימדים של אצווה ומימדים מרחביים.

BatchNormInference(operand, scale, offset, mean, variance, epsilon, feature_index)

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

‫BatchNormInference שווה לקריאה ל-BatchNormTraining בלי לחשב את mean ואת variance לכל אצווה. במקום זאת, הוא משתמש בערכי הקלט mean ו-variance כערכים משוערים. המטרה של האופרטור הזה היא להקטין את זמן האחזור בהסקת מסקנות, ומכאן השם BatchNormInference.

הפלט הוא מערך מנורמל n-ממדי עם אותה צורה כמו הקלט operand.

מידע על StableHLO זמין במאמר StableHLO – batch_norm_inference.

BatchNormTraining

לתיאור מפורט של האלגוריתם, אפשר לעיין גם במאמרים XlaBuilder::BatchNormTraining וthe original batch normalization paper.

מנרמלת מערך על פני מימדים של אצווה ומימדים מרחביים.

BatchNormTraining(operand, scale, offset, epsilon, feature_index)

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

האלגוריתם פועל באופן הבא לכל אצווה ב-operand \(x\) שמכילה m רכיבים עם w ו-h כגודל הממדים המרחביים (בהנחה ש-operand הוא מערך 4 ממדי):

• מחשבת את הממוצע של קבוצת הפריטים \(\mu_l\) לכל תכונה l בממד התכונה: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• חישוב השונות של קבוצת תמונות \(\sigma^2_l\): $\sigma^2l=\frac{1}{mwh}\sum{i=1}^m\sum{j=1}^w\sum{k=1}^h (x_{ijkl} - \mu_l)^2$

• נרמול, שינוי קנה מידה והזזה: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

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

סוג הפלט הוא טאפל של שלושה ערכים מסוג XlaOp:

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

מידע על StableHLO זמין במאמר StableHLO - batch_norm_training.

Bitcast

מידע נוסף זמין במאמר בנושא HloInstruction::CreateBitcast.

‫Bitcast עשוי להופיע בקובצי dump של HLO, אבל הוא לא מיועד לבנייה ידנית על ידי משתמשי קצה.

BitcastConvertType

מידע נוסף זמין במאמר בנושא XlaBuilder::BitcastConvertType.

בדומה ל-tf.bitcast ב-TensorFlow, הפעולה מבצעת bitcast ברמת הרכיב מצורת נתונים לצורת יעד. הגודל של הקלט והפלט חייב להיות זהה: לדוגמה, s32 רכיבים הופכים ל-f32 רכיבים באמצעות שגרת bitcast, ורכיב אחד של s32 יהפוך לארבעה רכיבים של s8. הפעולה bitcast מיושמת כהמרה ברמה נמוכה, ולכן מכונות עם ייצוגים שונים של נקודות צפות יניבו תוצאות שונות.

BitcastConvertType(operand, new_element_type)

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

סוגי הרכיבים של המקור והיעד לא יכולים להיות טאפלים.

מידע על StableHLO זמין במאמר StableHLO - bitcast_convert.

Bitcast-converting to primitive type of different width

BitcastConvert הוראת HLO תומכת במקרה שבו הגודל של סוג רכיב הפלט T' לא שווה לגודל של רכיב הקלט T. מכיוון שהפעולה כולה היא המרה של ביטים ולא משנה את הבייטים הבסיסיים, הצורה של רכיב הפלט צריכה להשתנות. עבור B = sizeof(T), B' = sizeof(T'), יש שני מקרים אפשריים.

קודם כול, כש-B > B', צורת הפלט מקבלת מימד חדש קטן יותר בגודל B/B'. לדוגמה:

  f16[10,2]{1,0} %output = f16[10,2]{1,0} bitcast-convert(f32[10]{0} %input)

הכלל נשאר זהה לגבי סקלרים אפקטיביים:

  f16[2]{0} %output = f16[2]{0} bitcast-convert(f32[] %input)

לחלופין, עבור B' > B, ההוראה מחייבת שהמאפיין הלוגי האחרון של צורת הקלט יהיה שווה ל-B'/B, והמאפיין הזה מושמט במהלך ההמרה:

  f32[10]{0} %output = f32[10]{0} bitcast-convert(f16[10,2]{1,0} %input)

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

להודיע לכולם

מידע נוסף זמין במאמר בנושא XlaBuilder::Broadcast.

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

Broadcast(operand, broadcast_sizes)

המימדים החדשים מוכנסים בצד ימין, כלומר אם ל-broadcast_sizes יש ערכים {a0, ..., aN} ולצורה של האופרנד יש מימדים {b0, ..., bM}, אז לצורה של הפלט יש מימדים {a0, ..., aN, b0, ..., bM}.

האינדקס של המאפיינים החדשים הוא עותקים של האופרנד, כלומר

output[i0, ..., iN, j0, ..., jM] = operand[j0, ..., jM]

לדוגמה, אם operand הוא סקלר f32 עם ערך 2.0f, ו-broadcast_sizes הוא {2, 3}, התוצאה תהיה מערך עם צורה f32[2, 3] וכל הערכים בתוצאה יהיו 2.0f.

מידע על StableHLO זמין במאמר StableHLO – שידור.

BroadcastInDim

מידע נוסף זמין במאמר בנושא XlaBuilder::BroadcastInDim.

מרחיבה את הגודל ואת מספר המאפיינים של מערך על ידי שכפול הנתונים במערך.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

בדומה ל-Broadcast, אבל מאפשר להוסיף מאפיינים בכל מקום ולהרחיב מאפיינים קיימים עם גודל 1.

הפעולה operand מועברת לשידור לצורה שמתוארת על ידי out_dim_size. הפעולה broadcast_dimensions ממפה את הממדים של operand לממדים של צורת היעד, כלומר הממד ה-i של האופרנד ממופה לממד ה-broadcast_dimension[i] של צורת הפלט. הממדים של operand חייבים להיות בגודל 1 או באותו גודל כמו הממד בצורת הפלט שהם ממופים אליו. שאר הממדים מתמלאים בממדים בגודל 1. לאחר מכן, מתבצע שידור של ממדים מנוונים לאורך הממדים המנוונים האלה כדי להגיע לצורת הפלט. הסמנטיקה מתוארת בפירוט בדף בנושא שידור.

התקשרות

מידע נוסף זמין במאמר בנושא XlaBuilder::Call.

מפעילה חישוב עם הארגומנטים שצוינו.

Call(computation, operands...)

האריות והסוגים של operands צריכים להתאים לפרמטרים של computation. מותר לא לכלול את operands.

CompositeCall

מידע נוסף זמין במאמר בנושא XlaBuilder::CompositeCall.

פעולה שמכילה (מורכבת מ) פעולות אחרות של StableHLO, מקבלת קלט ומאפיינים מורכבים ומפיקה תוצאות. הסמנטיקה של הפעולה מיושמת על ידי מאפיין הפירוק. אפשר להחליף את הפעולה המורכבת בפירוק שלה בלי לשנות את הסמנטיקה של התוכנית. במקרים שבהם הוספת הפירוק לא מספקת את אותה סמנטיקה של פעולה, מומלץ להשתמש ב-custom_call.

השדה version (ברירת המחדל היא 0) משמש לציון מתי הסמנטיקה של רכיב מורכב משתנה.

הפעולה הזו מיושמת כ-kCall עם המאפיין is_composite=true. השדה decomposition מוגדר על ידי המאפיין computation. מאפייני קצה קדמי מאחסנים את המאפיינים שנותרו עם הקידומת composite..

דוגמה לפעולת CompositeCall:

f32[] call(f32[] %cst), to_apply=%computation, is_composite=true,
frontend_attributes = {
  composite.name="foo.bar",
  composite.attributes={n = 1 : i32, tensor = dense<1> : tensor<i32>},
  composite.version="1"
}

CompositeCall(computation, operands..., name, attributes, version)

ה-decomposition של פעולה לא מופיע כשדה שנקרא, אלא כמאפיין to_apply שמפנה לפונקציה שמכילה את ההטמעה ברמה נמוכה יותר, כלומר to_apply=%funcname

מידע נוסף על קומפוזיציה ופירוק אפשר למצוא במפרט StableHLO.

Cbrt

מידע נוסף זמין במאמר בנושא XlaBuilder::Cbrt.

פעולת שורש שלישי לפי רכיבים x -> cbrt(x).

Cbrt(operand)

הפונקציה Cbrt תומכת גם בארגומנט האופציונלי result_accuracy:

Cbrt(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – cbrt.

תקרה

מידע נוסף זמין במאמר בנושא XlaBuilder::Ceil.

הפונקציה element-wise ceil x -> ⌈x⌉.

Ceil(operand)

מידע על StableHLO זמין במאמר StableHLO - ceil.

Cholesky

מידע נוסף זמין במאמר בנושא XlaBuilder::Cholesky.

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

Cholesky(a, lower)

אם lower הוא true, הפונקציה מחשבת מטריצות משולשיות תחתונות l כך ש-$a = l . ‫l^T$. אם lower הוא false, הפונקציה מחשבת מטריצות משולשיות עליונות u כך שמתקיים\(a = u^T . u\).

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

אם ל-a יש יותר מ-2 מאפיינים, המערכת מתייחסת ל-a כאל קבוצה של מטריצות, שבה כל המאפיינים חוץ מ-2 המאפיינים המשניים הם מאפיינים של קבוצת המטריצות.

אם a הוא לא סימטרי (הרמיטי) וחיובי מוגדר, התוצאה היא הגדרה שמוגדרת בהטמעה.

למידע על StableHLO, ראו StableHLO – cholesky.

תיחום

מידע נוסף זמין במאמר בנושא XlaBuilder::Clamp.

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

Clamp(min, operand, max)

בהינתן אופרנד וערכים מינימליים ומקסימליים, הפונקציה מחזירה את האופרנד אם הוא נמצא בטווח שבין הערך המינימלי לערך המקסימלי. אחרת, היא מחזירה את הערך המינימלי אם האופרנד נמוך מהטווח הזה, או את הערך המקסימלי אם האופרנד גבוה מהטווח הזה. כלומר, clamp(a, x, b) = min(max(a, x), b).

לכל שלושת המערכים צריכה להיות אותה צורה. לחלופין, כצורה מוגבלת של שידור, min או max יכולים להיות סקלר מסוג T.

דוגמה עם סקלר min ו-max:

let operand: s32[3] = {-1, 5, 9};
let min: s32 = 0;
let max: s32 = 6;
==>
Clamp(min, operand, max) = s32[3]{0, 5, 6};

מידע על StableHLO זמין במאמר StableHLO - clamp.

כיווץ

מידע נוסף זמין במאמר בנושא XlaBuilder::Collapse. והפעולה tf.reshape.

מצמצמת את המימדים של מערך למימד אחד.

Collapse(operand, dimensions)

הפעולה Collapse מחליפה את קבוצת המשנה הנתונה של מימדי האופרנד במימד יחיד. ארגומנטים הקלט הם מערך שרירותי מסוג T וקטור קבוע של אינדקסים של מימדים בזמן הקומפילציה. האינדקסים של המימדים חייבים להיות קבוצת משנה רציפה של מימדי T, בסדר עולה (מספר המימד הנמוך ביותר עד מספר המימד הגבוה ביותר). לכן, {0, 1, 2},‏ {0, 1} או {1, 2} הן קבוצות מימדים תקינות, אבל {1, 0} או {0, 2} לא תקינות. הן מוחלפות במימד חדש יחיד, באותו מיקום ברצף המימדים כמו המימדים שהן מחליפות, כאשר גודל המימד החדש שווה למכפלת גדלי המימדים המקוריים. מספר המימד הנמוך ביותר ב-dimensions הוא המימד המשתנה הכי לאט (הכי משמעותי) בלולאה שמקפלת את המימדים האלה, ומספר המימד הגבוה ביותר הוא המימד המשתנה הכי מהר (הכי משני). אם נדרש סדר קיפול כללי יותר, אפשר להשתמש באופרטור tf.reshape.

לדוגמה, נניח ש-v הוא מערך של 24 רכיבים:

let v = f32[4x2x3] { { {10, 11, 12}, {15, 16, 17} },
{ {20, 21, 22}, {25, 26, 27} },
{ {30, 31, 32}, {35, 36, 37} },
{ {40, 41, 42}, {45, 46, 47} } };

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

Clz

מידע נוסף זמין במאמר בנושא XlaBuilder::Clz.

ספירת אפסים מובילים בכל רכיב.

Clz(operand)

CollectiveBroadcast

מידע נוסף זמין במאמר בנושא XlaBuilder::CollectiveBroadcast.

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

CollectiveBroadcast(operand, replica_groups, channel_id)

מידע על StableHLO זמין במאמר StableHLO - collective_broadcast.

CollectivePermute

מידע נוסף זמין במאמר בנושא XlaBuilder::CollectivePermute.

‫CollectivePermute היא פעולה קולקטיבית ששולחת ומקבלת נתונים בין רפליקות.

CollectivePermute(operand, source_target_pairs, channel_id)

שימו לב להגבלות הבאות על source_target_pairs:

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

ה-API של פעולת CollectivePermute מפורק באופן פנימי ל-2 הוראות HLO‏ (CollectivePermuteStart ו-CollectivePermuteDone).

מידע נוסף זמין במאמר בנושא HloInstruction::CreateCollectivePermuteStart.

‫CollectivePermuteStart ו-CollectivePermuteDone משמשים כפרימיטיבים ב-HLO. יכול להיות שהפעולות האלה יופיעו בקובצי dump של HLO, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

למידע על StableHLO, ראו StableHLO - collective_permute.

השוואה

מידע נוסף זמין במאמר בנושא XlaBuilder::Compare.

הפונקציה מבצעת השוואה בין lhs לבין rhs של הרכיבים הבאים:

Eq

מידע נוסף זמין במאמר בנושא XlaBuilder::Eq.

הפונקציה מבצעת השוואה שווה ל- בין lhs לבין rhs ברמת הרכיב.

\(lhs = rhs\)

Eq(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בהרחבת שידור לממדים שונים עבור Eq:

Eq(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

קיימת תמיכה בסכום הזמנה כולל מעל המספרים הנקודתיים עבור Eq, על ידי אכיפה של:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

EqTotalOrder(lhs,rhs, broadcast_dimensions)

מידע על StableHLO זמין במאמר StableHLO – השוואה.

Ne

מידע נוסף זמין במאמר בנושא XlaBuilder::Ne.

הפונקציה מבצעת השוואה של lhs ו-rhs לפי רכיבים, כדי לבדוק אם הם לא שווים.

\(lhs != rhs\)

Ne(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בהרחבת שידור לממדים שונים עבור Ne:

Ne(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

קיימת תמיכה בסכום הזמנה כולל מעל המספרים הנקודתיים ב-Ne, על ידי אכיפה של:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

NeTotalOrder(lhs,rhs, broadcast_dimensions)

מידע על StableHLO זמין במאמר StableHLO – השוואה.

Ge

מידע נוסף זמין במאמר בנושא XlaBuilder::Ge.

הפונקציה מבצעת השוואה greater-or-equal-than בין lhs לבין rhs, לפי רכיב.

\(lhs >= rhs\)

Ge(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בהפצה רחבה של מימדים שונים עבור Ge:

Ge(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

קיימת תמיכה בסכום הזמנה כולל מעל המספרים הנקודתיים הצפים ב-Gt, על ידי אכיפה של:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

GtTotalOrder(lhs,rhs, broadcast_dimensions)

מידע על StableHLO זמין במאמר StableHLO – השוואה.

Gt

מידע נוסף זמין במאמר בנושא XlaBuilder::Gt.

מבצע השוואה של lhs ו-rhs לפי גדול מ- ברמת הרכיב.

\(lhs > rhs\)

Gt(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בהרחבה לממדים שונים עבור Gt:

Gt(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO – השוואה.

Le

מידע נוסף זמין במאמר בנושא XlaBuilder::Le.

הפונקציה מבצעת השוואה less-or-equal-than בין כל רכיב ב-lhs לבין הרכיב התואם ב-rhs.

\(lhs <= rhs\)

Le(lhs, rhs)

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

קיימת גרסה חלופית עם תמיכה בשידור בממדים שונים עבור Le:‏

Le(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

קיימת תמיכה בסכום הזמנה כולל מעל המספרים הנקודתיים הצפים עבור Le, על ידי אכיפה של:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LeTotalOrder(lhs,rhs, broadcast_dimensions)

מידע על StableHLO זמין במאמר StableHLO – השוואה.

Lt

מידע נוסף זמין במאמר בנושא XlaBuilder::Lt.

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

\(lhs < rhs\)

Lt(lhs, rhs)

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

קיים משתנה חלופי עם תמיכה בהעברה רב-ממדית עבור Lt:

Lt(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

קיימת תמיכה בסכום הזמנה כולל מעל המספרים הנקודתיים עבור Lt, על ידי אכיפה של:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LtTotalOrder(lhs,rhs, broadcast_dimensions)

מידע על StableHLO זמין במאמר StableHLO – השוואה.

רמה למתקדמים מאוד

מידע נוסף זמין במאמר בנושא XlaBuilder::Complex.

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

Complex(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בהרחבת שידור לממדים שונים עבור Complex:

Complex(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO – complex.

ConcatInDim (שרשור)

מידע נוסף זמין במאמר בנושא XlaBuilder::ConcatInDim.

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

Concatenate(operands..., dimension)

כל המימדים חייבים להיות זהים, למעט dimension. הסיבה לכך היא ש-XLA לא תומך במערכים לא סדירים. חשוב גם לזכור שאי אפשר לשרשר ערכים של מאפיינים עם 0 ממדים (כי אי אפשר לתת שם לממד שלפיו מתבצע השרשור).

דוגמה חד-ממדית:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
//Output:  {2, 3, 4, 5, 6, 7}

דוגמה דו-ממדית:

let a = { {1, 2},
         {3, 4},
         {5, 6} };

let b = { {7, 8} };

Concat({a, b}, 0)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

תרשים:

מידע על StableHLO זמין במאמר StableHLO – concatenate.

משפטי תנאי

מידע נוסף זמין במאמר בנושא XlaBuilder::Conditional.

Conditional(predicate, true_operand, true_computation, false_operand, false_computation)

מבצעת את true_computation אם predicate הוא true, מבצעת את false_computation אם predicate הוא false ומחזירה את התוצאה.

התנאי true_computation צריך לקבל ארגומנט יחיד מסוג \(T_0\) , והוא יופעל עם true_operand שחייב להיות מאותו סוג. הפונקציה false_computation צריכה לקבל ארגומנט יחיד מהסוג \(T_1\) והיא תופעל עם false_operand שחייב להיות מאותו סוג. הסוג של הערך המוחזר של true_computation ושל false_computation חייב להיות זהה.

שימו לב: רק אחת מהפעולות true_computation ו-false_computation תתבצע, בהתאם לערך של predicate.

Conditional(branch_index, branch_computations, branch_operands)

מבצע את branch_computations[branch_index] ומחזיר את התוצאה. אם branch_index הוא S32 שקטן מ-0 או גדול מ-N או שווה לו, אז branch_computations[N-1] מבוצע כענף ברירת המחדל.

כל branch_computations[b] צריך לקבל ארגומנט יחיד מהסוג \(T_b\) , והוא יופעל עם branch_operands[b] שצריך להיות מאותו סוג. סוג הערך המוחזר של כל branch_computations[b] צריך להיות זהה.

שימו לב שרק אחת מהפעולות branch_computations תבוצע, בהתאם לערך של branch_index.

מידע על StableHLO זמין במאמר בנושא StableHLO – if.

קבוע

מידע נוסף זמין במאמר בנושא XlaBuilder::ConstantLiteral.

הפונקציה מחזירה output מקבוע literal.

Constant(literal)

למידע על StableHLO, ראו StableHLO – קבוע.

ConvertElementType

מידע נוסף זמין במאמר בנושא XlaBuilder::ConvertElementType.

בדומה ל-static_cast ב-C++‎,‏ ConvertElementType מבצעת פעולת המרה ברמת הרכיב מצורת נתונים לצורת יעד. המימדים צריכים להיות זהים, וההמרה היא ברמת הרכיב. לדוגמה, s32 רכיבים הופכים ל-f32 רכיבים באמצעות שגרת המרה מ-s32 ל-f32.

ConvertElementType(operand, new_element_type)

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

המרות כמו T=s32 ל-U=f32 יבצעו שגרת המרה של מספר שלם למספר עשרוני עם נורמליזציה, כמו עיגול למספר הזוגי הקרוב ביותר.

let a: s32[3] = {0, 1, 2};
let b: f32[3] = convert(a, f32);
then b == f32[3]{0.0, 1.0, 2.0}

מידע על StableHLO זמין במאמר StableHLO – convert.

Conv (Convolution)

מידע נוסף זמין במאמר בנושא XlaBuilder::Conv.

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

‫Conv Enqueues a convolution instruction onto the computation, which uses the default convolution dimension numbers with no dilation.

הריפוד מצוין בקיצור כ-SAME או כ-VALID. הריפוד SAME מרפד את הקלט (lhs) באפסים כך שלפלט יש את אותו הצורה כמו לקלט, בלי להתחשב בצעדים. ריווח תקין פשוט אומר שאין ריווח.

Conv(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

אמצעי בקרה ברמות שונות זמינים ב-Conv:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

נסמן ב-n את מספר הממדים המרחביים. הארגומנט lhs הוא מערך (n+2)-ממדי שמתאר את שטח הבסיס. החלק הזה נקרא קלט, אף על פי שגם החלק השמאלי הוא קלט. ברשת נוירונים, אלה הפעלות הקלט. ‫n+2 המאפיינים הם, בסדר הזה:

• ‫batch: כל קואורדינטה בממד הזה מייצגת קלט עצמאי שעליו מתבצעת קונבולוציה.
• ‫z/depth/features: לכל מיקום (y,x) באזור הבסיס משויך וקטור שמייצג את המאפיין הזה.
• ‫spatial_dims: מתאר את המידות המרחביות של n שמגדירות את אזור הבסיס שהחלון נע לאורכו.

הארגומנט rhs הוא מערך (n+2)-ממדי שמתאר את המסנן/הליבה/החלון של הקונבולוציה. אלה המאפיינים, לפי הסדר:

• ‫output-z: המאפיין z של הפלט.
• ‫input-z: הגודל של המאפיין הזה כפול feature_group_count צריך להיות שווה לגודל של המאפיין z בצד ימין.
• ‫spatial_dims: מתאר את המימדים המרחביים n שמגדירים את החלון ה-n-d שנע על פני אזור הבסיס.

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

הארגומנט padding מציין את מספר האפסים שיוספו לשטח הבסיס. הערך של הריפוד יכול להיות שלילי – הערך המוחלט של ריפוד שלילי מציין את מספר האלמנטים שיש להסיר מהממד שצוין לפני שמבצעים את הקונבולוציה. ‫padding[0] מציין את הריווח של המאפיין y, ו-padding[1] מציין את הריווח של המאפיין x. בכל זוג, הריווח התחתון הוא הרכיב הראשון והריווח העליון הוא הרכיב השני. המרווח הפנימי הנמוך מוחל בכיוון של אינדקסים נמוכים יותר, והמרווח הפנימי הגבוה מוחל בכיוון של אינדקסים גבוהים יותר. לדוגמה, אם padding[1] הוא (2,3), יהיה ריפוד של 2 אפסים בצד שמאל ו-3 אפסים בצד ימין בממד המרחבי השני. שימוש בריפוד שקול להוספת אותם ערכי אפס לקלט (lhs) לפני ביצוע הקונבולוציה.

הארגומנטים lhs_dilation ו-rhs_dilation מציינים את מקדם ההרחבה שיחול על lhs ו-rhs, בהתאמה, בכל ממד מרחבי. אם גורם ההרחבה בממד מרחבי הוא d, אז d-1 חורים מוצבים באופן מרומז בין כל אחת מהרשומות בממד הזה, וכך גודל המערך גדל. החורים ממולאים בערך no-op, שבמקרה של קונבולוציה הוא אפסים.

הרחבה של הצד הימני נקראת גם קונבולוציה עם חורים. פרטים נוספים זמינים במאמר tf.nn.atrous_conv2d. הרחבה של הצד הימני נקראת גם קונבולוציה משוחפת. פרטים נוספים זמינים במאמר tf.nn.conv2d_transpose.

אפשר להשתמש בארגומנט feature_group_count (ערך ברירת המחדל הוא 1) עבור קונבולוציות מקובצות. ‫feature_group_count צריך להיות מחלק של מימד התכונה של הקלט ושל הפלט. אם הערך של feature_group_count גדול מ-1, המשמעות היא שמימד התכונה של הקלט ומימד התכונה של הפלט מחולקים באופן שווה לכמה קבוצות של feature_group_count, וכל קבוצה מורכבת מרצף עוקב של תכונות.rhs התכונה של קלט המימד של rhs צריכה להיות שווה למימד של תכונת הקלט lhs חלקי feature_group_count (כך שהגודל שלה כבר יהיה הגודל של קבוצת תכונות קלט). הקבוצות ה-i משמשות יחד לחישוב feature_group_count עבור הרבה קונבולוציות נפרדות. התוצאות של הקונבולוציות האלה משורשרות יחד בממד התכונה של הפלט.

במקרה של קונבולוציה עומקית, הארגומנט feature_group_count יוגדר למאפיין הקלט של המאפיין, והמסנן ישונה מ-[filter_height, filter_width, in_channels, channel_multiplier] ל-[filter_height, filter_width, 1, in_channels * channel_multiplier]. פרטים נוספים זמינים במאמר tf.nn.depthwise_conv2d.

אפשר להשתמש בארגומנט batch_group_count (ערך ברירת המחדל הוא 1) לסינון מקובץ במהלך הפצת שגיאות לאחור. ‫batch_group_count צריך להיות מחלק של גודל המימד של אצווה lhs (קלט). אם batch_group_count גדול מ-1, המשמעות היא שגודל המנה בפלט צריך להיות input batch / batch_group_count. הערך batch_group_count חייב להיות מחלק של גודל תכונת הפלט.

הצורה של הפלט כוללת את המימדים הבאים, בסדר הזה:

• ‫batch: הגודל של המאפיין הזה כפול batch_group_count צריך להיות שווה לגודל של המאפיין batch בצד ימין.
• ‫z: אותו גודל כמו output-z בקרנל (rhs).
• ‫spatial_dims: ערך אחד לכל מיקום חוקי של חלון הקונבולוציה.

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

המיקומים התקינים של חלון הקונבולוציה נקבעים לפי הצעדים (strides) וגודל אזור הבסיס אחרי הריפוד.

כדי לתאר מה עושה קונבולוציה, נתייחס לקונבולוציה דו-ממדית ונבחר כמה קואורדינטות קבועות batch,‏ z,‏ y,‏ x בפלט. אז (y,x) הוא מיקום של פינת החלון בתוך אזור הבסיס (למשל, הפינה הימנית העליונה, בהתאם לאופן שבו מפרשים את המימדים המרחביים). עכשיו יש לנו חלון דו-ממדי, שנלקח מהאזור הבסיסי, שבו כל נקודה דו-ממדית משויכת לווקטור חד-ממדי, כך שמתקבלת תיבה תלת-ממדית. מליבת הקונבולוציה, מכיוון שקבענו את קואורדינטת הפלט z, יש לנו גם תיבה תלת-ממדית. לשתי התיבות יש את אותם הממדים, ולכן אפשר לחשב את סכום המכפלות של הרכיבים בין שתי התיבות (בדומה למכפלה סקלרית). זה ערך הפלט.

שימו לב: אם output-z הוא 5, למשל, כל מיקום בחלון יוצר 5 ערכים בפלט במאפיין z של הפלט. הערכים האלה שונים זה מזה בחלק של ליבת הקונבולוציה שמשמשת – יש תיבה נפרדת של ערכים בתלת-ממד שמשמשת לכל קואורדינטה של output-z. אפשר לחשוב על זה כעל 5 קונבולוציות נפרדות עם מסנן שונה לכל אחת מהן.

הנה פסאודו קוד עבור קונבולוציה דו-ממדית עם ריפוד ודילוג:

for (b, oz, oy, ox) { // output coordinates
  value = 0;
  for (iz, ky, kx) { // kernel coordinates and input z
    iy = oy*stride_y + ky - pad_low_y;
    ix = ox*stride_x + kx - pad_low_x;
    if ((iy, ix) inside the base area considered without padding) {
      value += input(b, iz, iy, ix) * kernel(oz, iz, ky, kx);
    }
  }
  output(b, oz, oy, ox) = value;
}

‫precision_config משמש לציון הגדרת הדיוק. הרמה קובעת אם החומרה תנסה ליצור עוד הוראות של שפת מכונה כדי לספק הדמיה מדויקת יותר של סוג הנתונים כשצריך (כלומר, הדמיה של f32 ב-TPU שתומך רק ב-bf16 matmuls). הערכים האפשריים הם DEFAULT,‏ HIGH,‏ HIGHEST. פרטים נוספים בקטעים בנושא MXU.

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

מידע על StableHLO זמין במאמר StableHLO – convolution.

ConvWithGeneralPadding

מידע נוסף זמין במאמר בנושא XlaBuilder::ConvWithGeneralPadding.

ConvWithGeneralPadding(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

זהה ל-Conv כאשר הגדרת הריפוד מפורשת.

ConvWithGeneralDimensions

מידע נוסף זמין במאמר בנושא XlaBuilder::ConvWithGeneralDimensions.

ConvWithGeneralDimensions(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

זהה ל-Conv, שבו מספרי המאפיינים מצוינים במפורש.

ConvGeneral

מידע נוסף זמין במאמר בנושא XlaBuilder::ConvGeneral.

ConvGeneral(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

זהה ל-Conv, שבו מספרי המאפיינים והגדרת הריפוד מוגדרים באופן מפורש

ConvGeneralDilated

מידע נוסף זמין במאמר בנושא XlaBuilder::ConvGeneralDilated.

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

זהה ל-Conv, שבו הגדרת הריפוד, גורמי ההרחבה ומספרי המאפיינים מפורטים.

העתקה

מידע נוסף זמין במאמר בנושא HloInstruction::CreateCopyStart.

הפעולה Copy מפורקת באופן פנימי ל-2 הוראות HLO‏ CopyStart ו-CopyDone. הפעולה Copy, יחד עם CopyStart ו-CopyDone, משמשת כפרימיטיב ב-HLO. יכול להיות שהפעולות האלה יופיעו בקובצי dump של HLO, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

Cos

ראו גםXlaBuilder::Cos.

קוסינוס לפי רכיבים x -> cos(x).

Cos(operand)

‫Cos תומך גם בארגומנט האופציונלי result_accuracy:

Cos(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – cosine.

Cosh

מידע נוסף זמין במאמר בנושא XlaBuilder::Cosh.

קוסינוס היפרבולי של כל רכיב x -> cosh(x).

Cosh(operand)

‫Cosh תומך גם בארגומנט האופציונלי result_accuracy:

Cosh(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

CustomCall

מידע נוסף זמין במאמר בנושא XlaBuilder::CustomCall.

הפעלת פונקציה שסופקה על ידי המשתמש בתוך חישוב.

מסמכי התיעוד של CustomCall מופיעים במאמר פרטים למפתחים – קריאות מותאמות אישית של XLA

מידע על StableHLO זמין במאמר בנושא StableHLO – custom_call.

מח'

מידע נוסף זמין במאמר בנושא XlaBuilder::Div.

מבצעת חילוק של כל רכיב של המחולק lhs בכל רכיב של המחלק rhs.

Div(lhs, rhs)

גלישה בחילוק של מספרים שלמים (חילוק/שארית של מספרים חיוביים/שליליים באפס או חילוק/שארית של INT_SMIN ב--1) יוצרת ערך שמוגדר על ידי ההטמעה.

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

קיימת גרסה חלופית עם תמיכה בשידור במימדים שונים של Div:

Div(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר בנושא StableHLO – חלוקה.

דומיין

מידע נוסף זמין במאמר בנושא HloInstruction::CreateDomain.

‫Domain עשוי להופיע בקובצי dump של HLO, אבל הוא לא מיועד לבנייה ידנית על ידי משתמשי קצה.

נקודה

מידע נוסף זמין במאמר בנושא XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

הסמנטיקה המדויקת של הפעולה הזו תלויה בדרגות של האופרנדים:

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

‫precision_config משמש לציון הגדרת הדיוק. הרמה קובעת אם החומרה תנסה ליצור עוד הוראות של שפת מכונה כדי לספק הדמיה מדויקת יותר של סוג הנתונים כשצריך (כלומר, הדמיה של f32 ב-TPU שתומך רק ב-bf16 matmuls). הערכים האפשריים הם DEFAULT,‏ HIGH,‏ HIGHEST. פרטים נוספים בקטעים בנושא MXU.

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

מידע על StableHLO זמין במאמר בנושא StableHLO - dot.

DotGeneral

מידע נוסף זמין במאמר בנושא XlaBuilder::DotGeneral.

DotGeneral(lhs, rhs, dimension_numbers, precision_config, preferred_element_type)

בדומה ל-Dot, אבל מאפשר לציין מספרי מאפיינים מקוצרים וקבוצתיים גם עבור lhs וגם עבור rhs.

הפונקציה DotGeneral מבצעת את סכום המכפלות על פני מאפיינים מצטמצמים שצוינו ב-dimension_numbers.

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

דוגמה עם מספרי מאפיינים מצטמצמים:

lhs = { {1.0, 2.0, 3.0},
        {4.0, 5.0, 6.0} }

rhs = { {1.0, 1.0, 1.0},
        {2.0, 2.0, 2.0} }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(1);
dnums.add_rhs_contracting_dimensions(1);

DotGeneral(lhs, rhs, dnums) -> { { 6.0, 12.0},
                                 {15.0, 30.0} }

מספרי המימדים המשויכים של חבילת הנתונים מ-lhs ו-rhs חייבים להיות באותם גדלים.

דוגמה עם מספרי מאפיינים של קבוצות (גודל הקבוצה 2, מטריצות 2x2):

lhs = { { {1.0, 2.0},
          {3.0, 4.0} },
        { {5.0, 6.0},
          {7.0, 8.0} } }

rhs = { { {1.0, 0.0},
          {0.0, 1.0} },
        { {1.0, 0.0},
          {0.0, 1.0} } }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(2);
dnums.add_rhs_contracting_dimensions(1);
dnums.add_lhs_batch_dimensions(0);
dnums.add_rhs_batch_dimensions(0);

DotGeneral(lhs, rhs, dnums) -> {
    { {1.0, 2.0},
      {3.0, 4.0} },
    { {5.0, 6.0},
      {7.0, 8.0} } }

מכאן נובע שמספר המימד שמתקבל מתחיל במימד של הקבוצה, אחר כך במימד lhs שלא מתכווץ ולא שייך לקבוצה, ולבסוף במימד rhs שלא מתכווץ ולא שייך לקבוצה.

‫precision_config משמש לציון הגדרת הדיוק. הערך קובע אם החומרה צריכה לנסות ליצור עוד הוראות של שפת מכונה כדי לספק הדמיה מדויקת יותר של dtype כשצריך (כלומר, הדמיה של f32 ב-TPU שתומך רק ב-bf16 matmuls). הערכים האפשריים הם DEFAULT,‏ HIGH,‏ HIGHEST. פרטים נוספים זמינים בקטעים בנושא MXU.

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

מידע על StableHLO זמין במאמר בנושא StableHLO – dot_general.

ScaledDot

מידע נוסף זמין במאמר בנושא XlaBuilder::ScaledDot.

ScaledDot(lhs, lhs_scale, rhs, rhs_scale, dimension_number, precision_config,preferred_element_type)

דומה ל-DotGeneral.

יוצרת פעולת מכפלה נקודתית עם שינוי קנה מידה עם אופרנדים lhs,‏ lhs_scale,‏ rhs ו-rhs_scale, עם מימדי כיווץ ואצווה שצוינו ב-dimension_numbers.

RaggedDot

מידע נוסף זמין במאמר בנושא XlaBuilder::RaggedDot.

לפירוט של RaggedDot חישובים, אפשר לעיין במאמר StableHLO - chlo.ragged_dot

DynamicReshape

מידע נוסף זמין במאמר בנושא XlaBuilder::DynamicReshape.

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

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

מידע על StableHLO זמין במאמר StableHLO – dynamic_reshape.

DynamicSlice

מידע נוסף זמין במאמר בנושא XlaBuilder::DynamicSlice.

הפונקציה DynamicSlice מחלצת מערך משנה ממערך הקלט במיקום הדינמי start_indices. הגודל של הפלח בכל מאפיין מועבר ב-size_indices, שמציין את נקודת הסיום של מרווחי פלחים בלעדיים בכל מאפיין: [התחלה, התחלה + גודל). הצורה של start_indices חייבת להיות חד-ממדית, עם גודל ממד ששווה למספר הממדים של operand.

DynamicSlice(operand, start_indices, slice_sizes)

כדי לחשב את אינדקסים של הפלחים בפועל, צריך להחיל את ההמרה הבאה על כל אינדקס i ב-[1, N) לפני יצירת הפלח:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - slice_sizes[i])

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

דוגמה חד-ממדית:

let a = {0.0, 1.0, 2.0, 3.0, 4.0};
let s = {2};

DynamicSlice(a, s, {2});
// Result: {2.0, 3.0}

דוגמה דו-ממדית:

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let s = {2, 1}

DynamicSlice(b, s, {2, 2});
//Result:
// { { 7.0,  8.0},
//   {10.0, 11.0} }

מידע על StableHLO זמין במאמר בנושא StableHLO – dynamic_slice.

DynamicUpdateSlice

מידע נוסף זמין במאמר בנושא XlaBuilder::DynamicUpdateSlice.

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

DynamicUpdateSlice(operand, update, start_indices)

כדי לחשב את אינדקסים של הפלחים בפועל, צריך להחיל את ההמרה הבאה על כל אינדקס i ב-[1, N) לפני יצירת הפלח:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - update.dimension_size[i])

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

דוגמה חד-ממדית:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
let u = {5.0, 6.0}
let s = {2}

DynamicUpdateSlice(a, u, s)
// Result: {0.0, 1.0, 5.0, 6.0, 4.0}

דוגמה דו-ממדית:

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let u =
{ {12.0, 13.0},
  {14.0, 15.0},
  {16.0, 17.0} }

let s = {1, 1}

DynamicUpdateSlice(b, u, s)
// Result:
// { {0.0,  1.0,  2.0},
//   {3.0, 12.0, 13.0},
//   {6.0, 14.0, 15.0},
//   {9.0, 16.0, 17.0} }

למידע על StableHLO, ראו StableHLO – dynamic_update_slice.

Erf

מידע נוסף זמין במאמר בנושא XlaBuilder::Erf.

פונקציית השגיאה x -> erf(x) לפי רכיב, כאשר:

\(\text{erf}(x) = \frac{2}{\sqrt{\pi} }\int_0^x e^{-t^2} \, dt\).

Erf(operand)

הפונקציה Erf תומכת גם בארגומנט האופציונלי result_accuracy:

Erf(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

תפוגה

מידע נוסף זמין במאמר בנושא XlaBuilder::Exp.

האקספוננט הטבעי של כל רכיב x -> e^x.

Exp(operand)

הפונקציה Exp תומכת גם בארגומנט האופציונלי result_accuracy:

Exp(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – exponential.

Expm1

מידע נוסף זמין במאמר בנושא XlaBuilder::Expm1.

הפונקציה הטבעית של כל רכיב פחות אחד x -> e^x - 1.

Expm1(operand)

הפונקציה Expm1 תומכת גם בארגומנט האופציונלי result_accuracy:

Expm1(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – exponential_minus_one.

FFT

מידע נוסף זמין במאמר בנושא XlaBuilder::Fft.

הפעולה XLA FFT מטמיעה את טרנספורמציות פורייה הישירות וההפוכות עבור קלט/פלט ממשי ומרוכב. יש תמיכה ב-FFT רב-ממדי עם עד 3 צירים.

Fft(operand, ftt_type, fft_length)

מידע על StableHLO זמין במאמר בנושא StableHLO – fft.

Multidimensional FFT

אם מציינים יותר מ-1, הפעולה שמתבצעת שקולה להחלה של סדרת פעולות FFT על כל אחד מהצירים הפנימיים ביותר. שימו לב שבמקרים של המרה ממספרים ממשיים למספרים מרוכבים והמרה ממספרים מרוכבים למספרים ממשיים, ההמרה של הציר הפנימי ביותר מתבצעת (למעשה) ראשונה (RFFT; אחרונה ב-IRFFT), ולכן הציר הפנימי ביותר הוא זה שמשנה את הגודל. ההמרות של הצירים האחרים יהיו ממספרים מרוכבים למספרים מרוכבים.fft_length

פרטי ההטמעה

‫CPU FFT נתמך על ידי TensorFFT של Eigen. ‫GPU FFT משתמש ב-cuFFT.

קומה

מידע נוסף זמין במאמר בנושא XlaBuilder::Floor.

הפונקציה floor לפי רכיבים x -> ⌊x⌋.

Floor(operand)

מידע על StableHLO זמין במאמר בנושא StableHLO - floor.

פיוז'ן

מידע נוסף זמין במאמר בנושא HloInstruction::CreateFusion.

הפעולה Fusion מייצגת הוראות HLO ומשמשת כפרימיטיב ב-HLO. יכול להיות שהאופציה הזו תופיע בפריקות של HLO, אבל היא לא מיועדת לבנייה ידנית על ידי משתמשי קצה.

איסוף

הפעולה gather של XLA מחברת כמה פרוסות (כל פרוסה בהיסט שונה בזמן הריצה) של מערך קלט.

מידע על StableHLO זמין במאמר StableHLO - gather.

סמנטיקה כללית

מידע נוסף זמין במאמר בנושא XlaBuilder::Gather. תיאור פשוט יותר מופיע בקטע 'תיאור לא רשמי' שבהמשך.

gather(operand, start_indices, dimension_numbers, slice_sizes, indices_are_sorted)

לנוחותכם, אנחנו מתייגים את המאפיינים במערך הפלט שלא ב-offset_dims כ-batch_dims.

הפלט הוא מערך עם batch_dims.size + offset_dims.size ממדים.

הערך operand.rank חייב להיות שווה לסכום של offset_dims.size ושל collapsed_slice_dims.size. בנוסף, הערך של slice_sizes.size צריך להיות שווה לערך של operand.rank.

אם index_vector_dim שווה ל-start_indices.rank, אנחנו מתייחסים באופן מרומז ל-start_indices כאל טנזור עם מימד 1 (כלומר, אם הצורה של start_indices היא [6,7] ו-index_vector_dim הוא 2, אנחנו מתייחסים באופן מרומז לצורה של start_indices כאל [6,7,1]).

הגבולות של מערך הפלט לאורך המימד i מחושבים באופן הבא:

1. אם i מופיע ב-batch_dims (כלומר, שווה ל-batch_dims[k] עבור k כלשהו), נבחר את גבולות המאפיין המתאימים מתוך start_indices.shape, ונדלג על index_vector_dim (כלומר, נבחר start_indices.shape.dims[k] אם k < index_vector_dim, ואחרת נבחר start_indices.shape.dims[k+1]).

2. אם i מופיע ב-offset_dims (כלומר, שווה ל-offset_dims[k] עבור ערך מסוים של k), אנחנו בוחרים את הגבול המתאים מתוך slice_sizes אחרי התחשבות ב-collapsed_slice_dims (כלומר, אנחנו בוחרים ב-adjusted_slice_sizes[k] כאשר adjusted_slice_sizes הוא slice_sizes עם הגבולות במדדים collapsed_slice_dims שהוסרו).

באופן רשמי, אינדקס האופרנד In שמתאים לאינדקס פלט נתון Out מחושב כך:

1. ‫Let G = { Out[k] for k in batch_dims }. Use G to slice out a vector S such that S[i] = start_indices[Combine(G, i)] where Combine(A, b) inserts b at position index_vector_dim into A. שימו לב שההגדרה הזו ברורה גם אם G ריק: אם G ריק, אז S = start_indices.

2. יצירת אינדקס התחלתי, Sin, לתוך operand באמצעות S על ידי פיזור S באמצעות start_index_map. באופן ספציפי יותר:

   1. ‪Sin[start_index_map[k]] = S[k] if k < start_index_map.size.

   2. ‫Sin[_] = 0 אחרת.

3. יוצרים אינדקס Oin לתוך operand על ידי פיזור האינדקסים במאפייני ההיסט ב-Out בהתאם לערכים שמוגדרים ב-collapsed_slice_dims. באופן ספציפי יותר:

   1. ‫Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] if k < offset_dims.size (remapped_offset_dims is defined below).

   2. ‫Oin[_] = 0 אחרת.

4. ‫In הוא Oin + Sin כאשר + הוא חיבור של כל רכיב בנפרד.

‫remapped_offset_dims היא פונקציה מונוטונית עם תחום [0,‏ offset_dims.size) וטווח [0, ‏ operand.rank) \ collapsed_slice_dims. לדוגמה, אם offset_dims.size הוא 4,‏ operand.rank הוא 6 ו-collapsed_slice_dims הוא {0, 2}, אז remapped_offset_dims הוא {0→1,‏ 1→3, ‏ 2→4, ‏ 3→5}.

אם הערך של indices_are_sorted הוא true,‏ XLA יכול להניח שהמשתמש מיין את הערכים של start_indices (בסדר עולה, אחרי פיזור הערכים לפי start_index_map). אם הם לא ממוינים, הסמנטיקה מוגדרת בהטמעה.

תיאור לא רשמי ודוגמאות

באופן לא רשמי, כל אינדקס Out במערך הפלט תואם לאלמנט E במערך האופרנד, והוא מחושב באופן הבא:

• אנחנו משתמשים במאפייני האצווה ב-Out כדי לחפש אינדקס התחלתי מ-start_indices.

• אנחנו משתמשים ב-start_index_map כדי למפות את אינדקס ההתחלה (שהגודל שלו יכול להיות קטן מ-operand.rank) לאינדקס התחלה 'מלא' ב-operand.

• אנחנו יוצרים פרוסה באופן דינמי בגודל slice_sizes באמצעות אינדקס ההתחלה המלא.

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

• אנחנו משתמשים בממדי ההזחה ב-Out כדי ליצור אינדקס בפלח הזה ולקבל את רכיב הקלט, E, שמתאים לאינדקס הפלט Out.

הערך של index_vector_dim מוגדר כ-start_indices.rank – 1 בכל הדוגמאות הבאות. ערכים מעניינים יותר של index_vector_dim לא משנים את הפעולה באופן מהותי, אבל הופכים את הייצוג החזותי למסורבל יותר.

כדי להבין איך כל מה שצוין למעלה משתלב, נסתכל על דוגמה שבה נאספים 5 פרוסים של צורה [8,6] ממערך [16,11]. המיקום של פרוסה במערך [16,11] יכול להיות מיוצג כווקטור אינדקס בצורה S64[2], כך שקבוצה של 5 מיקומים יכולה להיות מיוצגת כמערך S64[5,2].

אפשר לתאר את ההתנהגות של פעולת האיסוף כשינוי אינדקס שלוקח [G,O0,O1], אינדקס בצורת הפלט וממפה אותו לרכיב במערך הקלט באופן הבא:

קודם בוחרים וקטור (X,Y) ממערך האינדקסים של הפעולה gather באמצעות G. האלמנט במערך הפלט באינדקס [G,O0,O1] הוא האלמנט במערך הקלט באינדקס [X+O0,Y+O1].

‫slice_sizes הוא [8,6], שקובע את הטווח של O₀ ו-O₁, והטווח הזה קובע את הגבולות של הפרוסה.

פעולת האיסוף הזו פועלת כפרוסת נתונים דינמית של אצווה עם G כממד האצווה.

יכול להיות שמערך האינדקסים יהיה רב-ממדי. לדוגמה, גרסה כללית יותר של הדוגמה שלמעלה שמשתמשת במערך 'אינדקסים לאיסוף' בצורה [4,5,2] תתרגם אינדקסים באופן הבא:

שוב, הפעולה הזו משמשת כפלח דינמי של קבוצה G0 וG1 כמאפייני הקבוצה. גודל הפלח עדיין [8,6].

הפעולה gather ב-XLA מכלילה את הסמנטיקה הלא פורמלית שמתוארת למעלה בדרכים הבאות:

1. אנחנו יכולים להגדיר אילו מימדים בצורת הפלט הם מימדי ההיסט (מימדים שמכילים O0, O1 בדוגמה האחרונה). מימדי אצווה הפלט (מימדים שמכילים G0, G1 בדוגמה האחרונה) מוגדרים כמימדי הפלט שלא מוגדרים כמימדי היסט.

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

3. יכול להיות שלפרוסה שחולצה מהמערך Gather Indices (מספרים (X, Y) בדוגמה האחרונה) יהיו פחות רכיבים ממספר המימדים של מערך הקלט, ומיפוי מפורש קובע איך צריך להרחיב את האינדקס כדי שיהיה לו אותו מספר מימדים כמו לקלט.

כדוגמה אחרונה, אנחנו משתמשים ב-(2) וב-(3) כדי להטמיע את tf.gather_nd:

הפרמטרים G0 ו-G1 משמשים לחיתוך אינדקס התחלתי ממערך האינדקסים של הפעולה gather כרגיל, אלא שהאינדקס ההתחלתי מכיל רק רכיב אחד, X. באופן דומה, יש רק אינדקס אחד של היסט בפלט עם הערך O0. עם זאת, לפני השימוש בהם כאינדקסים במערך הקלט, הם מורחבים בהתאם ל-Gather Index Mapping (start_index_map בתיאור הפורמלי) ול-Offset Mapping (remapped_offset_dims בתיאור הפורמלי) ל-[X,0] ול-[0,O0] בהתאמה, וכך מתקבל [X,O0]. במילים אחרות, אינדקס הפלט [G0,G1,O0] ממופה לאינדקס הקלט [GatherIndices[G0,G1,0],O0], וכך מתקבלת הסמנטיקה של tf.gather_nd.

מספר הפנייה שלך הוא slice_sizes.[1,11] באופן אינטואיטיבי, המשמעות היא שכל אינדקס X במערך האינדקסים של הפונקציה gather בוחר שורה שלמה, והתוצאה היא שרשור של כל השורות האלה.

GetDimensionSize

מידע נוסף זמין במאמר בנושא XlaBuilder::GetDimensionSize.

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

GetDimensionSize(operand, dimension)

מידע על StableHLO זמין במאמר בנושא StableHLO – get_dimension_size.

GetTupleElement

מידע נוסף זמין במאמר בנושא XlaBuilder::GetTupleElement.

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

הערך חייב להיות קבוע בזמן ההידור, כדי שהסקת הצורה תוכל לקבוע את סוג הערך שמתקבל.

זה דומה ל-std::get<int N>(t) ב-C++. באופן עקרוני:

let v: f32[10] = f32[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
let s: s32 = 5;
let t: (f32[10], s32) = tuple(v, s);
let element_1: s32 = gettupleelement(t, 1); // Inferred shape matches s32.

מידע נוסף מופיע במאמר tf.tuple.

GetTupleElement(tuple_data, index)

מידע על StableHLO זמין במאמר בנושא StableHLO – get_tuple_element.

Imag

מידע נוסף זמין במאמר בנושא XlaBuilder::Imag.

החלק המדומה של צורה מרוכבת (או ממשית) לפי אלמנט. x -> imag(x). אם האופרנד הוא מסוג נקודה צפה, הפונקציה מחזירה 0.

Imag(operand)

מידע על StableHLO זמין במאמר StableHLO - imag.

בתוך הפיד

מידע נוסף זמין במאמר בנושא XlaBuilder::Infeed.

Infeed(shape, config)

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

result1 = while (condition, init = init_value) {
  Infeed(shape)
  }

result2 = while (condition, init = result1) {
  Infeed(shape)
  }

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

מידע על StableHLO זמין במאמר StableHLO - infeed.

Iota

מידע נוסף זמין במאמר בנושא XlaBuilder::Iota.

Iota(shape, iota_dimension)

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

לדוגמה, הפקודה Iota(s32[4, 8], 0) מחזירה

[[0, 0, 0, 0, 0, 0, 0, 0 ],
 [1, 1, 1, 1, 1, 1, 1, 1 ],
 [2, 2, 2, 2, 2, 2, 2, 2 ],
 [3, 3, 3, 3, 3, 3, 3, 3 ]]

אפשרות החזרה במחיר Iota(s32[4, 8], 1)

[[0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ]]

מידע על StableHLO זמין במאמר StableHLO – iota.

IsFinite

מידע נוסף זמין במאמר בנושא XlaBuilder::IsFinite.

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

IsFinite(operand)

מידע על StableHLO זמין במאמר StableHLO – is_finite.

יומן

מידע נוסף זמין במאמר בנושא XlaBuilder::Log.

לוגריתם טבעי של כל רכיב x -> ln(x).

Log(operand)

הפונקציה Log תומכת גם בארגומנט האופציונלי result_accuracy:

Log(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – יומן.

Log1p

מידע נוסף זמין במאמר בנושא XlaBuilder::Log1p.

לוגריתם טבעי מוזז לפי רכיב x -> ln(1+x).

Log1p(operand)

הפונקציה Log1p תומכת גם בארגומנט האופציונלי result_accuracy:

Log1p(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – log_plus_one.

לוגיסטיקה

מידע נוסף זמין במאמר בנושא XlaBuilder::Logistic.

חישוב פונקציה לוגיסטית לפי רכיבים x -> logistic(x).

Logistic(operand)

הפונקציה Logistic תומכת גם בארגומנט result_accuracy האופציונלי:

Logistic(operand, result_accuracy)

מידע נוסף על result_accuracy זמין במאמר דיוק התוצאות.

מידע על StableHLO זמין במאמר StableHLO – לוגיסטיקה.

מפה

מידע נוסף זמין במאמר בנושא XlaBuilder::Map.

Map(operands..., computation, dimensions)

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

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

לדוגמה: Map(op1, op2, op3, computation, par1) ממפה את elem_out <- computation(elem1, elem2, elem3, par1) בכל אינדקס (רב-ממדי) במערכי הקלט כדי ליצור את מערך הפלט.

מידע על StableHLO זמין במאמר StableHLO – map.

מקסימום

מידע נוסף זמין במאמר בנושא XlaBuilder::Max.

מבצעת פעולת מקסימום לפי רכיבים בטנסורים lhs ו-rhs.

Max(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בשידור בממדים שונים ל-Max:

Max(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

למידע על StableHLO, ראו StableHLO – maximum.

מינימום

מידע נוסף זמין במאמר בנושא XlaBuilder::Min.

מבצעת פעולת min לפי רכיבים ב-lhs וב-rhs.

Min(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בשידור בממדים שונים עבור Min:

Min(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO – מינימום.

Mul

מידע נוסף זמין במאמר בנושא XlaBuilder::Mul.

מבצע מכפלה של כל רכיב ב-lhs עם הרכיב התואם ב-rhs.

Mul(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בשידור עם ממדים שונים עבור Mul:

Mul(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO – multiply.

Neg

מידע נוסף זמין במאמר בנושא XlaBuilder::Neg.

שלילה של כל רכיב x -> -x.

Neg(operand)

מידע על StableHLO זמין במאמר בנושא StableHLO – negate

לא

מידע נוסף זמין במאמר בנושא XlaBuilder::Not.

שלילה לוגית לפי רכיבים x -> !(x).

Not(operand)

מידע על StableHLO זמין במאמר בנושא StableHLO - not.

OptimizationBarrier

מידע נוסף זמין במאמר בנושא XlaBuilder::OptimizationBarrier.

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

OptimizationBarrier(operand)

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

מידע על StableHLO זמין במאמר StableHLO - optimization_barrier.

או

מידע נוסף זמין במאמר בנושא XlaBuilder::Or.

מבצעת פעולת OR בין כל רכיב ב-lhs לבין הרכיב התואם ב-rhs .

Or(lhs, rhs)

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

קיימת וריאציה חלופית עם תמיכה בשידור עם ממדים שונים עבור Or:

Or(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO - or.

מחוץ לפיד

מידע נוסף זמין במאמר בנושא XlaBuilder::Outfeed.

כתיבת קלט ל-outfeed.

Outfeed(operand, shape_with_layout, outfeed_config)

‫shape_with_layout מעביר את הצורה שרוצים להוציא.

מידע על StableHLO זמין במאמר בנושא StableHLO - outfeed.

רפידה

מידע נוסף זמין במאמר בנושא XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

הפונקציה מרחיבה את המערך operand שצוין על ידי הוספת ערכי מילוי מסביב למערך וגם בין האלמנטים של המערך עם הערך padding_value שצוין. ‫padding_config מציין את כמות השוליים בקצה ואת השוליים הפנימיים לכל מימד.

‫PaddingConfig הוא שדה חוזר של PaddingConfigDimension, שמכיל שלושה שדות לכל מאפיין: edge_padding_low,‏ edge_padding_high ו-interior_padding.

‫edge_padding_low ו-edge_padding_high מציינים את כמות הריפוד שנוספה בקצה הנמוך (ליד אינדקס 0) ובקצה הגבוה (ליד האינדקס הגבוה ביותר) של כל מימד, בהתאמה. כמות הריפוד בקצה יכולה להיות שלילית – הערך המוחלט של ריפוד שלילי מציין את מספר הרכיבים שיש להסיר מהמימד שצוין.

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

הפעולה הזו לא משפיעה אם כל זוגות הריפוד של הקצוות הם (0, 0) וכל ערכי הריפוד הפנימיים הם 0. באיור שלמטה מוצגות דוגמאות לערכים שונים של edge_padding ו-interior_padding במערך דו-ממדי.

מידע על StableHLO זמין במאמר StableHLO - pad.

פרמטר

מידע נוסף זמין במאמר בנושא XlaBuilder::Parameter.

‫Parameter מייצג ארגומנט שמוזן לחישוב.

PartitionID

מידע נוסף זמין במאמר בנושא XlaBuilder::BuildPartitionId.

יוצר partition_id של התהליך הנוכחי.

PartitionID(shape)

המחרוזת PartitionID עשויה להופיע בקובצי dump של HLO, אבל היא לא מיועדת ליצירה ידנית על ידי משתמשי קצה.

מידע על StableHLO זמין במאמר בנושא StableHLO – partition_id.

PopulationCount

מידע נוסף זמין במאמר בנושא XlaBuilder::PopulationCount.

מחשבת את מספר הביטים שמוגדרים בכל רכיב של operand.

PopulationCount(operand)

למידע על StableHLO, ראו StableHLO - popcnt.

Pow

מידע נוסף זמין במאמר בנושא XlaBuilder::Pow.

מבצע העלאה בחזקה של lhs בחזקת rhs, לפי רכיבים.

Pow(lhs, rhs)

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

קיימת גרסה חלופית עם תמיכה בשידור בממדים שונים ל-Pow:

Pow(lhs,rhs, broadcast_dimensions)

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

האופרנד הנוסף broadcast_dimensions הוא פרוסת מספרים שלמים שמציינת את המימדים שבהם יש להשתמש לשידור האופרנדים. הסמנטיקה מתוארת בפירוט בדף השידור.

מידע על StableHLO זמין במאמר StableHLO – power.

Real

מידע נוסף זמין במאמר בנושא XlaBuilder::Real.

החלק הממשי של צורה מרוכבת (או ממשי) לפי אלמנט. x -> real(x). אם האופרנד הוא מסוג נקודה צפה, הפונקציה Real מחזירה את אותו ערך.

Real(operand)

מידע על StableHLO זמין במאמר בנושא StableHLO - real.

Recv

מידע נוסף זמין במאמר בנושא XlaBuilder::Recv.

‫Recv,‏ RecvWithTokens ו-RecvToHost הם פעולות שמשמשות כפרימיטיבים של תקשורת ב-HLO. הפעולות האלה מופיעות בדרך כלל ב-dumps של HLO כחלק מהעברת קלט/פלט ברמה נמוכה או העברה מקושרת למכשיר אחר, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

Recv(shape, handle)

מקבל נתונים מהצורה שצוינה מSend הוראה בחישוב אחר שמשתמש באותו שם ערוץ. מחזיר XlaOp עבור הנתונים שהתקבלו.

מידע על StableHLO זמין במאמר StableHLO – recv.

RecvDone

מידע נוסף זמין במאמרים בנושא HloInstruction::CreateRecv וHloInstruction::CreateRecvDone.

בדומה ל-Send, ה-API של הלקוח של פעולת Recv מייצג תקשורת סינכרונית. עם זאת, ההוראה מפורקת באופן פנימי ל-2 הוראות HLO‏ (Recv ו-RecvDone) כדי לאפשר העברות נתונים אסינכרוניות.

Recv(const Shape& shape, int64 channel_id)

מקצה משאבים שנדרשים לקבלת נתונים מהוראה Send עם אותו channel_id. הפונקציה מחזירה הקשר למשאבים שהוקצו, שמשמשים בהוראה הבאה RecvDone להמתנה לסיום העברת הנתונים. ההקשר הוא טאפל של {מאגר לקליטת נתונים (צורה), מזהה בקשה (U32)} ואפשר להשתמש בו רק באמצעות הוראה RecvDone.

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

הקטנה

מידע נוסף זמין במאמר בנושא XlaBuilder::Reduce.

מחיל פונקציית צמצום על מערך אחד או יותר במקביל.

Reduce(operands..., init_values..., computation, dimensions_to_reduce)

כאשר:

• הערך של n חייב להיות גדול מ-1 או שווה לו.
• החישוב צריך להיות אסוציאטיבי בערך (ראו בהמשך).
• לכל מערכי הקלט צריכים להיות אותם ממדים.
• כל הערכים הראשוניים צריכים ליצור זהות תחת computation.
• אם N = 1, אז Collate(T) הוא T.
• אם N > 1, Collate(T_0, ..., T_{N-1}) הוא טאפל של N רכיבים מסוג T.

הפעולה הזו מצמצמת מימד אחד או יותר של כל מערך קלט לערכים סקלריים. מספר המימדים של כל מערך שמוחזר הוא number_of_dimensions(operand) - len(dimensions). הפלט של הפעולה הוא Collate(Q_0, ..., Q_N), כאשר Q_i הוא מערך מסוג T_i, והממדים שלו מתוארים בהמשך.

מותר לשרתי קצה שונים לשייך מחדש את חישוב הצמצום. זה יכול להוביל להבדלים מספריים, כי חלק מפונקציות הצמצום כמו חיבור לא אסוציאטיביות עבור נקודה צפה (floating-point). עם זאת, אם טווח הנתונים מוגבל, חיבור של נקודה צפה (floating-point) קרוב מספיק לאסוציאטיביות לרוב השימושים המעשיים.

מידע על StableHLO זמין במאמר בנושא StableHLO – reduce.

דוגמאות

כשמצמצמים לאורך מימד אחד במערך חד-ממדי יחיד עם הערכים [10, 11, 12, 13], עם פונקציית הצמצום f (זהו computation), אפשר לחשב את זה כך:

f(10, f(11, f(12, f(init_value, 13)))

אבל יש גם הרבה אפשרויות אחרות, למשל:

f(init_value, f(f(10, f(init_value, 11)), f(f(init_value, 12), f(init_value, 13))))

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

result_shape <- remove all dims in dimensions from operand_shape

# Iterate over all elements in result_shape. The number of r's here is equal
# to the number of dimensions of the result.
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

  # Iterate over all the reduction dimensions
  for d0 in range(dimensions[0]), d1 in range(dimensions[1]), ...:
    # Increment the result element with the value of the operand's element.
    # The index of the operand's element is constructed from all ri's and di's
    # in the right order (by construction ri's and di's together index over the
    # whole operand shape).
    result[r0, r1...] += operand[ri... di]

דוגמה לצמצום מערך דו-ממדי (מטריצה). לצורה יש 2 מימדים, מימד 0 בגודל 2 ומימד 1 בגודל 3:

תוצאות של צמצום מימדים 0 או 1 באמצעות פונקציית 'הוספה':

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

דוגמה מורכבת יותר: מערך תלת-ממדי. מספר המאפיינים הוא 3, מאפיין 0 בגודל 4, מאפיין 1 בגודל 2 ומאפיין 2 בגודל 3. כדי לפשט את הדברים, הערכים 1 עד 6 משוכפלים במאפיין 0.

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

|  4   8  12 |
| 16  20  24 |

אם נצמצם את מאפיין 2, נקבל גם מערך דו-ממדי שבו כל הערכים לאורך מאפיין 2 קופלו לערך סקלרי:

| 6  15 |
| 6  15 |
| 6  15 |
| 6  15 |

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

אפשר גם לצמצם כמה מאפיינים. הוספה של מאפיינים מצמצמים 0 ו-1 יוצרת את המערך החד-ממדי [20, 28, 36].

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

Variadic Reduce

כשמשתמשים ב-N > 1, הפונקציה reduce קצת יותר מורכבת, כי היא מופעלת בו-זמנית על כל ערכי הקלט. האופרנדים מסופקים לחישוב בסדר הבא:

• הפעלת ערך מופחת לאופרנד הראשון
• ...
• הפעלת ערך מופחת לאופרנד ה-N
• ערך הקלט של האופרנד הראשון
• ...
• ערך הקלט של האופרנד ה-N

לדוגמה, נניח שיש לנו את פונקציית הצמצום הבאה, שאפשר להשתמש בה כדי לחשב את המקסימום ואת argmax של מערך חד-ממדי במקביל:

f: (Float, Int, Float, Int) -> Float, Int
f(max, argmax, value, index):
  if value >= max:
    return (value, index)
  else:
    return (max, argmax)

עבור מערכי קלט חד-ממדיים V = Float[N], K = Int[N] וערכי אתחול I_V = Float, I_K = Int, התוצאה f_(N-1) של צמצום המערך לאורך מימד הקלט היחיד שווה לשימוש הרקורסיבי הבא:

f_0 = f(I_V, I_K, V_0, K_0)
f_1 = f(f_0.first, f_0.second, V_1, K_1)
...
f_(N-1) = f(f_(N-2).first, f_(N-2).second, V_(N-1), K_(N-1))

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

ReducePrecision

מידע נוסף זמין במאמר בנושא XlaBuilder::ReducePrecision.

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

ReducePrecision(operand, exponent_bits, mantissa_bits)

התוצאה היא מערך מסוג T. ערכי הקלט מעוגלים לערך הקרוב ביותר שאפשר לייצג עם מספר הביטים של המנטיסה שצוין (באמצעות סמנטיקה של 'עיגול למספר הזוגי הקרוב ביותר'), וכל הערכים שחורגים מהטווח שצוין על ידי מספר הביטים של המעריך מוצמדים לאינסוף חיובי או שלילי. הערכים של NaN נשמרים, אבל יכול להיות שהם יומרו לערכים קנוניים של NaN.

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

מידע על StableHLO זמין במאמר בנושא StableHLO – reduce_precision.

ReduceScatter

מידע נוסף זמין במאמר בנושא XlaBuilder::ReduceScatter.

‫ReduceScatter היא פעולה קולקטיבית שמבצעת למעשה AllReduce ואז מפזרת את התוצאה על ידי פיצול שלה ל-shard_count בלוקים לאורך scatter_dimension והרפליקה i בקבוצת הרפליקות מקבלת את ה-shard ith.

ReduceScatter(operand, computation, scatter_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• אם operand הוא טאפל של מערכים, הפעולה reduce-scatter מתבצעת על כל רכיב בטאפל.
• ‫replica_groups היא רשימה של קבוצות רפליקות שביניהן מתבצעת הפעולה (אפשר לאחזר את מזהה הרפליקה של הרפליקה הנוכחית באמצעות ReplicaId). הסדר של הרפליקות בכל קבוצה קובע את הסדר שבו התוצאה של פעולת ה-all-reduce תפוזר. replica_groups חייבת להיות ריקה (במקרה כזה כל הרפליקות שייכות לקבוצה אחת), או להכיל את אותו מספר של רכיבים כמספר הרפליקות. אם יש יותר מקבוצת רפליקות אחת, כולן חייבות להיות באותו גודל. לדוגמה, replica_groups = {0, 2}, {1, 3} מבצעת פעולת צמצום בין הרפליקות 0 ו-2, ובין 1 ו-3, ואז מפזרת את התוצאה.
• ‫shard_count הוא הגודל של כל קבוצת שכפולים. אנחנו צריכים את זה במקרים שבהם replica_groups ריק. אם replica_groups לא ריק, shard_count חייב להיות שווה לגודל של כל קבוצת שכפולים.
• ‫channel_id משמש לתקשורת בין מודולים: רק פעולות עם אותו channel_id יכולות לתקשר זו עם זו.reduce-scatter
• layout מידע נוסף על פריסות זמין במאמר xla::shapes.
• ‫use_global_device_ids הוא דגל שצוין על ידי המשתמש. כש-false(ברירת מחדל) המספרים ב-replica_groups הם ReplicaId כש-true המספרים ב-replica_groups מייצגים מזהה גלובלי של (ReplicaID*partition_count + partition_id). לדוגמה:
  • עם 2 עותקים ו-4 מחיצות,
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • ‫group[0] = (0,0), (0,1), (1,0), (1,1)
  • ‫group[1] = (0,2), (0,3), (1,2), (1,3)
  • כאשר כל זוג הוא (replica_id, partition_id).

צורת הפלט היא צורת הקלט עם scatter_dimension שהוקטן פי shard_count. לדוגמה, אם יש שני עותקים והאופרנד הוא [1.0, 2.25] ו-[3.0, 5.25] בהתאמה בשני העותקים, אז ערך הפלט מהפעולה הזו שבה scatter_dim הוא 0 יהיה [4.0] בעותק הראשון ו-[7.5] בעותק השני.

מידע על StableHLO זמין במאמר בנושא StableHLO – reduce_scatter.

ReduceScatter - Example 1 - StableHLO

בדוגמה שלמעלה, יש 2 רפליקות שמשתתפות ב-ReduceScatter. בכל רפליקה, לאופרנד יש צורה f32[2,4]. מתבצעת פעולת all-reduce (סכום) בין העותקים, ונוצר ערך מופחת בצורה f32[2,4] בכל עותק. לאחר מכן, הערך המצומצם הזה מפולח ל-2 חלקים לאורך מאפיין 1, כך שלכל חלק יש צורה f32[2,2]. כל רפליקה בקבוצת התהליכים מקבלת את החלק שמתאים למיקום שלה בקבוצה. כתוצאה מכך, הפלט בכל עותק הוא בצורה f32[2,2].

ReduceWindow

מידע נוסף זמין במאמר בנושא XlaBuilder::ReduceWindow.

הפונקציה מחילה פונקציית צמצום על כל הרכיבים בכל חלון של רצף של מערכים רב-ממדיים בגודל N, ומפיקה מערך רב-ממדי יחיד או טופל של N מערכים רב-ממדיים כפלט. לכל מערך פלט יש את אותו מספר של רכיבים כמו מספר המיקומים התקינים של החלון. שכבת איגום יכולה להיות מיוצגת כ-ReduceWindow. בדומה ל-Reduce, הערך של computation שמוחל תמיד מועבר ל-init_values בצד ימין.

ReduceWindow(operands..., init_values..., computation, window_dimensions, window_strides, padding)

כאשר:

• הערך של n חייב להיות גדול מ-1 או שווה לו.
• לכל מערכי הקלט צריכים להיות אותם ממדים.
• אם N = 1, אז Collate(T) הוא T.
• אם N > 1, Collate(T_0, ..., T_{N-1}) הוא טאפל של N רכיבים מסוג (T0,...T{N-1}).

מידע על StableHLO זמין במאמר בנושא StableHLO – reduce_window.

‫ReduceWindow – דוגמה 1

הקלט הוא מטריצה בגודל [4x6], וגם window_dimensions וגם window_stride_dimensions הם [2x3].

// Create a computation for the reduction (maximum).
XlaComputation max;
{
  XlaBuilder builder(client_, "max");
  auto y = builder.Parameter(0, ShapeUtil::MakeShape(F32, {}), "y");
  auto x = builder.Parameter(1, ShapeUtil::MakeShape(F32, {}), "x");
  builder.Max(y, x);
  max = builder.Build().value();
}

// Create a ReduceWindow computation with the max reduction computation.
XlaBuilder builder(client_, "reduce_window_2x3");
auto shape = ShapeUtil::MakeShape(F32, {4, 6});
auto input = builder.Parameter(0, shape, "input");
builder.ReduceWindow(
    input,
    /*init_val=*/builder.ConstantLiteral(LiteralUtil::MinValue(F32)),
    *max,
    /*window_dimensions=*/{2, 3},
    /*window_stride_dimensions=*/{2, 3},
    Padding::kValid);