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

J'utilise l'exemple d'introduction de la multiplication matricielle 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 en tant Tensorqu'objet:

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

Mais comment savoir 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 Sessions, mais n'y a-t-il aucun moyen de vérifier la sortie d'un Tensorobjet sans exécuter le graphique dans un session?

La façon ^{[A] la plus} simple d'évaluer la valeur réelle d'un Tensorobjet est de la transmettre à la Session.run()méthode, ou d'appeler Tensor.eval()lorsque vous avez une session par défaut (c'est-à-dire dans un with tf.Session():bloc, 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 évaluer facilement les tenseurs, le tf.InteractiveSessionvous permet d'ouvrir une session au début de votre programme, puis d'utiliser cette session pour tous les appels Tensor.eval()(et Operation.run()). Cela peut être plus facile dans un cadre interactif, comme le shell ou un bloc-notes IPython, quand il est fastidieux de faire circuler un Sessionobjet partout. Par exemple, ce qui suit fonctionne dans un cahier Jupyter:

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

Cela peut sembler idiot pour une si petite expression, mais l'une des idées clés de Tensorflow 1.x est l' exécution différée : il est très bon marché de construire une expression grande et complexe, et lorsque vous voulez l'évaluer, le back-end (à auquel vous vous connectez a Session) est capable de planifier son exécution plus efficacement (par exemple, exécuter des parties indépendantes en parallèle et utiliser des GPU).

[A]: Pour imprimer la valeur d'un tenseur sans le retourner à votre programme Python, vous pouvez utiliser l' tf.print()opérateur, comme Andrzej le suggère dans une autre réponse . Selon la documentation officielle:

Pour s'assurer que l'opérateur s'exécute, les utilisateurs doivent passer l'op produite à tf.compat.v1.Sessionla méthode run ou utiliser l'op comme dépendance de contrôle pour les opérations exécutées en spécifiant avec tf.compat.v1.control_dependencies([print_op]), qui est imprimée sur la sortie standard.

Notez également que:

Dans les cahiers et les colabs Jupyter, tf.printimprime sur les sorties des cellules du cahier. Il n'écrira pas dans les journaux de la console du noyau du bloc-notes.

[B]: Vous pourriez être en mesure d'utiliser la tf.get_static_value()fonction pour obtenir la valeur constante du tenseur donné si sa valeur est efficacement calculable.

Bien que d'autres réponses soient correctes, vous ne pouvez pas imprimer la valeur avant d'avoir é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.

La façon la plus simple de voir une valeur d'un tenseur chaque fois que le graphique est évalué (à l'aide de runou eval) est d'utiliser l' Printopé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 évaluons 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 les autres ont dit, il n'est pas possible de vérifier les valeurs sans exécuter le graphique.

Un extrait simple pour quiconque cherche un exemple simple 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))

Production:

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

Non, vous ne pouvez pas voir le contenu du tenseur sans lancer 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 d'opération qui sera utilisé 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 pense que les valeurs des variables (et certaines des constantes ne sont pas calculées au moment de l'affectation).

Jetez un œil à 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'exécute approximativement en même temps 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 deuxième 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 s'écouler O(dim^2.8))

PS j'ai trouvé où il est expliqué dans la 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.

Je pense que vous devez bien comprendre certains principes fondamentaux. Avec les exemples ci-dessus, vous avez créé des tenseurs (tableau multidimensionnel). Mais pour que le flux du tenseur fonctionne vraiment, vous devez lancer une " session " et exécuter votre " opération " dans la session. Notez le mot «session» et «opération». Vous devez connaître 4 choses pour travailler avec tensorflow:

1. tenseurs
2. Les opérations
3. Séances
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 les opérations (nœuds du graphe). Il y a 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.

Ainsi, vous pouvez voir ce qui vous manque:

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

J'espère que ça aide!

Dans Tensorflow 1.x

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.x, le mode impatient 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.]]

Sur la base des 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()

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

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

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

tf.keras.backend.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 besoin de créer explicitement un Sessionou InteractiveSession.

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

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

juste après toi import tensorflow.

La sortie de print productdans votre exemple sera maintenant: 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 .

Veuillez noter que tf.Print()cela changera le nom du tenseur. Si le tenseur que vous cherchez à imprimer est un espace réservé, l'alimentation des données échouera car le nom d'origine 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))

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

Vous devez considérer les programmes TensorFlow Core comme consistant en deux sections distinctes:

• Construction du graphe de calcul.
• Exécution du graphe de calcul.

Donc, pour le code ci-dessous, il vous suffit de créer le graphique de calcul.

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

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

init = tf.global_variables_initializer()

Maintenant que vous créez le graphique et initialisez toutes les variables, l'étape suivante consiste à évaluer les nœuds, vous devez exécuter le graphique de calcul dans une session. Une session encapsule le contrôle et l'état du runtime TensorFlow.

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

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

print(sess.run([product]))

Vous pouvez utiliser Keras, la réponse sur une ligne consistera à utiliser une evalméthode comme celle-ci:

import keras.backend as K
print(K.eval(your_tensor))

Essayez ce code simple! (c'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'exécute cela. 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 toujours avoir besoin de la valeur renvoyé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()

Fondamentalement, dans tensorflow lorsque vous créez un tenseur de n'importe quel type, ils sont créés et stockés à l'intérieur, accessibles uniquement lorsque vous exécutez une session tensorflow. Supposons que vous ayez créé un tenseur constant
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Sans exécuter de 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 qui 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 dont vous avez besoin en tant que:

with tf.Session() as sess:
    print(sess.run(c))
    sess.close()

La sortie sera quelque chose comme ceci:

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

Activez l'exécution désirée qui est introduite dans tensorflow après la version 1.10. C'est très simple à 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)

À l'aide des conseils fournis dans https://www.tensorflow.org/api_docs/python/tf/print J'utilise la log_dfonction pour imprimer des chaînes formatées.

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)

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

tf.Print est désormais obsolète, voici comment utiliser tf.print (p minuscule) à la place.

Bien que l'exécution d'une session soit une bonne option, ce n'est pas toujours la voie à suivre. Par exemple, vous pouvez imprimer un tenseur dans une session particulière.

La nouvelle méthode d'impression renvoie une opération d'impression qui n'a pas de tenseurs de sortie:

print_op = tf.print(tensor_to_print)

Comme il n'a pas de sortie, vous ne pouvez pas l'insérer dans un graphique de la même manière que vous le feriez avec tf.Print. Au lieu de cela, vous pouvez l'ajouter pour contrôler les dépendances dans votre session afin de la faire imprimer.

sess = tf.compat.v1.Session()
with sess.as_default():
  tensor_to_print = tf.range(10)
  print_op = tf.print(tensor_to_print)
with tf.control_dependencies([print_op]):
  tripled_tensor = tensor_to_print * 3
sess.run(tripled_tensor)

Parfois, dans un graphique plus grand, peut-être créé en partie dans des sous-fonctions, il est difficile de propager le print_op à l'appel de session. Ensuite, tf.tuple peut être utilisé pour coupler l'opération d'impression avec une autre opération, qui s'exécutera ensuite avec cette opération, quelle que soit la session qui exécute le code. Voici comment procéder:

print_op = tf.print(tensor_to_print)
some_tensor_list = tf.tuple([some_tensor], control_inputs=[print_op])
# Use some_tensor_list[0] instead of any_tensor below.

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

Répondre:

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)