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 utilização:
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)
`lojas c_sm_dense_value` o produto matriz densa: [[ 2. 0. 0.]
[ 0. 0. 0.]
[ 35. 40. 0.]
[ -4. 0. 0.]]
um: Uma` 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
classe | SparseMatrixSparseMatMul.Options | Atributos opcionais para SparseMatrixSparseMatMul |
Métodos Públicos
estáticos SparseMatrixSparseMatMul.Options | adjointA (booleano adjointA) |
estáticos SparseMatrixSparseMatMul.Options | adjointB (booleano adjointB) |
Output <Object> | asOutput () Retorna o identificador simbólico de um tensor. |
Output <?> | c () A CSRSparseMatrix. |
estática <T> SparseMatrixSparseMatMul | criar ( Scope escopo, Operando <?> a, Operando <?> b, Class <T> tipo, Options ... Opções) Método de fábrica para criar uma classe envolvendo uma nova operação SparseMatrixSparseMatMul. |
estáticos SparseMatrixSparseMatMul.Options | transposeA (booleano transposeA) |
estáticos SparseMatrixSparseMatMul.Options | transposeB (booleano 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. |
---|
pública 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.
public static SparseMatrixSparseMatMul criar ( Scope escopo, Operando <?> a, Operando <?> b, Class <T> tipo, Options ... 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. |
---|