SparseMatrixSparseMatMul

public final class SparseMatrixSparseMatMul

Matriz esparsa multiplica duas matrizes CSR `a` e` b`.

Executa uma multiplicação de matriz de uma matriz esparsa `a` com uma matriz esparsa` b`; retorna uma matriz esparsa `a * b`, a menos que` a` ou `b` seja transposta ou anexada.

Cada matriz pode ser transposta ou anexada (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 formatos compatíveis. Ou seja, a dimensão interna de `a` deve ser igual à dimensão externa de` b`. Este requisito é ajustado de acordo com se `a` ou` b` é transposto ou adjunto.

O parâmetro `type` denota o tipo dos elementos da matriz. Tanto `a` quanto` 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 é necessário podar zeros.

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 de matriz densa: 
[[  2.   0.   0.]
      [  0.   0.   0.]
      [ 35.  40.   0.]
      [ -4.   0.   0.]]
a: A` CSRSparseMatrix`. b: Um `CSRSparseMatrix` com o mesmo tipo e classificação que` a`. tipo: 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` adicionado antes da multiplicação. adjoint_b: se True, `b` adicionado antes da multiplicação.

Classes aninhadas

aula SparseMatrixSparseMatMul.Options Atributos opcionais para SparseMatrixSparseMatMul

Métodos Públicos

static SparseMatrixSparseMatMul.Options
adjointA (booleano adjointA)
static SparseMatrixSparseMatMul.Options
adjointB (booleano adjointB)
Saída <Objeto>
asOutput ()
Retorna o identificador simbólico de um tensor.
Resultado <?>
c ()
A CSRSparseMatrix.
static <T> SparseMatrixSparseMatMul
criar ( escopo do escopo, operando <?> a, operando <?> b, tipo de classe <T>, opções ... opções)
Método de fábrica para criar uma classe envolvendo uma nova operação SparseMatrixSparseMatMul.
static SparseMatrixSparseMatMul.Options
transposeA (boolean transposeA)
static SparseMatrixSparseMatMul.Options
transposeB (boolean transposeB)

Métodos herdados

Métodos Públicos

public static SparseMatrixSparseMatMul.Options adjointA (Boolean adjointA)

Parâmetros
adjunto A Indica se `a` deve ser transposto por conjugado.

public static SparseMatrixSparseMatMul.Options adjointB (Boolean adjointB)

Parâmetros
adjointB Indica se `b` deve ser transposto por conjugado.

public Output <Object> asOutput ()

Retorna o identificador simbólico de um tensor.

As entradas para as operações do TensorFlow são saídas de outra operação do TensorFlow. Este método é usado para obter um identificador simbólico que representa o cálculo da entrada.

Saída pública <?> c ()

A CSRSparseMatrix.

public static SparseMatrixSparseMatMul criar ( escopo do escopo, operando <?> a, operando <?> b, classe <T> tipo, opções ... opções)

Método de fábrica para criar uma classe envolvendo uma nova operação SparseMatrixSparseMatMul.

Parâmetros
alcance escopo atual
uma A CSRSparseMatrix.
b A CSRSparseMatrix.
opções carrega valores de atributos opcionais
Devoluções
  • uma nova instância de SparseMatrixSparseMatMul

public static SparseMatrixSparseMatMul.Options transposeA (Boolean transposeA)

Parâmetros
transporA Indica se `a` deve ser transposto.

public static SparseMatrixSparseMatMul.Options transposeB (Boolean transposeB)

Parâmetros
transporB Indica se `b` deve ser transposto.