SparseMatrixSparseMatMul

Ma trận thưa-nhân hai ma trận CSR `a` và `b`.

Thực hiện phép nhân ma trận của ma trận thưa `a` với ma trận thưa `b`; trả về một ma trận thưa `a * b`, trừ khi `a` hoặc `b` được hoán vị hoặc nối.

Mỗi ma trận có thể được hoán vị hoặc liền kề (liên hợp và hoán vị) theo các tham số Boolean `transpose_a`, `adjoint_a`, `transpose_b` và `adjoint_b`. Nhiều nhất một trong số `transpose_a` hoặc `adjoint_a` có thể đúng. Tương tự, nhiều nhất một trong số `transpose_b` hoặc `adjoint_b` có thể đúng.

Các đầu vào phải có hình dạng tương thích. Tức là kích thước bên trong của `a` phải bằng kích thước bên ngoài của `b`. Yêu cầu này được điều chỉnh tùy theo việc `a` hoặc `b` được hoán vị hay nối liền.

Tham số `type` biểu thị loại phần tử ma trận. Cả `a` và `b` đều phải có cùng loại. Các loại được hỗ trợ là: `float32`, `float64`, `complex64` và `complex128`.

Cả `a` và `b` đều phải có cùng thứ hạng. Phát sóng không được hỗ trợ. Nếu chúng có thứ hạng 3 thì mỗi lô 2D CSRSparseMatrices trong `a` và `b` phải có cùng hình dạng dày đặc.

Sản phẩm ma trận thưa thớt có thể có các số 0 (phi cấu trúc). TODO(anudhyan): Cân nhắc thêm thuộc tính boolean để kiểm soát xem có cắt bớt số 0 hay không.

Ví dụ sử dụng:

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` lưu trữ tích ma trận dày đặc:

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

a: Một `CSRSparseMatrix`. b: Một `CSRSparseMatrix` có cùng loại và xếp hạng như `a`. loại: Loại của cả `a` và `b`. transpose_a: Nếu đúng, `a` được chuyển đổi trước khi nhân. transpose_b: Nếu đúng, `b` được chuyển đổi trước khi nhân. adjoint_a: Nếu đúng, `a` liền kề trước phép nhân. adjoint_b: Nếu đúng, `b` liền kề trước khi nhân.