La multiplication des tenseurs épars est-elle implémentée dans TensorFlow?
from __future__ import print_function
import tensorflow as tf
x = tf.constant([[1.0,2.0],
[3.0,4.0]])
y = tf.SparseTensor(indices=[[0,0],[1,1]], values=[1.0,1.0], shape=[2,2])
z = tf.matmul(x,y)
sess = tf.Session()
sess.run(tf.initialize_all_variables())
print(sess.run([x, y, z]))
échoue avec le message d'erreur
TypeError: Input 'b' of 'MatMul' Op has type string that does not match type
float32 of argument 'a'
les deux tenseurs ont des valeurs de type float32 comme vu en les évaluant sans la multiplication op. La Multiplication de y avec lui-même renvoie un message d'erreur similaire. La multiplication de x avec lui-même fonctionne très bien.
4 réponses
usage Général multiplication de tf.SparseTensor n'est pas actuellement implémenté dans TensorFlow. Cependant, il y a trois solutions partielles, et la bonne dépendra des caractéristiques de vos données:
Si vous avez un
tf.SparseTensorettf.Tensor, vous pouvez utilisertf.sparse_tensor_dense_matmul()pour les multiplier. Ceci est plus efficace que l'approche suivante si l'un des tenseurs est trop grand pour entrer en mémoire lors de la densification: des conseils sur la façon de décider entre ces deux méthodes. Notez qu'il accepte untf.SparseTensorpremier argument, afin de résoudre votre problème, vous devez utiliser leadjoint_aetadjoint_barguments, et de transposer le résultat.Si vous avez deux éparses tenseurs et la nécessité de les multiplier, le plus simple (si ce n'est le plus performant) est de convertir dense et utiliser
tf.matmul:a = tf.SparseTensor(...) b = tf.SparseTensor(...) c = tf.matmul(tf.sparse_tensor_to_dense(a, 0.0), tf.sparse_tensor_to_dense(b, 0.0), a_is_sparse=True, b_is_sparse=True)Notez que l'option
a_is_sparseetb_is_sparseles arguments signifient que"a(oub) a une représentation dense mais un grand nombre de ses entrées sont nulles", ce qui déclenche l'utilisation d'un algorithme de multiplication différent.Pour le cas particulier de éparses vecteur par multiplication matricielle dense (potentiellement grande et partagée), et les valeurs dans le vecteur sont 0 ou 1, le
tf.nn.embedding_lookupopérateur peut être plus approprié. Ce tutoriel discute quand vous pouvez utiliser les incorporations et comment appeler l'opérateur plus en détail.Pour le cas particulier de éparses matrice par (potentiellement vaste et fragmenté) dense de la matrice,
tf.nn.embedding_lookup_sparse()peut être approprié. Cette fonction accepte une ou deuxtf.SparseTensorobjetssp_idsreprésentant les valeurs non nulles, et l'optionsp_weightsreprésentant leurs valeurs (par défaut à 1).
Récemment, tf.sparse_tensor_dense_matmul(...) a été ajouté qui permet de multiplier une matrice clairsemée par une matrice dense.
https://www.tensorflow.org/versions/r0.9/api_docs/python/sparse_ops.html#sparse_tensor_dense_matmul
Il semble que
tf.sparse_matmul(
a,
b,
transpose_a=None,
transpose_b=None,
a_is_sparse=None,
b_is_sparse=None,
name=None
)
n'est pas pour la multiplication de deux SparseTensors.
a et bTensorsSparseTensors. Et j'ai essayé, ça ne fonctionne pas avec SparseTensors.
Pour rendre la réponse plus complète:
tf.sparse_matmul(
a,
b,
transpose_a=None,
transpose_b=None,
a_is_sparse=None,
b_is_sparse=None,
name=None
)
existe aussi: