SparseMatrixSparseMatMul

public final class SparseMatrixSparseMatMul

Matrice sparsa moltiplica due matrici CSR "a" e "b".

Esegue una moltiplicazione matriciale di una matrice sparsa `a` con una matrice sparsa` b`; restituisce una matrice sparsa "a * b", a meno che "a" o "b" non siano trasposti o aggiunti.

Ogni matrice può essere trasposta o aggiunta (coniugata e trasposta) secondo i parametri booleani `transpose_a`,` adjoint_a`, `transpose_b` e` adjoint_b`. Al massimo uno tra `transpose_a` o` adjoint_a` può essere True. Allo stesso modo, al massimo uno tra `transpose_b` o` adjoint_b` può essere True.

Gli input devono avere forme compatibili. Cioè, la dimensione interna di "a" deve essere uguale alla dimensione esterna di "b". Questo requisito viene adattato a seconda che "a" o "b" siano trasposti o aggiunti.

Il parametro `type` denota il tipo degli elementi della matrice. Sia "a" che "b" devono avere lo stesso tipo. I tipi supportati sono: `float32`,` float64`, `complex64` e` complex128`.

Sia "a" che "b" devono avere lo stesso rango. La trasmissione non è supportata. Se hanno il rango 3, ogni batch di CSRSparseMatrices 2D all'interno di "a" e "b" deve avere la stessa forma densa.

Il prodotto di matrice sparsa può avere zeri numerici (non strutturali). TODO (anudhyan): considera l'aggiunta di un attributo booleano per controllare se eliminare gli zeri.

Esempio di utilizzo:

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` memorizza il prodotto matrice densa:
[[  2.   0.   0.]
      [  0.   0.   0.]
      [ 35.  40.   0.]
      [ -4.   0.   0.]]
 
a: A` CSRSparseMatrix`. b: Una `CSRSparseMatrix` con lo stesso tipo e rango di` a`. tipo: il tipo di "a" e "b". transpose_a: se True, `a` trasposto prima della moltiplicazione. transpose_b: se True, "b" trasposto prima della moltiplicazione. adjoint_a: se True, "a" aggiunto prima della moltiplicazione. adjoint_b: se True, "b" aggiunto prima della moltiplicazione.

Classi annidate

classe SparseMatrixSparseMatMul.Options Attributi facoltativi per SparseMatrixSparseMatMul

Metodi pubblici

static SparseMatrixSparseMatMul.Options
adjointA (booleano adjointA)
static SparseMatrixSparseMatMul.Options
adjointB (booleano adjointB)
Output <Object>
asOutput ()
Restituisce la maniglia simbolica di un tensore.
Uscita <?>
c ()
Un CSRSparseMatrix.
static <T> SparseMatrixSparseMatMul
create ( ambito ambito, operando <?> a, operando <?> b, tipo classe <T>, opzioni ... )
Metodo Factory per creare una classe che racchiude una nuova operazione SparseMatrixSparseMatMul.
static SparseMatrixSparseMatMul.Options
transposeA (Boolean transposeA)
static SparseMatrixSparseMatMul.Options
transposeB (Boolean transposeB)

Metodi ereditati

Metodi pubblici

public static SparseMatrixSparseMatMul.Options adjointA (Boolean adjointA)

Parametri
adjointA Indica se "a" deve essere trasposto coniugato.

public static SparseMatrixSparseMatMul.Options adjointB (Boolean adjointB)

Parametri
aggiunto B. Indica se "b" deve essere trasposto con coniugato.

output pubblico <Object> asOutput ()

Restituisce la maniglia simbolica di un tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

output pubblico <?> c ()

Un CSRSparseMatrix.

public static SparseMatrixSparseMatMul create ( Scope scope, Operand <?> a, Operand <?> b, Class <T> type, Options ... options)

Metodo Factory per creare una classe che racchiude una nuova operazione SparseMatrixSparseMatMul.

Parametri
scopo ambito attuale
un Un CSRSparseMatrix.
b Un CSRSparseMatrix.
opzioni trasporta valori di attributi opzionali
ritorna
  • una nuova istanza di SparseMatrixSparseMatMul

public static SparseMatrixSparseMatMul.Options transposeA (Boolean transposeA)

Parametri
trasporreA Indica se è necessario trasporre "a".

public static SparseMatrixSparseMatMul.Options transposeB (Boolean transposeB)

Parametri
trasporre B. Indica se "b" deve essere trasposto.