'इनपुट' के विरल चॉलेस्की अपघटन की गणना करता है।
दिए गए भरण-पोषण को कम करने वाले क्रमपरिवर्तन के साथ, एक विरल मैट्रिक्स के विरल चोलेस्की अपघटन की गणना करता है।
इनपुट विरल मैट्रिक्स और भरण-घटाने वाले क्रमपरिवर्तन `क्रमपरिवर्तन` में संगत आकार होने चाहिए। यदि विरल मैट्रिक्स की रैंक 3 है; बैच आयाम `बी` के साथ, तो `क्रमपरिवर्तन` रैंक 2 का होना चाहिए; समान बैच आयाम `बी` के साथ। प्रसारण के लिए कोई समर्थन नहीं है.
इसके अलावा, `क्रमपरिवर्तन` के प्रत्येक घटक वेक्टर की लंबाई `N` होनी चाहिए, जिसमें प्रत्येक पूर्णांक {0, 1, ..., N - 1} बिल्कुल एक बार शामिल हो, जहां `N` प्रत्येक घटक की पंक्तियों की संख्या है विरल मैट्रिक्स का.
इनपुट विरल मैट्रिक्स के प्रत्येक घटक को एक सममित सकारात्मक निश्चित (एसपीडी) मैट्रिक्स का प्रतिनिधित्व करना चाहिए; हालाँकि मैट्रिक्स का केवल निचला त्रिकोणीय भाग ही पढ़ा जाता है। यदि कोई व्यक्तिगत घटक SPD नहीं है, तो एक InvalidArgument त्रुटि उत्पन्न हो जाती है।
लौटाए गए विरल मैट्रिक्स में इनपुट विरल मैट्रिक्स के समान सघन आकार होता है। इनपुट विरल मैट्रिक्स के प्रत्येक घटक `ए` के लिए, संबंधित आउटपुट विरल मैट्रिक्स `एल` का प्रतिनिधित्व करता है, निचला त्रिकोणीय चोल्स्की कारक निम्नलिखित पहचान को संतुष्ट करता है:
A = L * Lt
`प्रकार` पैरामीटर मैट्रिक्स तत्वों के प्रकार को दर्शाता है। समर्थित प्रकार हैं: `फ्लोट32`, `फ्लोट64`, `कॉम्प्लेक्स64` और `कॉम्प्लेक्स128`।
उपयोग उदाहरण:
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)
[[ 1. 0. 0. 0.]
[ 0. 1.41 0. 0.]
[ 0. 0.70 1.58 0.]
[ 0. 0. 0. 2.]]
स्थिरांक
| डोरी | OP_NAME | इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है |
सार्वजनिक तरीके
| आउटपुट < टीटाइप > | आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है। |
| स्थिर <T टीटाइप का विस्तार करता है > SparseMatrixSparseColesky | |
| आउटपुट <?> | आउटपुट () `इनपुट` का विरल चोलेस्की विघटन। |
विरासत में मिली विधियाँ
स्थिरांक
सार्वजनिक स्थैतिक अंतिम स्ट्रिंग OP_NAME
इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है
सार्वजनिक तरीके
सार्वजनिक आउटपुट < TType > asOutput ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
TensorFlow संचालन के इनपुट किसी अन्य TensorFlow ऑपरेशन के आउटपुट हैं। इस पद्धति का उपयोग एक प्रतीकात्मक हैंडल प्राप्त करने के लिए किया जाता है जो इनपुट की गणना का प्रतिनिधित्व करता है।
सार्वजनिक स्थैतिक SparseMatrixSparseColesky निर्माण ( स्कोप स्कोप, ऑपरेंड <?> इनपुट, ऑपरेंड <TInt32> क्रमपरिवर्तन, क्लास<T> प्रकार)
एक नए SparseMatrixSparseColesky ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
पैरामीटर
| दायरा | वर्तमान दायरा |
|---|---|
| इनपुट | एक `CSRSparseMatrix`। |
| परिवर्तन | एक भरण-घटाने वाला क्रमपरिवर्तन मैट्रिक्स। |
रिटर्न
- SparseMatrixSparseColesky का एक नया उदाहरण