SparseMatrixSparseMatMul

Sparse-matrix-multiplica dos matrices CSR `a` y` b`.

Realiza una multiplicación matricial de una matriz dispersa `a` con una matriz dispersa` b`; devuelve una matriz dispersa `a * b`, a menos que` a` o `b` estén transpuestos o adjuntos.

Cada matriz puede ser transpuesta o adjunta (conjugada y transpuesta) de acuerdo con los parámetros booleanos `transpose_a`,` adjoint_a`, `transpose_b` y` adjoint_b`. Como máximo, uno de `transpose_a` o` adjoint_a` puede ser Verdadero. De manera similar, como máximo uno de `transpose_b` o` adjoint_b` puede ser Verdadero.

Las entradas deben tener formas compatibles. Es decir, la dimensión interna de "a" debe ser igual a la dimensión externa de "b". Este requisito se ajusta según se transponga o se adjunte "a" o "b".

El parámetro `type` denota el tipo de los elementos de la matriz. Tanto `a` como` b` deben tener el mismo tipo. Los tipos admitidos son: `float32`,` float64`, `complex64` y` complex128`.

Tanto "a" como "b" deben tener el mismo rango. No se admite la transmisión. Si tienen rango 3, cada lote de CSRSparseMatrices 2D dentro de `a` y` b` debe tener la misma forma densa.

El producto de matriz dispersa puede tener ceros numéricos (no estructurales). TODO (anudhyan): considere agregar un atributo booleano para controlar si se deben eliminar los ceros.

Ejemplo 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` almacena el producto de matriz densa:

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

a: A` CSRSparseMatrix`. b: un "CSRSparseMatrix" con el mismo tipo y rango que "a". type: el tipo de `a` y` b`. transpose_a: Si es True, `a` se transpone antes de la multiplicación. transpose_b: Si es True, `b` se transpone antes de la multiplicación. adjoint_a: Si es verdadero, `a` adjunto antes de la multiplicación. adjoint_b: Si es verdadero, `b` adjunto antes de la multiplicación.