SparseMatrixSparseCholesky

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

מחשב את הפירוק הדליל של 'קלט'.

מחשב את פירוק ה-Sparse Cholesky של מטריצה ​​דלילה, עם התמורה הנתונה להפחתת המילוי.

למטריצת הקלט הדלילה ולתמורה המפחיתה את המילוי 'תמורה' חייבות להיות צורות תואמות. אם למטריצה ​​הדלילה יש דרגה 3; עם ממד האצווה 'B', אז ה'תמורה' חייבת להיות בדרגה 2; עם אותו ממד אצווה 'B'. אין תמיכה בשידור.

יתר על כן, כל וקטור רכיב של `תמורה` חייב להיות באורך `N`, להכיל כל אחד מהמספרים השלמים {0, 1, ..., N - 1} בדיוק פעם אחת, כאשר `N` הוא מספר השורות של כל רכיב של המטריצה ​​הדלילה.

כל רכיב של מטריצת הקלט הדלילה חייב לייצג מטריצה ​​סימטרית חיובית מוגדרת (SPD); אם כי רק החלק המשולש התחתון של המטריצה ​​נקרא. אם רכיב בודד כלשהו אינו SPD, אזי נזרקת שגיאת InvalidArgument.

למטריצה ​​הדלילה המוחזרת יש אותה צורה צפופה כמו המטריצה ​​הדלילה של הקלט. עבור כל רכיב 'A' של מטריצת הקלט הדלילה, מטריצת הפלט הדלילה המתאימה מייצגת את 'L', הגורם Cholesky המשולש התחתון מקיים את הזהות הבאה: 

A = L * Lt
כאשר Lt מציין את הטרנספוזה של L (או הטרנספוזה המצומדת שלו, אם ' סוג` הוא `complex64` או `complex128`).

הפרמטר 'סוג' מציין את סוג רכיבי המטריצה. הסוגים הנתמכים הם: `float32`, `float64`, `complex64` ו-`complex128`.

דוגמה לשימוש: 

from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
 
     a_indices = np.array([[0, 0], [1, 1], [2, 1], [2, 2], [3, 3]])
     a_values = np.array([1.0, 2.0, 1.0, 3.0, 4.0], np.float32)
     a_dense_shape = [4, 4]
 
     with tf.Session() as sess:
       # Define (COO format) SparseTensor over Numpy array.
       a_st = tf.sparse.SparseTensor(a_indices, a_values, a_dense_shape)
 
       # Convert SparseTensors to CSR SparseMatrix.
       a_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
           a_st.indices, a_st.values, a_st.dense_shape)
 
       # Obtain the Sparse Cholesky factor using AMD Ordering for reducing zero
       # fill-in (number of structural non-zeros in the sparse Cholesky factor).
       ordering_amd = sparse_csr_matrix_ops.sparse_matrix_ordering_amd(sparse_matrix)
       cholesky_sparse_matrices = (
           sparse_csr_matrix_ops.sparse_matrix_sparse_cholesky(
               sparse_matrix, ordering_amd, type=tf.float32))
 
       # Convert the CSRSparseMatrix Cholesky factor to a dense Tensor
       dense_cholesky = sparse_csr_matrix_ops.csr_sparse_matrix_to_dense(
           cholesky_sparse_matrices, tf.float32)
 
       # Evaluate the dense Tensor value.
       dense_cholesky_value = sess.run(dense_cholesky)
`dense_cholesky_value` מאחסן את גורם Cholesky הצפוף: 
[[  1.  0.    0.    0.]
      [  0.  1.41  0.    0.]
      [  0.  0.70  1.58  0.]
      [  0.  0.    0.    2.]]
קלט: A `CSRSparseMatrix`. תמורה: 'טנזור'. סוג: סוג ה'קלט'.

קבועים

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

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

פלט < TType >
asOutput ()
מחזירה את הידית הסמלית של הטנזור.
static <T מרחיב את TType > SparseMatrixSparseCholesky
צור (היקף היקף , קלט Operand <?>, פרמוטציה של Operand < TInt32 >, סוג Class<T>)
שיטת מפעל ליצירת מחלקה העוטפת פעולת SparseMatrixSparseCholesky חדשה.
פלט <?>
פלט ()
הפירוק הצ'ולסקי הדליל של 'קלט'.

שיטות בירושה

קבועים

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

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

ערך קבוע: "SparseMatrixSparseCholesky"

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

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

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

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

ציבורי סטטי SparseMatrixSparseCholesky create (היקף היקף , קלט Operand <?>, פרמוטציה של Operand < TInt32 >, סוג Class<T>)

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

פרמטרים
תְחוּם ההיקף הנוכחי
קֶלֶט 'CSRSparseMatrix'.
תְמוּרָה מטריצת תמורה מצמצמת מילוי.
החזרות
  • מופע חדש של SparseMatrixSparseCholesky

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

הפירוק הצ'ולסקי הדליל של 'קלט'.