Tensorflow dense gradient explication?

J'ai récemment mis en œuvre un modèle et quand je l'ai couru, j'ai reçu cet avertissement:

UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. 
This may consume a large amount of memory.
"Converting sparse IndexedSlices to a dense Tensor of unknown shape. "

Avec certains paramètres (intégration dimensionnalités) tout à coup, le modèle est ridiculement lent.

  1. Ce qui fait de cet avertissement, cela implique? Il semble que quelque chose que j'ai fait a causé tous les dégradés pour être dense et donc backprop fait dense de la matrice des calculs
  2. Si c'est qu'il y a un problème avec le modèle qui est à l'origine de ce, comment puis-je identifier et de résoudre ce problème?
InformationsquelleAutor Taaam | 2016-03-09
  1. 57

    Ce message d'avertissement est affiché lorsque éparse tf.IndexedSlices objet est implicitement converti en un dense tf.Tenseur. Cela se produit généralement lorsque l'un op (généralement tf.gather()) backpropagates éparse dégradé, mais l'op qui le reçoit n'a pas spécialisé dégradé la fonction qui peut gérer éparses dégradés. En conséquence, TensorFlow automatiquement densifie la tf.IndexedSlices, ce qui peut avoir un effet dévastateur sur les performances si le tenseur est grande.

    Pour résoudre ce problème, vous devriez essayer de faire en sorte que le params d'entrée à tf.gather() (ou le params entrées à tf.nn.embedding_lookup()) est un tf.Variable. Les Variables peuvent recevoir du peu de mises à jour directement, donc aucune conversion n'est nécessaire. Bien que tf.gather() (et tf.nn.embedding_lookup()) accepter l'arbitraire tenseurs comme entrées, ce qui peut conduire à une plus compliqué les graphique, résultant de la conversion implicite.

    • Merci pour les précisions. Comment puis-je identifier les op en est la cause?
    • Le plus simple est de regarder à travers votre code pour tf.gather() ou tf.nn.embedding_lookup() invocations, trouver le tenseur t qui est le params (premier argument) soit de ceux de la fpo, et imprimer t.op. En général, vous obtiendrez les meilleures performances si t est un tf.Variable, mais certains ops comme tf.concat() ont des spécialisations qui font les gradients efficace.
    • Il semble être un boolean_mask avec un reshape. Il est utilisé dans un calcul de la perte de la mesure sur le graphe après plusieurs reshapes, packs, tiles, expand_dims, squeezes, batch_matmuls, etc. Est-il un moyen pour identifier les op(s) ne peut pas accepter éparses dégradés?
    • J'ai le même problème. Mon entrée à tf.gather est un reshape de sortie. Comment puis-je convertir Variable? Merci.
    • pour embedding_lookup, c'est bon pour avoir tf.placeholder comme param ? Je ne suis pas sûr si elles remplissent le rôle de tf.Variable
    • Je suis aussi de voir ce message d'avertissement avec un boolean_mask mais c'est juste d'être nourris de variables normales--rien n'est modifié.
    • cette erreur se produit lorsque vous utilisez des images avec de grandes dimensions..par exemple:- 8582*1920
    • avez-vous trouvé une solution à ce problème?

    InformationsquelleAutor mrry
  2. 23

    Dense Tenseur peut être considéré comme un standard de python tableau. Un éparses peut être considérée comme un ensemble d'indices et de valeurs par exemple

    # dense
array = ['a', None, None, 'c']

# sparse
array = [(0, 'a'), (3, 'c')]

    Donc, comme vous pouvez le voir si vous avez beaucoup de vide entrées d'un tableau fragmenté sera beaucoup plus efficace qu'une denses d'une. Mais si toutes les entrées sont remplies, denses est de loin plus efficace. Dans votre cas, quelque part dans le tenseur du graphe de flot de éparse tableau est converti en un dense indéterminée taille. L'avertissement est juste dire qu'il est possible que vous pouvez perdre beaucoup de mémoire comme ça. Mais il ne pourrait pas être un problème si le tableau fragmenté n'est pas trop grand/déjà assez dense.

    Si vous souhaitez en faire le diagnostic, je vous conseille de nommage de vos différents tenseur des objets, alors il sera imprimé exactement quels sont ceux qui sont utilisés dans cette conversion et vous pouvez travailler sur ce que vous pourriez être en mesure de s'adapter à l'enlever.

    InformationsquelleAutor Daniel Slater
  3. 8

    Tout à fait d'accord avec la réponse de mrry.

    En fait, je vais poster une autre solution pour ce problème.

    Vous pouvez utiliser tf.dynamic_partition() au lieu de tf.gather() pour éliminer l'avertissement.

    L'exemple de code ci-dessous:

    # Create the cells for the RNN network
lstm = tf.nn.rnn_cell.BasicLSTMCell(128)

# Get the output and state from dynamic rnn
output, state = tf.nn.dynamic_rnn(lstm, sequence, dtype=tf.float32, sequence_length = seqlen)

# Convert output to a tessor and reshape it
outputs = tf.reshape(tf.pack(output), [-1, lstm.output_size])

# Set partions to 2
num_partitions = 2

# The partitions argument is a tensor which is already fed to a placeholder.
# It is a 1-D tensor with the length of batch_size * max_sequence_length.
# In this partitions tensor, you need to set the last output idx for each seq to 1 and 
# others remain 0, so that the result could be separated to two parts,
# one is the last outputs and the other one is the non-last outputs.
res_out = tf.dynamic_partition(outputs, partitions, num_partitions)

# prediction
preds = tf.matmul(res_out[1], weights) + bias

    Espère que cela pourra vous aider.

    • dynamic_partition peut être utilisé à la place de la tf.gather(), ce qui peut être utilisé à la place de la tf.nn.embedding_lookup()?
    • Je suppose que cela ne résout pas vraiment le problème, seulement de couper le son de l'alerte. Parce qu'il ressemble à tf.dynamic_partition produit dense dégradés?
    InformationsquelleAutor AI_ROBOT