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

BatchToSpaceNd

BatchToSpaceNd המעמד הסופי הציבור

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

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

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

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

שיטות בירושה

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

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

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

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

סטטי הציבור BatchToSpaceNd <T> ליצור ( היקף היקף, האופרנד <T> קלט, האופרנד <U> blockShape, האופרנד <V> גידולים)

שיטת מפעל ליצירת מחלקה העוטפת פעולת 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. עצב מחדש את 'קלט' ל-'reshape' של הצורה: [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. עצב מחדש את 'מתומרת' כדי לייצר 'מתומרת_ מחדש' של הצורה [אצווה / prod(בלוק_צורה),

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] ', ו' יבולים = [[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] ', ו' יבולים = [[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> פלט ()