SparseMatrixSparseMatMul

classe finale publique SparseMatrixSparseMatMul

Sparse-matrix multiplie deux matrices CSR « a » et « b ».

Effectue une multiplication matricielle d'une matrice clairsemée « a » avec une matrice clairsemée « b » ; renvoie une matrice clairsemée `a * b`, sauf si `a` ou `b` est transposé ou adjoint.

Chaque matrice peut être transposée ou adjointe (conjuguée et transposée) selon les paramètres booléens `transpose_a`, `adjoint_a`, `transpose_b` et `adjoint_b`. Au plus un des `transpose_a` ou `adjoint_a` peut être True. De même, au plus un des éléments `transpose_b` ou `adjoint_b` peut être vrai.

Les entrées doivent avoir des formes compatibles. Autrement dit, la dimension intérieure de « a » doit être égale à la dimension extérieure de « b ». Cette exigence est ajustée selon que « a » ou « b » est transposé ou adjoint.

Le paramètre `type` désigne le type des éléments de la matrice. « a » et « b » doivent avoir le même type. Les types pris en charge sont : `float32`, `float64`, `complex64` et `complex128`.

« a » et « b » doivent avoir le même rang. La diffusion n'est pas prise en charge. S'ils ont le rang 3, chaque lot de CSRSparseMatrices 2D dans « a » et « b » doit avoir la même forme dense.

Le produit matriciel clairsemé peut avoir des zéros numériques (non structurels). À FAIRE (anudhyan) : envisagez d'ajouter un attribut booléen pour contrôler s'il faut élaguer les zéros.

Exemple d'utilisation :

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` stocke le produit matriciel dense :
[[  2.   0.   0.]
      [  0.   0.   0.]
      [ 35.  40.   0.]
      [ -4.   0.   0.]]
a : Un `CSRSparseMatrix`. b : Un `CSRSparseMatrix` avec le même type et le même rang que `a`. type : Le type de « a » et de « b ». transpose_a : Si True, `a` transposé avant la multiplication. transpose_b : Si True, `b` transposé avant la multiplication. adjoint_a : Si Vrai, `a` adjoint avant la multiplication. adjoint_b : Si Vrai, `b` adjoint avant la multiplication.

Classes imbriquées

classe SparseMatrixSparseMatMul.Options Attributs facultatifs pour SparseMatrixSparseMatMul

Constantes

Chaîne OP_NAME Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Méthodes publiques

SparseMatrixSparseMatMul.Options statique
adjointA (booléen adjointA)
SparseMatrixSparseMatMul.Options statique
adjointB (booléen adjointB)
Sortie < TType >
comme Sortie ()
Renvoie le handle symbolique du tenseur.
Sortie <?>
c ()
Un CSRSparseMatrix.
statique <T étend TType > SparseMatrixSparseMatMul
créer ( Portée de portée, Opérande <?> a, Opérande <?> b, type Class<T>, Options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération SparseMatrixSparseMatMul.
SparseMatrixSparseMatMul.Options statique
transposeA (transposeA booléenne)
SparseMatrixSparseMatMul.Options statique
transposeB (transposeB booléenne)

Méthodes héritées

Constantes

chaîne finale statique publique OP_NAME

Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Valeur constante : "SparseMatrixSparseMatMul"

Méthodes publiques

public static SparseMatrixSparseMatMul.Options adjointA (booléen adjointA)

Paramètres
adjointA Indique si « a » doit être transposé-conjugué.

public static SparseMatrixSparseMatMul.Options adjointB (booléen adjointB)

Paramètres
adjointB Indique si « b » doit être transposé conjugué.

sortie publique < TType > asOutput ()

Renvoie le handle symbolique du tenseur.

Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.

Sortie publique <?> c ()

Un CSRSparseMatrix.

public static SparseMatrixSparseMatMul créer ( Portée de la portée, Opérande <?> a, Opérande <?> b, type Class<T>, Options... options)

Méthode d'usine pour créer une classe encapsulant une nouvelle opération SparseMatrixSparseMatMul.

Paramètres
portée portée actuelle
un Un CSRSparseMatrix.
b Un CSRSparseMatrix.
choix porte des valeurs d'attributs facultatifs
Retours
  • une nouvelle instance de SparseMatrixSparseMatMul

public statique SparseMatrixSparseMatMul.Options transposeA (transposeA booléenne)

Paramètres
transposerA Indique si « a » doit être transposé.

public statique SparseMatrixSparseMatMul.Options transposeB (booléen transposeB)

Paramètres
transposerB Indique si `b` doit être transposé.