SparseMatrixSparseMatMul

विरल-मैट्रिक्स-दो सीएसआर मैट्रिसेस `ए` और `बी` को गुणा करता है।

विरल मैट्रिक्स `a` का विरल मैट्रिक्स `b` के साथ मैट्रिक्स गुणन करता है; एक विरल मैट्रिक्स `a * b` देता है, जब तक कि या तो `a` या `b` को स्थानांतरित या संलग्न नहीं किया जाता है।

प्रत्येक मैट्रिक्स को बूलियन पैरामीटर `transpose_a`, `adjoint_a`, `transpose_b` और `adjoint_b` के अनुसार स्थानांतरित या संलग्न (संयुग्मित और स्थानांतरित) किया जा सकता है। `transpose_a` या `adjoint_a` में से ज़्यादा से ज़्यादा एक सही हो सकता है। इसी तरह, `transpose_b` या `adjoint_b` में से ज़्यादा से ज़्यादा एक सही हो सकता है।

इनपुट में संगत आकार होना चाहिए। अर्थात्, `a` का आंतरिक आयाम `b` के बाहरी आयाम के बराबर होना चाहिए। इस आवश्यकता को इस अनुसार समायोजित किया जाता है कि या तो `ए` या `बी` को स्थानांतरित किया गया है या संलग्न किया गया है।

`प्रकार` पैरामीटर मैट्रिक्स तत्वों के प्रकार को दर्शाता है। `a` और `b` दोनों का प्रकार समान होना चाहिए। समर्थित प्रकार हैं: `float32`, `float64`, `complex64` और `complex128`।

`a` और `b` दोनों की रैंक समान होनी चाहिए। प्रसारण समर्थित नहीं है। यदि उनके पास रैंक 3 है, तो `a` और `b` के भीतर 2D CSRSparseMatrices के प्रत्येक बैच का आकार समान होना चाहिए।

विरल मैट्रिक्स उत्पाद में संख्यात्मक (गैर-संरचनात्मक) शून्य हो सकते हैं। TODO(अनुध्यान): शून्य को छांटना है या नहीं, इसे नियंत्रित करने के लिए एक बूलियन विशेषता जोड़ने पर विचार करें।

प्रयोग उदाहरण:

from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
 
     a_indices = np.array([[0, 0], [2, 3], [2, 4], [3, 0]])
     a_values = np.array([1.0, 5.0, -1.0, -2.0], np.float32)
     a_dense_shape = [4, 5]
 
     b_indices = np.array([[0, 0], [3, 0], [3, 1]])
     b_values = np.array([2.0, 7.0, 8.0], np.float32)
     b_dense_shape = [5, 3]
 
     with tf.Session() as sess:
       # Define (COO format) Sparse Tensors over Numpy arrays
       a_st = tf.sparse.SparseTensor(a_indices, a_values, a_dense_shape)
       b_st = tf.sparse.SparseTensor(b_indices, b_values, b_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)
       b_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
           b_st.indices, b_st.values, b_st.dense_shape)
 
       # Compute the CSR SparseMatrix matrix multiplication
       c_sm = sparse_csr_matrix_ops.sparse_matrix_sparse_mat_mul(
           a=a_sm, b=b_sm, type=tf.float32)
 
       # Convert the CSR SparseMatrix product to a dense Tensor
       c_sm_dense = sparse_csr_matrix_ops.csr_sparse_matrix_to_dense(
           c_sm, tf.float32)
       # Evaluate the dense Tensor value
       c_sm_dense_value = sess.run(c_sm_dense)
 

`c_sm_dense_value` भंडार घने मैट्रिक्स उत्पाद:

[[  2.   0.   0.]
      [  0.   0.   0.]
      [ 35.  40.   0.]
      [ -4.   0.   0.]]
 

एक: एक` CSRSparseMatrix`। बी: एक `CSRSparseMatrix` एक ही प्रकार के साथ और `ए` के रूप में रैंक। प्रकार: `ए` और `बी` दोनों का प्रकार। transpose_a: अगर सही है, तो `a` गुणन से पहले ट्रांसपोज़ किया गया। transpose_b: अगर सही है, तो `b` गुणन से पहले ट्रांसपोज़ किया गया। adjoint_a: अगर सही है, तो `a` गुणन से पहले जुड़ा हुआ है। adjoint_b: अगर सही है, तो `b` गुणन से पहले जुड़ा हुआ है।