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

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

org.tensorflow.op.RawOp
booléen final
est égal à (Obj objet)
entier final
Opération
op ()
Renvoie cette unité de calcul sous la forme d'une seule Operation .
Chaîne finale
booléen
est égal à (Objet arg0)
Classe finale<?>
obtenirClasse ()
int
Code de hachage ()
vide final
notifier ()
vide final
notifierTous ()
Chaîne
àChaîne ()
vide final
attendre (long arg0, int arg1)
vide final
attendez (long arg0)
vide final
attendez ()
org.tensorflow.op.Op
résuméExécutionEnvironnement
env ()
Renvoie l'environnement d'exécution dans lequel cette opération a été créée.
opération abstraite
op ()
Renvoie cette unité de calcul sous la forme d'une seule Operation .
org.tensorflow.Operand
sortie abstraite < TType >
comme Sortie ()
Renvoie le handle symbolique du tenseur.
TType abstrait
asTensor ()
Renvoie le tenseur à cet opérande.
Forme abstraite
forme ()
Renvoie la forme (éventuellement partiellement connue) du tenseur auquel fait référence la Output de cet opérande.
Classe abstraite < TType >
taper ()
Renvoie le type de tenseur de cet opérande
org.tensorflow.ndarray.Shaped
abstrait entier
rang ()
Forme abstraite
forme ()
abstrait long
taille ()
Calcule et renvoie la taille totale de ce conteneur, en nombre de valeurs.

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é.