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

alors que d'autres réponses sont correctes que vous ne pouvez pas Imprimer la valeur jusqu'à ce que vous évaluez le graphique, ils ne parlent pas d'une façon facile d'imprimer réellement une valeur à l'intérieur du graphique, une fois que vous l'évaluez.

la façon la plus facile de voir une valeur d'un tenseur chaque fois que le graphique est évalué (en utilisant run ou eval ) est d'utiliser le Print opération 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 évaluer le graphique entier, par exemple en utilisant b.eval() , nous obtenons:

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

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

un exemple simple pour quiconque cherche un exemple facile pour imprimer des valeurs est comme ci-dessous. Le code peut être exécuté sans aucune modification dans le bloc-notes ipython

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]]

Non, vous ne pouvez pas voir le contenu du tenseur sans exécuter le graphe (faire 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é pour générer le tenseur ( transpose_1:0 , random_uniform:0 )
• type de les éléments du 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'attribution).

regardez 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 courir environ le même temps irréspectueusement 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 sont 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 rendre plus clair en calculant quelque chose ( d = tf.matrix_determinant(m1) , en gardant à l'esprit que le temps va courir dans O(dim^2.8) )

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

un objet tenseur est une poignée symbolique au résultat d'une opération, mais ne détient pas réellement les valeurs de la sortie de l'opération.

je pense que vous avez besoin d'obtenir certains fondamentaux bien. Avec les exemples ci-dessus, vous avez créé des tenseurs (multi dimension tableau). Mais pour que le flux de tenseur fonctionne vraiment, vous devez initier une " session " et exécuter votre " opération " dans la session. Remarquez le mot "session" et "exploitation". Vous devez savoir 4 choses pour travailler avec tensorflow:

1. tenseurs
2. 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. Le tenseur (bords du graphe) traverse les graphes et est manipulé par des opérations (noeuds du graphe). Il y a un graphique par défaut mais vous pouvez lancer le vôtre dans une session.

quand vous dites imprimer , vous n'accédez qu'à la forme de la variable ou de la constante que vous avez définie.

pour que vous puissiez voir ce que vous manquez:

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

Espère que cela aide!

basé sur les réponses ci-dessus, avec votre extrait de code particulier, vous pouvez imprimer le produit comme ceci:

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()

vous devriez penser aux programmes de base TensorFlow comme se composant de deux sections distinctes:

• construire le graphe computationnel.
• exécute le graphe de calcul.

donc pour le code ci-dessous vous construisez juste le graphe de calcul.

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

vous devez également initialiser toutes les variables dans un programme TensorFlow , vous devez explicitement appeler une opération spéciale comme

init = tf.global_variables_initializer()

maintenant vous construisez le graphe et initialisé toutes les variables ,la prochaine étape est d'évaluer les noeuds, vous devez exécuter le graphe computationnel dans une session. Une session encapsule le contrôle et l'état de l'exécution TensorFlow.

le code suivant crée un objet Session et invoque ensuite sa méthode d'exécution pour exécuter suffisamment du graphe computationnel pour évaluer product :

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

print(sess.run([product]))

vous pouvez vérifier la sortie d'un TensorObject sans exécuter le graphe dans une session, en activant exécution impatiente .

il suffit d'ajouter 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 un Tensorflow construction nocturne pour permettre l'exécution impatiente. Des roues pré-construites peuvent être trouvées ici .

veuillez noter que tf.Print() changera le nom du tenseur. Si le tensor que vous cherchez à imprimer est un placeholder, l'alimentation des données à elle échouera car le nom original ne sera pas trouvé pendant 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))

sortie:

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

essayez ce code simple! (il est auto-explicatif)

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)

Je n'ai pas trouvé facile de comprendre ce qui est requis même après avoir lu toutes les réponses jusqu'à ce que j'ai exécuté ceci. 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 pouvez quand même avoir 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()

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()

fondamentalement, dans tensorflow quand vous créez un tenseur de n'importe quelle sorte ils sont créés et stockés à l'intérieur de laquelle peut être accédé seulement quand vous exécutez une session tensorflow. Dites que vous avez créé un tenseur constant

c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

Sans exécuter une session, vous pouvez obtenir

- op : Une Opération. Opération qui calcule ce tenseur.

- value_index : Un int. Index du point final de l'opération cela produit ce tenseur.

- dtype : Un DType. Type d'éléments stockés dans ce tenseur.

pour obtenir les valeurs vous pouvez exécuter une session avec le tenseur que vous avez besoin comme:

with tf.Session() as sess:
    sess.run(c)
    c.eval()

la sortie sera

2018-08-01 14:41:00.397653: I tensorflow/core/common_runtime/gpu / gpu_device.cc: 1471] ajout de dispositifs gpu visibles: 0

2018-08-01 14:41: 00.397738: I tensorflow/core/common_runtime/gpu/gpu_device. cc: 952] Dispositif d'interconnexion StreamExecutor avec une puissance de 1 bord de la matrice:

2018-08-01 14:41: 00.397759: I tensorflow/core/common_runtime/gpu/gpu_device.cc: 958] 0

2018-08-01 14:41: 00.397776: I tensorflow/core/common_runtime/gpu/gpu_device.cc: 971] 0: N

2018-08-01 14: 41:00.398018: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1084] Créé TensorFlow périphérique (/emploi:localhost/réplique:0/tâche:0/appareil:GPU:0 avec 2752 MO de mémoire) -> physique GPU (appareil: 0, nom: GeForce GTX 1050 Ti, bus pci id: 0000:01:00.0, calculer la capacité: 6.1)

array([[1., 2., 3.], [4., 5., 6.]], dtype=float32)

array([[1., 2., 3.], [4., 5., 6.]], dtype=float32)

Nous obtenons le tableau imprimé Deux fois que la session a seulement le tensor passe constante et aussi nous avons c.eval()