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

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

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

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

Abs

מידע נוסף זמין במאמר בנושא 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 – הוספה.

AddDependency

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

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

AfterAll

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

הפונקציה AfterAll מקבלת מספר משתנה של טוקנים ומפיקה טוקן יחיד. אסימונים (tokens) הם סוגים פרימיטיביים שאפשר להעביר בין פעולות עם תופעות לוואי כדי לאכוף סדר. אפשר להשתמש ב-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 משמש לתקשורת בין מודולים: רק פעולות עם אותו channel_id יכולות לתקשר זו עם זו.all-gather
• 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 משמש לתקשורת בין מודולים: רק פעולות עם אותו channel_id יכולות לתקשר זו עם זו.all-reduce
• ‫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]. ארבעת החלקים מפוזרים בין כל הליבות. לאחר מכן, כל ליבה משרשרת את החלקים שהתקבלו לאורך מאפיין 0, לפי הסדר של ליבה 0 עד 4. לכן, הפלט בכל ליבה הוא בצורה f32[16,4].

AllToAll - Example 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]+input_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] שבהם ragged-all-to-all עשוי לשלוח עד 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 - and.

אסינכרוני

ראו גם 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 (feature_index הוא האינדקס של המאפיין feature ב-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 (feature_index הוא האינדקס של המאפיין feature ב-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. מכיוון שהפעולה כולה היא שידור ביט (bitcast) ולא משנה את הבייטים הבסיסיים, הצורה של רכיב הפלט צריכה להשתנות. עבור 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. לאחר מכן, מתבצע שידור (broadcast) של המימד המנוון לאורך המימדים המנוונים האלה כדי להגיע לצורת הפלט. הסמנטיקה מתוארת בפירוט בדף השידור.

התקשרות

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

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

Call(computation, operands...)

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

CompositeCall

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

מכיל פעולה שמורכבת מפעולות אחרות של StableHLO, מקבלת קלט ו-composite_attributes ומפיקה תוצאות. הסמנטיקה של הפעולה מיושמת על ידי מאפיין הפירוק. אפשר להחליף את הפעולה המורכבת בפירוק שלה בלי לשנות את הסמנטיקה של התוכנית. במקרים שבהם הטמעה של הפירוק לא מספקת את אותה סמנטיקת פעולה, עדיף להשתמש ב-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.

פונקציית התקרה (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.

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

CollectiveBroadcast(operand, replica_groups, channel_id)

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

CollectivePermute

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

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

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

שימו לב להגבלות הבאות על 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(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 קבוצות, ועושים את אותו הדבר לגבי תכונות הפלט. לאחר מכן, לכל אחת מהקבוצות האלה אנחנו מבצעים קונבולוציות בזוגות ומשרשרים את הפלט לאורך הממד של תכונת הפלט. הסמנטיקה התפעולית של כל המאפיינים האחרים (מאפיינים מרחביים ומאפיינים של תכונות) נשארת ללא שינוי.

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

כדי לתאר מה עושה קונבולוציה, נתייחס לקונבולוציה דו-ממדית ונבחר כמה קואורדינטות קבועות 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 משמש לציון הגדרת הדיוק. הרמה קובעת אם החומרה צריכה לנסות ליצור עוד הוראות של קוד מכונה כדי לספק הדמיה מדויקת יותר של dtype כשצריך (כלומר, הדמיה של f32 ב-TPU שתומך רק ב-bf16 matmuls). הערכים יכולים להיות DEFAULT, ‏ HIGH, ‏ HIGHEST. פרטים נוספים בקטעים של MXU.

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

מידע על 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 – divide.

דומיין

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

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

נקודה

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

Dot(lhs, rhs, precision_config, preferred_element_type)

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

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

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

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

מידע על 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 ממליץ על סוג הצבירה לפעולה הנתונה, אבל אין בכך ערובה. כך אפשר לצבור נתונים בחלק מהעורפים של החומרה בסוג אחר ולהמיר אותם לסוג הפלט המועדף.

מידע על 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 על כל אחד מהצירים הפנימיים ביותר.fft_length שימו לב: במקרים של real->complex ו-complex->real, הטרנספורמציה של הציר הפנימי ביותר מתבצעת (למעשה) קודם (RFFT; אחרון ב-IRFFT), ולכן הציר הפנימי ביותר הוא זה שגודלו משתנה. הטרנספורמציות האחרות של הצירים יהיו מורכבות->מורכבות.

פרטי ההטמעה

ה-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].

אפשר לתאר את אופן הפעולה של gather כטרנספורמציה של אינדקס שלוקחת [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 היא למעשה פעולה ללא פעולה (no-op) והיא ממשיכה בלי לקרוא נתונים מה-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(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.

פאו

מידע נוסף זמין במאמר בנושא 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. הפעולות האלה מופיעות בדרך כלל בפריקות של HLO כחלק מהעברת קלט/פלט ברמה נמוכה או העברה בין מכשירים, אבל הן לא מיועדות לבנייה ידנית על ידי משתמשי קצה.

Recv(shape, handle)

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

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

RecvDone

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

בדומה ל-Send, פעולת Recv של לקוח ה-API מייצגת תקשורת סינכרונית. עם זאת, ההוראה מפורקת באופן פנימי ל-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, והממדים שלו מתוארים בהמשך.

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

מידע על 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 משמש לתקשורת בין מודולים: רק פעולות reduce-scatter עם אותו channel_id יכולות לתקשר ביניהן.
• 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 מערכים רב-ממדיים כפלט. לכל מערך פלט יש את אותו מספר של רכיבים כמו מספר המיקומים התקינים של החלון. שכבת איגום יכולה להיות מיוצגת כ-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);