SparseMatrixSparseCholesky

'इनपुट' के विरल चोल्स्की अपघटन की गणना करता है।

दिए गए फिल-इन कम करने वाले क्रमपरिवर्तन के साथ, विरल मैट्रिक्स के विरल Cholesky अपघटन की गणना करता है।

इनपुट विरल मैट्रिक्स और फिल-इन कम करने वाले क्रमपरिवर्तन `क्रमपरिवर्तन` में संगत आकार होने चाहिए। यदि विरल मैट्रिक्स की रैंक 3 है; बैच आयाम `बी` के साथ, फिर `क्रमपरिवर्तन` रैंक 2 का होना चाहिए; समान बैच आयाम `बी` के साथ। प्रसारण के लिए कोई समर्थन नहीं है।

इसके अलावा, `क्रमपरिवर्तन` का प्रत्येक घटक वेक्टर लंबाई `N` का होना चाहिए, जिसमें प्रत्येक पूर्णांक {0, 1, ..., N - 1} ठीक एक बार हो, जहां `N` प्रत्येक घटक की पंक्तियों की संख्या है विरल मैट्रिक्स के।

इनपुट विरल मैट्रिक्स के प्रत्येक घटक को एक सममित सकारात्मक निश्चित (एसपीडी) मैट्रिक्स का प्रतिनिधित्व करना चाहिए; हालांकि मैट्रिक्स का केवल निचला त्रिकोणीय हिस्सा पढ़ा जाता है। यदि कोई व्यक्तिगत घटक एसपीडी नहीं है, तो एक अमान्य आर्ग्यूमेंट त्रुटि फेंक दी जाती है।

लौटे विरल मैट्रिक्स में इनपुट विरल मैट्रिक्स के समान घना आकार होता है। इनपुट विरल मैट्रिक्स के प्रत्येक घटक `A` के लिए, संबंधित आउटपुट विरल मैट्रिक्स `L` का प्रतिनिधित्व करता है, निम्न त्रिकोणीय चोल्स्की कारक निम्नलिखित पहचान को संतुष्ट करता है:

A = L * Lt
 

जहां L, L (या इसके संयुग्मित स्थानान्तरण, यदि ` type``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.]]
 

इनपुट: एक `CSRSparseMatrix`। क्रमपरिवर्तन: ए 'टेन्सर'। प्रकार: `इनपुट` का प्रकार।