SparseMatrixSparseMatMul

A matriz esparsa multiplica duas matrizes CSR `a` e `b`.

Executa uma multiplicação de matrizes de uma matriz esparsa `a` com uma matriz esparsa `b`; retorna uma matriz esparsa `a * b`, a menos que `a` ou `b` sejam transpostos ou adjuntos.

Cada matriz pode ser transposta ou adjunta (conjugada e transposta) de acordo com os parâmetros booleanos `transpose_a`, `adjoint_a`, `transpose_b` e `adjoint_b`. No máximo um de `transpose_a` ou `adjoint_a` pode ser True. Da mesma forma, no máximo um de `transpose_b` ou `adjoint_b` pode ser True.

As entradas devem ter formas compatíveis. Ou seja, a dimensão interna de `a` deve ser igual à dimensão externa de `b`. Este requisito é ajustado de acordo com o fato de `a` ou `b` ser transposto ou adjunto.

O parâmetro `type` denota o tipo dos elementos da matriz. Ambos `a` e `b` devem ter o mesmo tipo. Os tipos suportados são: `float32`, `float64`, `complex64` e `complex128`.

Ambos `a` e `b` devem ter a mesma classificação. A transmissão não é suportada. Se eles tiverem classificação 3, cada lote de CSRSparseMatrices 2D dentro de `a` e `b` deve ter a mesma forma densa.

O produto de matriz esparsa pode ter zeros numéricos (não estruturais). TODO(anudhyan): Considere adicionar um atributo booleano para controlar se os zeros devem ser removidos.

Exemplo de uso:

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` armazena o produto da matriz densa:

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

a: Um `CSRSparseMatrix`. b: Um `CSRSparseMatrix` com o mesmo tipo e classificação que `a`. type: O tipo de `a` e `b`. transpose_a: Se True, `a` transposto antes da multiplicação. transpose_b: Se True, `b` transposto antes da multiplicação. adjoint_a: Se True, `a` adjunto antes da multiplicação. adjoint_b: Se True, `b` adjunto antes da multiplicação.