web-dev-qa-db-fra.com

Comment imprimer la valeur d'un objet Tensor dans TensorFlow?

J'utilise l'exemple d'introduction de la multiplication de matrice dans TensorFlow.

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

Lorsque j'imprime le produit, il l'affiche sous la forme d'un objet Tensor:

<tensorflow.python.framework.ops.Tensor object at 0x10470fcd0>

Mais comment connaître la valeur de product?

Ce qui suit n'aide pas:

print product
Tensor("MatMul:0", shape=TensorShape([Dimension(1), Dimension(1)]), dtype=float32)

Je sais que les graphiques fonctionnent sur Sessions, mais n’est-il pas possible de vérifier la sortie d’un objet Tensor sans exécuter le graphique dans un session?

pythontensorflow
193
Dawny33

Le plus facile[UNE] Pour évaluer la valeur réelle d’un objet Tensor, vous devez le transmettre à la méthode Session.run() ou appeler Tensor.eval() lorsque vous avez une session par défaut (c’est-à-dire dans un bloc with tf.Session(): ou voir ci-dessous). En général[B], vous ne pouvez pas imprimer la valeur d’un tenseur sans exécuter du code dans une session.

Si vous expérimentez le modèle de programmation et souhaitez un moyen simple d’évaluer les tenseurs, le tf.InteractiveSession vous permet d’ouvrir une session au début de votre programme, puis de l’utiliser pour tous les appels Tensor.eval() (et Operation.run()). Cela peut être plus facile dans un environnement interactif, tel que Shell ou un ordinateur portable IPython, lorsqu'il est fastidieux de faire circuler un objet Session partout.

Cela peut paraître idiot pour une expression aussi petite, mais l’une des idées clés de Tensorflow est la suivante: exécution différée: il est très économique de construire une expression large et complexe, et lorsque vous voulez l’évaluer, end (auquel vous vous connectez avec une Session) est en mesure de planifier son exécution plus efficacement (par exemple, l'exécution de parties indépendantes en parallèle et l'utilisation de GPU).

[A]: Pour imprimer la valeur d'un tenseur sans la renvoyer dans votre programme Python, vous pouvez utiliser l'opérateur tf.Print() , comme le suggère Andrzej dans une autre réponse . Notez que vous devez toujours exécuter une partie du graphique pour voir la sortie de cette opération, qui est imprimée sur la sortie standard. Si vous utilisez TensorFlow distribué, tf.Print() imprimera sa sortie sur la sortie standard de la tâche sur laquelle cette opération est exécutée. Cela signifie que si vous utilisez https://colab.research.google.com par exemple, ou tout autre bloc-notes Jupyter, vous _ ne verrez pas la sortie de tf.Print() in le cahier; dans ce cas, reportez-vous à cette réponse sur comment l’obtenir pour l’imprimer encore.

[B]: Vous pouvez pouvez utiliser la fonction expérimentale tf.contrib.util.constant_value() pour obtenir la valeur d'un tenseur constant, mais il n'est pas destiné à un usage général et n'est pas défini pour de nombreux opérateurs.

190
mrry

Alors que d'autres réponses sont correctes, vous ne pouvez pas imprimer la valeur tant que vous n'avez pas évalué le graphique, mais elles ne parlent pas d'un moyen simple d'imprimer réellement une valeur à l'intérieur du graphique, une fois que vous l'avez évaluée. 

Le moyen le plus simple de visualiser la valeur d'un tenseur lorsque le graphique est évalué (à l'aide de run ou eval) consiste à utiliser l'opération Print comme dans cet exemple:

# Initialize session
import tensorflow as tf
sess = tf.InteractiveSession()

# Some tensor we want to print the value of
a = tf.constant([1.0, 3.0])

# Add print operation
a = tf.Print(a, [a], message="This is a: ")

# Add more elements of the graph using a
b = tf.add(a, a)

Maintenant, chaque fois que nous évaluons l'ensemble du graphique, par exemple en utilisant b.eval(), nous obtenons:

I tensorflow/core/kernels/logging_ops.cc:79] This is a: [1 3]
133
Andrzej Pronobis

En réitérant ce que d'autres ont dit, il n'est pas possible de vérifier les valeurs sans exécuter le graphique.

Voici un extrait de code pour ceux qui recherchent un exemple simple pour l’impression de valeurs. Le code peut être exécuté sans aucune modification dans ipython notebook

import tensorflow as tf

#define a variable to hold normal random values 
normal_rv = tf.Variable( tf.truncated_normal([2,3],stddev = 0.1))

#initialize the variable
init_op = tf.initialize_all_variables()

#run the graph
with tf.Session() as sess:
    sess.run(init_op) #execute init_op
    #print the random values that we sample
    print (sess.run(normal_rv))

Sortie:

[[-0.16702934  0.07173464 -0.04512421]
 [-0.02265321  0.06509651 -0.01419079]]
25
Jeevan

Non, vous ne pouvez pas voir le contenu du tenseur sans exécuter le graphique (en effectuant session.run()). Les seules choses que vous pouvez voir sont:

  • la dimensionnalité du tenseur (mais je suppose qu'il n'est pas difficile de le calculer pour la liste des opérations que TF a)
  • type de l'opération qui sera utilisée pour générer le tenseur (transpose_1:0, random_uniform:0)
  • type d'éléments dans le tenseur (float32)

Je n'ai pas trouvé cela dans la documentation, mais je crois que les valeurs des variables (et certaines des constantes ne sont pas calculées au moment de l'affectation).

Jetez un oeil à cet exemple:

import tensorflow as tf
from datetime import datetime
dim = 7000

Le premier exemple où je viens d’initier un tenseur constant de nombres aléatoires s’applique approximativement à la même heure, indépendamment de dim (0:00:00.003261)

startTime = datetime.now()
m1 = tf.truncated_normal([dim, dim], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1)
print datetime.now() - startTime

Dans le second cas, où la constante est effectivement évaluée et les valeurs attribuées, le temps dépend clairement de dim (0:00:01.244642)

startTime = datetime.now()
m1 = tf.truncated_normal([dim, dim], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1)
sess = tf.Session()
sess.run(m1)
print datetime.now() - startTime

Et vous pouvez le préciser en calculant quelque chose (d = tf.matrix_determinant(m1), en gardant à l’esprit que le temps s’écoulera dans O(dim^2.8))

P.S. J'ai trouvé où il est expliqué dans documentation :

Un objet Tenseur est une poignée symbolique du résultat d'une opération, mais ne contient pas réellement les valeurs de la sortie de l'opération.

19
Salvador Dali

Je pense que vous devez avoir quelques bases fondamentales. Avec les exemples ci-dessus, vous avez créé des tenseurs (tableau multidimensionnel). Mais pour que le flux de tenseurs fonctionne réellement, vous devez initier un " session " et exécuter votre " operation " dans la session. Notez le mot "session" et "operation" . Vous devez savoir 4 choses pour travailler avec tensorflow: 

  1. tenseurs
  2. Des opérations
  3. Sessions
  4. Graphiques

Maintenant, d'après ce que vous avez écrit, vous avez donné le tenseur et l'opération, mais vous n'avez pas de session en cours ni de graphique. Les tenseurs (bords du graphe) traversent les graphes et sont manipulés par des opérations (nœuds du graphe). Il existe un graphique par défaut mais vous pouvez lancer le vôtre dans une session.

Lorsque vous dites imprimer, vous accédez uniquement à la forme de la variable ou de la constante que vous avez définie.

Pour que vous puissiez voir ce qui vous manque:

 with tf.Session() as sess:     
           print(sess.run(product))
           print (product.eval())

J'espère que ça aide!

11
user29120

Dans le récent Tensorflow 1.13.1

import tensorflow as tf
tf.enable_eager_execution()
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product)         # tf.Tensor([[12.]], shape=(1, 1), dtype=float32)
print(product.numpy()) # [[12.]]

Avec Tensorflow 2.0, le mode rapide est activé par défaut. le code suivant fonctionne donc avec TF2.0.

import tensorflow as tf
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product)         # tf.Tensor([[12.]], shape=(1, 1), dtype=float32)
print(product.numpy()) # [[12.]]
8
Vishnuvardhan Janapati

D'après les réponses ci-dessus, avec votre extrait de code particulier, vous pouvez imprimer le produit comme suit:

import tensorflow as tf
#Initialize the session
sess = tf.InteractiveSession()

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product.eval())

#close the session to release resources
sess.close()
7
Ben

Vous pouvez vérifier la sortie d'un objet TensorObject sans exécuter le graphique dans une session, en activant exécution rapide .

Ajoutez simplement les deux lignes de code suivantes: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

juste après vous import tensorflow.

La sortie de print product dans votre exemple sera désormais: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Notez qu'à partir de maintenant (novembre 2017), vous devrez installer une version nocturne de Tensorflow pour permettre une exécution rapide. Des roues pré-construites peuvent être trouvées ici .

6
Giorgos Sfikas

Vous devriez penser aux programmes TensorFlow Core comme comprenant deux sections distinctes:

  • Construire le graphe de calcul.
  • Exécution du graphique de calcul.

Donc, pour le code ci-dessous, vous venez de construire le graphe de calcul. 

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

Vous devez également pouvoir initialiser toutes les variables d'un programme TensorFlow, vous devez explicitement appeler une opération spéciale comme suit:

init = tf.global_variables_initializer()

Maintenant que vous construisez le graphique et initialisez toutes les variables, l'étape suivante consiste à évaluer les nœuds. Vous devez exécuter le graphique de calcul au sein d'une session. Une session encapsule le contrôle et l'état du moteur d'exécution TensorFlow.

Le code suivant crée un objet Session, puis appelle sa méthode d'exécution pour exécuter suffisamment de graphes informatiques pour évaluer product:

sess = tf.Session()
// run variables initializer
sess.run(init)

print(sess.run([product]))
5
Ahmed Gamal

Veuillez noter que tf.Print() changera le nom du tenseur . Si le tenseur que vous souhaitez imprimer est un paramètre fictif, l’alimentation en données échouera car le nom original ne sera pas trouvé lors de l’alimentation . Par exemple:

import tensorflow as tf
tens = tf.placeholder(tf.float32,[None,2],name="placeholder")
print(eval("tens"))
tens = tf.Print(tens,[tens, tf.shape(tens)],summarize=10,message="tens:")
print(eval("tens"))
res = tens + tens
sess = tf.Session()
sess.run(tf.global_variables_initializer())

print(sess.run(res))

La sortie est:

python test.py
Tensor("placeholder:0", shape=(?, 2), dtype=float32)
Tensor("Print:0", shape=(?, 2), dtype=float32)
Traceback (most recent call last):
[...]
InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'placeholder' with dtype float
4
npit

Essayez ce code simple! (c'est explicite) 

import tensorflow as tf
sess = tf.InteractiveSession() # see the answers above :)
x = [[1.,2.,1.],[1.,1.,1.]]    # a 2D matrix as input to softmax
y = tf.nn.softmax(x)           # this is the softmax function
                               # you can have anything you like here
u = y.eval()
print(u)
3
Ganindu

tf.keras.backend.eval est utile pour évaluer de petites expressions.

_tf.keras.backends.eval(op)
_

Compatible TF 1.x et TF 2.0.

Exemple vérifiable minimal 

_from tensorflow.keras.backend import eval

m1 = tf.constant([[3., 3.]])
m2 = tf.constant([[2.],[2.]])

eval(tf.matmul(m1, m2))
# array([[12.]], dtype=float32)
_

Ceci est utile car vous n'avez pas à créer explicitement un Session ou InteractiveSession.

2
cs95

Dans Tensorflow 2.0+ (ou en mode Eager), vous pouvez appeler la méthode .numpy():

import tensorflow as tf

matrix1 = tf.constant([[3., 3.0]])
matrix2 = tf.constant([[2.0],[2.0]])
product = tf.matmul(matrix1, matrix2)

print(product.numpy())
1
Madiyar

Je ne trouvais pas facile de comprendre ce qui était nécessaire même après avoir lu toutes les réponses jusqu'à ce que je l'ait exécuté. TensofFlow est nouveau pour moi aussi.

def printtest():
x = tf.constant([1.0, 3.0])
x = tf.Print(x,[x],message="Test")
init = (tf.global_variables_initializer(), tf.local_variables_initializer())
b = tf.add(x, x)
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(b))
    sess.close()

Mais vous aurez peut-être encore besoin de la valeur retournée en exécutant la session.

def printtest():
    x = tf.constant([100.0])
    x = tf.Print(x,[x],message="Test")
    init = (tf.global_variables_initializer(), tf.local_variables_initializer())
    b = tf.add(x, x)
    with tf.Session() as sess:
        sess.run(init)
        c = sess.run(b)
        print(c)
        sess.close()
1
Mohan Radhakrishnan

Vous pouvez utiliser Keras, la réponse sur une ligne consistera à utiliser la méthode eval comme suit:

import keras.backend as K
print(K.eval(your_tensor))
1
chandresh
import tensorflow as tf
sess = tf.InteractiveSession()
x = [[1.,2.,1.],[1.,1.,1.]]    
y = tf.nn.softmax(x)           

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

print(product.eval())
tf.reset_default_graph()
sess.close()
0
Prakhar Agarwal

Active l'exécution anticipée introduite dans tensorflow après la version 1.10. C'est très facile à utiliser. 

# Initialize session
import tensorflow as tf
tf.enable_eager_execution()


# Some tensor we want to print the value of
a = tf.constant([1.0, 3.0])

print(a)
0
Aashish Dahiya

Utilisation des astuces fournies dans https://www.tensorflow.org/api_docs/python/tf/print J'utilise la fonction log_d pour imprimer des chaînes mises en forme.

import tensorflow as tf

def log_d(fmt, *args):
    op = tf.py_func(func=lambda fmt_, *args_: print(fmt%(*args_,)),
                    inp=[fmt]+[*args], Tout=[])
    return tf.control_dependencies([op])


# actual code starts now...

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

with log_d('MAT1: %s, MAT2: %s', matrix1, matrix2): # this will print the log line
    product = tf.matmul(matrix1, matrix2)

with tf.Session() as sess:
    sess.run(product)
0
Batta

Question: Comment imprimer la valeur d'un objet Tensor dans TensorFlow?

Réponse:

import tensorflow as tf

# Variable
x = tf.Variable([[1,2,3]])

# initialize
init = (tf.global_variables_initializer(), tf.local_variables_initializer())

# Create a session
sess = tf.Session()

# run the session
sess.run(init)

# print the value
sess.run(x)
0
Cyril Ivar Garcia