MatrixDiag

שיעור הגמר הציבורי MatrixDiag

מחזירה טנזור אלכסוני אצווה עם ערכי אלכסון אצווה נתונים.

מחזירה טנזור עם התוכן ב-`אלכסון` כאלכסוני `k[0]`-th ל-`k[1]`-th של מטריצה, כאשר כל השאר מרופדים ב-`padding`. `num_rows` ו-`num_cols` מציינים את הממד של המטריצה ​​הפנימית ביותר של הפלט. אם שניהם לא מצוינים, האופ מניח שהמטריקס הפנימי ביותר הוא מרובע ומסיק את גודלה מ-'k' והממד הפנימי ביותר של 'אלכסון'. אם רק אחד מהם צוין, ה-op מניח שהערך הלא מוגדר הוא הקטן ביותר האפשרי בהתבסס על קריטריונים אחרים.

תן ל-`אלכסון` להיות ממדי `r` `[I, J, ..., L, M, N]`. לטנזור הפלט יש דרגה 'r+1' עם הצורה '[I, J, ..., L, M, num_rows, num_cols]' כאשר ניתן רק אלכסון אחד ('k' הוא מספר שלם או 'k[0] == k[1]`). אחרת, יש לו דרגה 'r' עם הצורה '[I, J, ..., L, num_rows, num_cols]'.

למימד השני הפנימי ביותר של `אלכסון` יש משמעות כפולה. כאשר `k` הוא סקלארי או `k[0] == k[1]`, `M` הוא חלק מגודל האצווה [I, J, ..., M], וטנסור הפלט הוא:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
אחרת, 'M' יטופל כמספר האלכסונים עבור המטריצה ​​באותה אצווה ('M = k[1]-k[0]+1'), וטנזור הפלט הוא:
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
כאשר `d = n - m`, `diag_index = k[1] - d`, ו-`index_in_diag = n - max(d, 0)`.

לְדוּגמָה:

# The main diagonal.
 diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                      [5, 6, 7, 8]])
 tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                                [0, 2, 0, 0],
                                [0, 0, 3, 0],
                                [0, 0, 0, 4]],
                               [[5, 0, 0, 0],
                                [0, 6, 0, 0],
                                [0, 0, 7, 0],
                                [0, 0, 0, 8]]]
 
 # A superdiagonal (per batch).
 diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                      [4, 5, 6]])
 tf.matrix_diag(diagonal, k = 1)
   ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
         [0, 0, 2, 0],
         [0, 0, 0, 3],
         [0, 0, 0, 0]],
        [[0, 4, 0, 0],
         [0, 0, 5, 0],
         [0, 0, 0, 6],
         [0, 0, 0, 0]]]
 
 # A band of diagonals.
 diagonals = np.array([[[1, 2, 3],  # Input shape: (2, 2, 3)
                        [4, 5, 0]],
                       [[6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 0))
   ==> [[[1, 0, 0],  # Output shape: (2, 3, 3)
         [4, 2, 0],
         [0, 5, 3]],
        [[6, 0, 0],
         [9, 7, 0],
         [0, 1, 9]]]
 
 # Rectangular matrix.
 diagonal = np.array([1, 2])  # Input shape: (2)
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
   ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
        [1, 0, 0, 0],
        [0, 2, 0, 0]]
 
 # Rectangular matrix with inferred num_cols and padding_value = 9.
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
   ==> [[9, 9],  # Output shape: (3, 2)
        [1, 9],
        [9, 2]]

קבועים

חוּט OP_NAME השם של המבצע הזה, כפי שידוע על ידי מנוע הליבה של TensorFlow

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

פלט <T>
asOutput ()
מחזירה את הידית הסמלית של הטנזור.
סטטי <T מרחיב את TType > MatrixDiag <T>
create ( scope scope, Operand <T> diagonal, Operand < TInt32 > k, Operand < TInt32 > numRows, Operand < TInt32 > numCols, Operand <T> paddingValue)
שיטת מפעל ליצירת מחלקה העוטפת פעולת MatrixDiag חדשה.
פלט <T>
פלט ()
יש דרגה `r+1` כאשר `k` הוא מספר שלם או `k[0] == k[1]`, דרגה `r` אחרת.

שיטות בירושה

org.tensorflow.op.RawOp
בוליאנית סופית
שווה (Object obj)
int סופי
hashcode ()
מִבצָע
אופ ()
החזר יחידת חישוב זו Operation אחת.
מחרוזת סופית
toString ()
בוליאני
שווה (Object arg0)
כיתה אחרונה<?>
getClass ()
int
hashcode ()
ריק סופי
להודיע ​​()
ריק סופי
הודע הכל ()
חוּט
toString ()
ריק סופי
המתן (ארג0 ארוך, אינט arg1)
ריק סופי
חכה (ארג0 ארוך)
ריק סופי
חכה ()
org.tensorflow.op.Op
אבסטרקט ExecutionEnvironment
env ()
החזר את סביבת הביצוע שבה נוצר האופציה הזו.
מבצע מופשט
אופ ()
החזר יחידת חישוב זו Operation אחת.
org.tensorflow.Operand
פלט מופשט <T>
asOutput ()
מחזירה את הידית הסמלית של הטנזור.
תקציר T
asTensor ()
מחזיר את הטנזור באופרנד זה.
צורה מופשטת
צורה ()
מחזירה את הצורה (הידועה אולי בחלקה) של הטנזור שאליו מתייחס Output של אופרנד זה.
מחלקה מופשטת<T>
סוג ()
מחזירה את סוג הטנזור של אופרנד זה
org.tensorflow.ndarray.Shaped
מופשט int
דרגה ()
צורה מופשטת
צורה ()
מופשט ארוך
גודל ()
מחשב ומחזיר את הגודל הכולל של מיכל זה, במספר ערכים.

קבועים

מחרוזת סופית סטטית ציבורית OP_NAME

השם של המבצע הזה, כפי שידוע על ידי מנוע הליבה של TensorFlow

ערך קבוע: "MatrixDiagV2"

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

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

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

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

ציבורי סטטי MatrixDiag <T> create ( scope scope, Operand <T> diagonal, Operand < TInt32 > k, Operand < TInt32 > numRows, Operand < TInt32 > numCols, Operand <T> paddingValue)

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

פרמטרים
תְחוּם ההיקף הנוכחי
אֲלַכסוֹנִי דירוג `r`, כאשר `r >= 1`
ק היסט אלכסוני(ים). ערך חיובי פירושו על-אלכסון, 0 מתייחס לאלכסון הראשי, וערך שלילי פירושו תת-אלכסונים. `k` יכול להיות מספר שלם בודד (עבור אלכסון בודד) או זוג מספרים שלמים המציינים את הקצוות הנמוכים והגבוהים של פס מטריצה. 'k[0]' לא יכול להיות גדול מ-'k[1]'.
numRows מספר השורות של מטריצת הפלט. אם זה לא מסופק, ה-op מניח שמטריצת הפלט היא מטריצה ​​מרובעת ומסיק את גודל המטריצה ​​מ-k ומהמימד הפנימי ביותר של 'אלכסון'.
numCols מספר העמודות של מטריצת הפלט. אם זה לא מסופק, ה-op מניח שמטריצת הפלט היא מטריצה ​​מרובעת ומסיק את גודל המטריצה ​​מ-k ומהמימד הפנימי ביותר של 'אלכסון'.
paddingValue המספר שיש למלא איתו את השטח שמחוץ לפס האלכסוני שצוין. ברירת המחדל היא 0.
מחזיר
  • מופע חדש של MatrixDiag

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

יש דרגה `r+1` כאשר `k` הוא מספר שלם או `k[0] == k[1]`, דרגה `r` אחרת.