BatchToSpaceNd

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

BatchToSpace עבור טנסור ND מסוג T.

פעולה זו מעצבת מחדש את הממד "אצווה" 0 למימדים של `M + 1` של הצורה `block_shape + [אצווה]`, משלבת בלוקים אלה בחזרה לרשת המוגדרת על ידי הממדים המרחביים `[1, ..., M]`, כדי להשיג תוצאה באותה דירוג כמו הקלט. הממדים המרחביים של תוצאת ביניים זו נחתכים לאחר מכן לפי 'גידולים' כדי להפיק את הפלט. זה ההפך של SpaceToBatch. ראה להלן לתיאור מדויק.

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

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

שיטות בירושה

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

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

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

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

Public static BatchToSpaceNd <T> create ( scope scope, Operand <T> input, Operand <U> blockShape, Operand <V> crops)

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

פרמטרים
תְחוּם ההיקף הנוכחי
קֶלֶט ND עם צורה `input_shape = [אצווה] + spatial_shape + resting_shape`, כאשר לצורת_מרחבית יש ממדי M.
blockShape 1-D עם צורה `[M]`, כל הערכים חייבים להיות >= 1.
יבולים 2-D עם צורה `[M, 2]`, כל הערכים חייבים להיות >= 0. `crops[i] = [crop_start, crop_end]` מציין את הכמות לחתוך מממד הקלט `i + 1`, המתאים ל ממד מרחבי `i`. נדרש ש-'crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]'.

פעולה זו מקבילה לשלבים הבאים:

1. עצב מחדש את 'קלט' ל'צורה מחדש' של הצורה: [block_shape[0], ..., block_shape[M-1], batch / prod(block_shape), input_shape[1], ..., input_shape[N- 1]]

2. הפוך את הממדים של 'צורה מחדש' כדי לייצר 'מתומרת' של צורה [batch / prod(block_shape),

input_shape[1], block_shape[0], ..., input_shape[M], block_shape[M-1],

input_shape[M+1], ..., input_shape[N-1]]

3. עצב מחדש את 'מתומרת' כדי ליצור 'מתומרת_ מחדש' של הצורה [אצווה / פרוד(בלוק_צורה),

input_shape[1] * block_shape[0], ..., input_shape[M] * block_shape[M-1],

input_shape[M+1], ..., input_shape[N-1]]

4. חתוך את ההתחלה והסוף של הממדים `[1, ..., M]` של `reshaped_permuted` לפי `crops` כדי להפיק את הפלט של הצורה: [batch / prod(block_shape),

input_shape[1] * block_shape[0] - יבולים[0,0] - יבולים[0,1], ..., input_shape[M] * block_shape[M-1] - יבולים[M-1,0] - יבולים [M-1,1],

input_shape[M+1], ..., input_shape[N-1]]

כמה דוגמאות:

(1) עבור הקלט הבא של הצורה `[4, 1, 1, 1]`, `block_shape = [2, 2]` ו-`crops = [[0, 0], [0, 0]]`:

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
 
לטנזור הפלט יש צורה `[1, 2, 2, 1]` וערך:
x = [[[[1], [2]], [[3], [4]]]]
 
(2) עבור הקלט הבא של הצורה `[4, 1, 1, 3]`, `block_shape = [ 2, 2]`, ו-`crops = [[0, 0], [0, 0]]`:
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
 
לטנזור הפלט יש צורה `[1, 2, 2, 3]` וערך:
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
 
(3) עבור הקלט הבא של צורה `[4, 2, 2, 1]`, `block_shape = [2, 2]` ו-`crops = [[0, 0], [0, 0]]`:
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
 
לטנזור הפלט יש צורה `[1, 4, 4, 1]` וערך:
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]],
      [[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
 
(4) עבור הקלט הבא של הצורה `[8, 1, 3, 1]`, `block_shape = [ 2, 2]`, ו-`crops = [[0, 0], [2, 0]]`:
x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
      [[[0], [2], [4]]], [[[0], [10], [12]]],
      [[[0], [5], [7]]], [[[0], [13], [15]]],
      [[[0], [6], [8]]], [[[0], [14], [16]]]]
 
לטנזור הפלט יש צורה `[2, 2, 4, 1]` וערך:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 

החזרות
  • מופע חדש של BatchToSpaceNd

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