ScatterNd

כיתת גמר ציבורית ScatterNd

מפזר `עדכונים` לטנסור של צורה `צורה` לפי `מדדים`.

פזר 'עדכונים' דלילים לפי ערכים בודדים ב'מדדים' שצוינו. אופציה זו מחזירה טנזור פלט עם ה'צורה' שאתה מציין. אופ זה הוא היפוך של האופרטור tf.gather_nd אשר מחלץ ערכים או פרוסות מטנזור נתון.

פעולה זו דומה ל- tf.tensor_scatter_nd_add , אלא שהטנזור מאותחל. קריאה ל- tf.scatter_nd(indices, updates, shape) זהה לקריאת `tf.tensor_scatter_nd_add(tf.zeros(shape, updates.dtype), מדדים, עדכונים)`

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

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

`מדדים` הוא טנזור שלם המכיל מדדים לתוך טנזור הפלט. הממד האחרון של 'מדדים' יכול להיות לכל היותר דרגת 'צורה':

indices.shape[-1] <= shape.rank

הממד האחרון של `מדדים` מתאים למדדים של אלמנטים (אם `indices.shape[-1] = shape.rank`) או פרוסות (אם `indices.shape[-1] < shape.rank`) לאורך הממד `מדדים` .shape[-1]` של `shape`.

'עדכונים' הוא טנסור עם צורה:

indices.shape[:-1] + shape[indices.shape[-1]:]

הצורה הפשוטה ביותר של ה-Catter op היא הכנסת אלמנטים בודדים בטנזור לפי אינדקס. שקול דוגמה שבה אתה רוצה להכניס 4 אלמנטים מפוזרים בטנזור דרגה 1 עם 8 אלמנטים.

ב-Python, פעולת הפיזור הזו תיראה כך:

indices = tf.constant([[4], [3], [1], [7]])
     updates = tf.constant([9, 10, 11, 12])
     shape = tf.constant([8])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 

הטנזור שנוצר ייראה כך:

[0, 11, 0, 10, 9, 0, 0, 12]

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

ב-Python, פעולת הפיזור הזו תיראה כך:

indices = tf.constant([[1], [3]])
     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]],
                            [[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]]])
     shape = tf.constant([4, 4, 4])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 

הטנזור שנוצר ייראה כך:

[[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[5, 5, 5 , 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0, 0], [0, 0 , 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[5, 5, 5, 5], [6, 6, 6, 6], [7] , 7, 7, 7], [8, 8, 8, 8]]]

שימו לב שב-CPU, אם נמצא אינדקס מחוץ לתחום, מוחזרת שגיאה. ב-GPU, אם נמצא אינדקס מחוץ לתחום, מתעלמים מהאינדקס.

שיטות ציבוריות

פלט <U>	asOutput () מחזירה את הידית הסמלית של טנזור.
סטטי <U, T מרחיב מספר> ScatterNd <U>	ליצור ( היקף היקף, מדדי Operand <T>, עדכוני Operand <U>, צורת Operand <T>) שיטת מפעל ליצירת מחלקה העוטפת פעולת ScatterNd חדשה.
פלט <U>	פלט () טנזור חדש עם הצורה הנתונה ועדכונים מיושמים לפי המדדים.

שיטות בירושה

מכיתה org.tensorflow.op.PrimitiveOp

בוליאנית סופית	שווה (Object obj)
int סופי	hashcode ()
מבצע	אופ () מחזירה את Operation הבסיסית
מחרוזת סופית	toString ()

מכיתה java.lang.Object

בוליאני	שווה (Object arg0)
שיעור אחרון<?>	getClass ()
int	hashcode ()
ריק סופי	להודיע ​​()
ריק סופי	הודע הכל ()
חוּט	toString ()
ריק סופי	המתן (ארג0 ארוך, int arg1)
ריק סופי	המתן (ארג0 ארוך)
ריק סופי	חכה ()

מממשק org.tensorflow.Operand

פלט מופשט <U>

asOutput () מחזירה את הידית הסמלית של טנזור.

שיטות ציבוריות

פלט ציבורי <U> asOutput ()

מחזירה את הידית הסמלית של טנזור.

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

Public static ScatterNd <U> create ( היקף היקף , מדדי Operand <T>, עדכוני Operand <U>, צורת Operand <T>)

שיטת מפעל ליצירת מחלקה העוטפת פעולת ScatterNd חדשה.

פרמטרים

תְחוּם	ההיקף הנוכחי
מדדים	טנסור של מדדים.
עדכונים	ערכים לפיזור לתוך טנסור הפלט.
צוּרָה	1-D. צורת טנסור הפלט.

החזרות

• מופע חדש של ScatterNd

פלט ציבורי <U> פלט ()

טנזור חדש עם הצורה הנתונה ועדכונים מיושמים לפי המדדים.