StridedSlice

שיעור גמר ציבורי StridedSlice

החזר פרוסה פסיעה מ'קלט'.

שימו לב, רוב משתמשי python ירצו להשתמש ב-Python Tensor.__getitem__ או Variable.__getitem__ ולא באופציה הזו ישירות.

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

- אליפסיס (...). אליפסות משמשות כדי לרמוז על אפס או יותר ממדים של בחירת מימד מלא ומיוצרות באמצעות `ellipsis_mask`. לדוגמה, `foo[...]` הוא פרוסת הזהות.

- ציר חדש. זה משמש להכנסת צורה חדשה = מימד 1 ומופק באמצעות `new_axis_mask`. לדוגמה, `foo[:, ...]` כאשר `foo` הוא צורה `(3, 4)` מייצר טנזור `(1, 3, 4)`.

- טווח `begin:end:stride`. זה משמש כדי לציין כמה לבחור מממד נתון. `stride` יכול להיות כל מספר שלם מלבד 0. `begin` הוא מספר שלם המייצג את האינדקס של הערך הראשון שיש לבחור בעוד `end` מייצג את האינדקס של הערך האחרון לבחירה. מספר הערכים שנבחרו בכל מימד הוא 'סוף - התחלה' אם 'צעד > 0' ו'התחלה - סוף' אם 'צעד < 0'. `התחלה` ו`סוף` יכולים להיות שליליים כאשר `-1` הוא האלמנט האחרון, `-2` הוא השני אחרון. `begin_mask` שולט אם להחליף את ה-begin שניתן במפורש בערך אפקטיבי מרומז של `0` אם `stride > 0` ו-`-1` אם `stride < 0`. `end_mask` הוא אנלוגי אך מייצר את המספר הנדרש ליצירת המרווח הפתוח הגדול ביותר. לדוגמה, בהינתן צורה `(3,)` טנסור `foo[:]`, `ההתחלה` וה`סוף` האפקטיביים הם `0` ו-`3`. אל תניח שזה שווה ערך ל-'foo[0:-1]' שיש לו 'התחלה' ו'סוף' אפקטיביים של '0' ו-'2'. דוגמה נוספת היא `foo[-2::-1]` אשר הופך את הממד הראשון של טנזור תוך שחרור שני האחרונים (באלמנטים בסדר המקורי). לדוגמה `foo = [1,2,3,4]; foo[-2::-1]` הוא `[4,3]`.

- מדד בודד. זה משמש כדי לשמור רק אלמנטים שיש להם אינדקס נתון. לדוגמה (`foo[2, :]` על טנסור של צורה `(5,6)` מייצר טנזור של צורה `(6,)`. זה מקודד ב-'begin' ו-'end' ו-'shrink_axis_mask'.

כל מפרט טווח מושגי מקודד בארגומנט ה-op. הכי טוב להבין את הקידוד הזה על ידי בחינת דוגמה לא טריוויאלית. בפרט, `foo[1, 2:4, None, ..., :-3:-1, :]` יקודד בתור

begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
 end = [2, 4, x, x, -3, x]
 strides = [1, 1, x, x, -1, 1]
 begin_mask = 1<<4 | 1<<5 = 48
 end_mask = 1<<5 = 32
 ellipsis_mask = 1<<3 = 8
 new_axis_mask = 1<<2 = 4
 shrink_axis_mask = 1<<0 = 1
 

במקרה זה אם `foo.shape` הוא (5, 5, 5, 5, 5, 5) הצורה הסופית של הפרוסה הופכת (2, 1, 5, 5, 2, 5). הבה נעבור צעד אחר צעד דרך כל מפרט טיעון.

1. הארגומנט הראשון בפרוסה לדוגמה הופך ל-'begin = 1' ו-'end = begin + 1 = 2'. כדי להבדיל מהמפרט המקורי `2:4`, הגדרנו גם את הביט המתאים ב- `shrink_axis_mask`.

2. `2:4` תורם 2, 4, 1 כדי להתחיל, לסיים ולצעיד. לכל המסכות יש אפס ביטים.

3. None היא מילה נרדפת ל- tf.newaxis . זה אומר להכניס ממד בגודל 1 ממד בצורה הסופית. ערכי דמה תורמים להתחלה, לסוף ולצעידה, בעוד סיבית new_axis_mask מוגדרת.

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

5. `:-3:-1` מציג את השימוש במדדים שליליים. אינדקס שלילי `i` המשויך לממד בעל צורה `s` מומר לאינדקס חיובי `s + i`. אז `-1` הופך להיות `s-1` (כלומר האלמנט האחרון). המרה זו מתבצעת באופן פנימי, כך שההתחלה, הסוף והצעדים מקבלים x, -3 ו-1. סיבית begin_mask המתאימה מוגדרת כדי לציין שטווח ההתחלה הוא הטווח המלא (בהתעלם מה-x).

6. `:` מציין שכל התוכן של הממד המתאים נבחר. זה שווה ערך ל-`::` או `0::1`. התחלה, סיום וצעדים מקבלים 0, 0 ו-1, בהתאמה. הסיביות המתאימות ב-'begin_mask' ו-'end_mask' מוגדרות גם כן.

דרישות : `0 != צעדים[i] עבור i ב-[0, m)` `ellipsis_mask חייב להיות בחזקת שתיים (רק אליפסה אחת)`

כיתות מקוננות

מעמד

StridedSlice.Options

תכונות אופציונליות עבור StridedSlice

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

פלט <T>	asOutput () מחזירה את הידית הסמלית של טנזור.
סטטי StridedSlice.Options	beginMask (Long beginMask)
סטטי <T, U מרחיב מספר> StridedSlice <T>	צור ( היקף היקף , קלט Operand <T>, Operand <U> מתחיל, Operand <U> סוף, צעדי Operand <U>, אפשרויות... אפשרויות) שיטת מפעל ליצירת מחלקה העוטפת פעולת StridedSlice חדשה.
סטטי StridedSlice.Options	ellipsisMask (מסכת ellipsis ארוכה)
סטטי StridedSlice.Options	endMask (Long endMask)
סטטי StridedSlice.Options	newAxisMask (Long newAxisMask)
פלט <T>	פלט ()
סטטי StridedSlice.Options	shrinkAxisMask (Long shrinkAxisMask)

שיטות בירושה

מכיתה 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

פלט מופשט <T>

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

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

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

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

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

Public static StridedSlice.Options beginMask (Long beginMask)

פרמטרים

beginMask	bitmask שבו bit i להיות 1 פירושו להתעלם מערך ההתחלה ובמקום זאת להשתמש במרווח הגדול ביותר האפשרי. בזמן הריצה מתחיל[i] יוחלף ב-`[0, n-1)` אם `stride[i] > 0` או `[-1, n-1]` אם `stride[i] < 0`

public static StridedSlice <T> create ( היקף היקף, קלט Operand <T>, Operand <U> התחלה, Operand <U> סוף, צעדי Operand <U>, אפשרויות... אפשרויות)

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

פרמטרים

תְחוּם	ההיקף הנוכחי
התחל	`begin[k]` מציין את ההיסט לתוך מפרט הטווח `k`th. המימד המדויק אליו יקבע בהתאם להקשר. ערכי מחוץ לתחום יוצמדו בשקט. אם ה-`k`th bit של `begin_mask` אז מתעלמים מ-begin[k]` ובמקום זאת נעשה שימוש בטווח המלא של הממד המתאים. ערכים שליליים גורמים לאינדקס להתחיל מהאלמנט הגבוה ביותר, למשל אם `foo==[1,2,3]` אז `foo[-1]==3`.
סוֹף	'end[i]' הוא כמו 'התחלה', למעט החריג ש-'end_mask' משמש כדי לקבוע טווחים מלאים.
צעדים	`strides[i]` מציין את התוספת במפרט `i` לאחר חילוץ אלמנט נתון. מדדים שליליים יהפכו את הסדר המקורי. ערכי החוץ או הטווח מוצמדים ל-'[0,dim[i]) if slice[i]>0' או '[-1,dim[i]-1] if slice[i] < 0'
אפשרויות	נושא ערכי תכונות אופציונליות

החזרות

• מופע חדש של StridedSlice

Public static StridedSlice.Options ellipsisMask (Long ellipsisMask)

פרמטרים

מסכה אליפסית	מסכת סיביות שבה ביט 'i' הוא 1 פירושו שהמיקום ה-i הוא למעשה אליפסיס. סיביות אחת לכל היותר יכולה להיות 1. אם `ellipsis_mask == 0`, אז מסופקת מסכת אליפסיס מרומזת של `1 << (m+1)`. המשמעות היא ש-'foo[3:5] == foo[3:5, ...]'. אליפסיס יוצר באופן מרומז כמה מפרטי טווח הנדרשים כדי לציין במלואו את הטווח הפרוס עבור כל ממד. לדוגמה עבור טנזור 4 מימדי `foo`, החתך `foo[2, ..., 5:8]` מרמז על `foo[2, :, :, 5:8]`.

Public static StridedSlice.Options endMask (Long endMask)

פרמטרים

endMask	מקביל ל-'begin_mask'

StridedSlice סטטי ציבורי. אפשרויות newAxisMask (Long newAxisMask)

פרמטרים

newAxisMask	מסכת סיביות שבה ביט `i` הוא 1 פירושו המפרט `i` יוצר מימד חדש של צורה 1. לדוגמה, `foo[:4, tf.newaxis, :2]` ייצור טנסור של צורה `(4, 1, 2)`.

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

StridedSlice סטטי ציבורי. אפשרויות shrinkAxisMask (Long shrinkAxisMask)

פרמטרים

shrinkAxisMask	מסכת סיביות שבה סיביות 'i' מרמזת שהמפרט ה'י' צריך לכווץ את הממדיות. התחלה וסוף חייבים לרמוז על פרוסה בגודל 1 בממד. לדוגמה בפיתון אפשר לעשות 'foo[:, 3, :]' מה שיביא לכך ש-'shrink_axis_mask' יהיה 2.