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

SparseMatrixSparseCholesky

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

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

מחשב את פירוק ה-Spare 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`. תמורה: 'טנזור'. סוג: סוג ה'קלט'.

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

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

שיטות בירושה

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

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

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

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

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

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

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

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

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