MatrixSetDiag

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

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

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

ל'קלט' יש ממדי 'r+1' '[I, J, ..., L, M, N]'. כאשר `k` הוא סקלארי או `k[0] == k[1]`, ל`אלכסון` יש ממדי `r` `[I, J, ..., L, max_diag_len]`. אחרת, יש לו ממדי `r+1` `[I, J, ..., L, num_diags, max_diag_len]`. `num_diags` הוא מספר האלכסונים, `num_diags = k[1] - k[0] + 1`. `max_diag_len` הוא האלכסון הארוך ביותר בטווח `[k[0], k[1]]`, `max_diag_len = min(M + min(k[1], 0), N + min(-k[0] , 0))`

הפלט הוא טנסור בדרגה `k+1` עם מידות `[I, J, ..., L, M, N]`. אם `k` הוא סקלארי או `k[0] == k[1]`:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(k[1], 0)] ; if n - m == k[1]
     input[i, j, ..., l, m, n]              ; otherwise
אַחֶרֶת,
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     input[i, j, ..., l, m, n]                         ; otherwise
כאשר `d = n - m`, `diag_index = k[1] - d`, ו-`index_in_diag = n - max(d, 0) + offset`.

'היסט' הוא אפס למעט כאשר היישור של האלכסון הוא ימינה.

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT
                                            and `d >= 0`) or
                                          (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                            and `d <= 0`)
          0                          ; otherwise
 }
 כאשר `diag_len(d) = min(cols - max(d, 0), rows + min(d, 0))`.

לְדוּגמָה:

# The main diagonal.
 input = np.array([[[7, 7, 7, 7],              # Input shape: (2, 3, 4)
                    [7, 7, 7, 7],
                    [7, 7, 7, 7]],
                   [[7, 7, 7, 7],
                    [7, 7, 7, 7],
                    [7, 7, 7, 7]]])
 diagonal = np.array([[1, 2, 3],               # Diagonal shape: (2, 3)
                      [4, 5, 6]])
 tf.matrix_set_diag(input, diagonal)
   ==> [[[1, 7, 7, 7],  # Output shape: (2, 3, 4)
         [7, 2, 7, 7],
         [7, 7, 3, 7]],
        [[4, 7, 7, 7],
         [7, 5, 7, 7],
         [7, 7, 6, 7]]]
 
 # A superdiagonal (per batch).
 tf.matrix_set_diag(input, diagonal, k = 1)
   ==> [[[7, 1, 7, 7],  # Output shape: (2, 3, 4)
         [7, 7, 2, 7],
         [7, 7, 7, 3]],
        [[7, 4, 7, 7],
         [7, 7, 5, 7],
         [7, 7, 7, 6]]]
 
 # A band of diagonals.
 diagonals = np.array([[[0, 9, 1],  # Diagonal shape: (2, 4, 3)
                        [6, 5, 8],
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 1, 2],
                        [5, 6, 4],
                        [6, 1, 2],
                        [3, 4, 0]]])
 tf.matrix_set_diag(input, diagonals, k = (-1, 2))
   ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
         [4, 2, 5, 1],
         [7, 5, 3, 8]],
        [[6, 5, 1, 7],
         [3, 1, 6, 2],
         [7, 4, 2, 4]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[9, 1, 0],  # Diagonal shape: (2, 4, 3)
                        [6, 5, 8],
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[1, 2, 0],
                        [5, 6, 4],
                        [6, 1, 2],
                        [0, 3, 4]]])
 tf.matrix_set_diag(input, diagonals, k = (-1, 2), align="LEFT_RIGHT")
   ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
         [4, 2, 5, 1],
         [7, 5, 3, 8]],
        [[6, 5, 1, 7],
         [3, 1, 6, 2],
         [7, 4, 2, 4]]]

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

מַחלָקָה MatrixSetDiag.Options תכונות אופציונליות עבור MatrixSetDiag

קבועים

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

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

סטטי MatrixSetDiag.Options
יישור (יישור מחרוזת)
פלט <T>
asOutput ()
מחזירה את הידית הסמלית של הטנזור.
סטטי <T מרחיב את TType > MatrixSetDiag <T>
צור ( scope scope, Operand <T> קלט, Operand <T> אלכסוני, Operand < TInt32 > k, Options... options)
שיטת מפעל ליצירת מחלקה העוטפת פעולת MatrixSetDiag חדשה.
פלט <T>
פלט ()
דרג 'r+1', עם 'output.shape = input.shape'.

שיטות בירושה

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

ערך קבוע: "MatrixSetDiagV3"

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

ציבורי סטטי MatrixSetDiag.Options align (String align)

פרמטרים
ליישר חלק מהאלכסונים קצרים מ-'max_diag_len' וצריכים להיות מרופדים. `align` הוא מחרוזת המציינת כיצד יש ליישר את אלכסוני העל ותת-אלכסונים, בהתאמה. ישנם ארבעה יישורים אפשריים: "RIGHT_LEFT" (ברירת מחדל), "LEFT_RIGHT", "LEFT_LEFT" ו-"RIGHT_RIGHT". "RIGHT_LEFT" מיישר את אלכסוני העל ימינה (מכפיל את השורה משמאל) ואת אלכסוני המשנה שמאלה (מכפיל את השורה מימין). זוהי פורמט האריזה שבו LAPACK משתמש. cuSPARSE משתמש ב-"LEFT_RIGHT", שהוא היישור ההפוך.

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

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

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

ציבורי סטטי MatrixSetDiag <T> create ( היקף היקף , קלט Operand <T>, Operand <T> אלכסוני, Operand < TInt32 > k, אפשרויות... אפשרויות)

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

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

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

דרג 'r+1', עם 'output.shape = input.shape'.