Jak wydrukować wartość obiektu Tensor w TensorFlow?

Korzystam ze wstępnego przykładu mnożenia macierzy w TensorFlow.

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

Kiedy drukuję produkt, wyświetla go jako Tensorobiekt:

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

Ale skąd mam poznać wartość product?

Następujące nie pomaga:

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

Wiem, że wykresy działają Sessions, ale czy nie ma sposobu, aby sprawdzić wynik Tensorobiektu bez uruchamiania wykresu w session?

Najłatwiejszym ^[A] sposobem oceny rzeczywistej wartości Tensorobiektu jest przekazanie go do Session.run()metody lub wywołanie, Tensor.eval()gdy masz sesję domyślną (tj. W with tf.Session():bloku lub patrz poniżej). Zasadniczo ^[B] nie można wydrukować wartości tensora bez uruchomienia kodu w sesji.

Jeśli eksperymentujesz z modelem programowania i chcesz w łatwy sposób ocenić tensory, tf.InteractiveSessionpozwala otworzyć sesję na początku programu, a następnie użyć tej sesji dla wszystkich Tensor.eval()(i Operation.run()) połączeń. Może to być łatwiejsze w ustawieniach interaktywnych, takich jak powłoka lub notatnik IPython, gdy Sessionwszędzie nużące jest przechodzenie wokół obiektu. Na przykład następujące czynności działają w notatniku Jupyter:

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

To może wydawać się głupie w przypadku tak małego wyrażenia, ale jednym z kluczowych pomysłów w Tensorflow 1.x jest odroczenie wykonania : zbudowanie dużego i złożonego wyrażenia jest bardzo tanie, a jeśli chcesz to ocenić, zaplecze (aby który łączysz za pomocą a Session) jest w stanie bardziej efektywnie zaplanować jego wykonanie (np. równoległe wykonywanie niezależnych części i używanie GPU).

[A]: Aby wydrukować wartość tensora bez zwracania go do programu w języku Python, możesz użyć tf.print()operatora, jak sugeruje Andrzej w innej odpowiedzi . Według oficjalnej dokumentacji:

Aby upewnić się, że operator działa, użytkownicy muszą przekazać wytworzoną tf.compat.v1.Sessionmetodę operacji na operację lub użyć operacji jako zależności sterującej dla wykonywanych operacji przez określenie z tf.compat.v1.control_dependencies([print_op]), która jest drukowana na standardowe wyjście.

Pamiętaj również, że:

W notesach i colabach Jupyter tf.printdrukuje na wyjściach komórek notebooka. Nie będzie zapisywać do dzienników konsoli jądra notebooka.

[B]: Użytkownik może być w stanie korzystać z tf.get_static_value()funkcji, aby uzyskać stałą wartość danego tensora jeśli jego wartość jest efektywnie obliczalne.

Podczas gdy inne odpowiedzi są poprawne, że nie można wydrukować wartości, dopóki nie oceni się wykresu, nie mówią one o jednym łatwym sposobie drukowania wartości wewnątrz wykresu, po jej oszacowaniu.

Najłatwiejszym sposobem sprawdzenia wartości tensora za każdym razem, gdy wykres jest oceniany (za pomocą runlub eval), jest użycie Printoperacji jak w tym przykładzie:

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

Teraz, ilekroć oceniamy cały wykres, np. Za pomocą b.eval(), otrzymujemy:

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

Powtarzając to, co powiedzieli inni, nie można sprawdzić wartości bez uruchomienia wykresu.

Prosty fragment dla każdego, kto szuka łatwego przykładu do wydrukowania wartości, jest przedstawiony poniżej. Kod można wykonać bez żadnych modyfikacji w notatniku 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))

Wynik:

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

Nie, nie można zobaczyć zawartości tensora bez uruchomienia wykresu (wykonanie session.run()). Jedyne, co możesz zobaczyć, to:

• wymiar tensora (ale zakładam, że nie jest trudno go obliczyć dla listy operacji, które ma TF)
• rodzaj operacji, która zostanie użyta do wygenerowania tensora ( transpose_1:0, random_uniform:0)
• rodzaj elementów w tensorze ( float32)

Nie znalazłem tego w dokumentacji, ale uważam, że wartości zmiennych (i niektórych stałych nie są obliczane w momencie przypisania).

Spójrz na ten przykład:

import tensorflow as tf
from datetime import datetime
dim = 7000

Pierwszy przykład, w którym właśnie inicjuję stały Tensor liczb losowych, działa w przybliżeniu w tym samym czasie, niezależnie od 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

W drugim przypadku, w którym obliczana jest stała, a wartości są przypisywane, czas wyraźnie zależy od 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

Możesz to wyjaśnić, obliczając coś ( d = tf.matrix_determinant(m1)pamiętając, że czas się skończy O(dim^2.8))

PS Znalazłem, że zostało to wyjaśnione w dokumentacji :

Obiekt Tensor jest symbolicznym uchwytem wyniku operacji, ale tak naprawdę nie przechowuje wartości wyniku operacji.

Myślę, że musisz dobrze zrozumieć kilka podstawowych zasad. Z powyższych przykładów stworzyłeś tensory (tablica wielowymiarowa). Ale aby przepływ tensora naprawdę zadziałał, musisz zainicjować „ sesję ” i uruchomić swoją „ operację ” w sesji. Zwróć uwagę na słowa „sesja” i „operacja”. Musisz wiedzieć 4 rzeczy do pracy z tensorflow:

1. tensory
2. Operacje
3. Sesje
4. Wykresy

Teraz z tego, co napisałeś, dałeś tensor i operację, ale nie masz uruchomionej sesji ani wykresu. Tensor (krawędzie wykresu) przepływają przez wykresy i są manipulowane przez operacje (węzły wykresu). Istnieje domyślny wykres, ale możesz go zainicjować w sesji.

Kiedy mówisz print, masz dostęp tylko do kształtu zdefiniowanej zmiennej lub stałej.

Aby zobaczyć, czego brakuje:

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

Mam nadzieję, że to pomoże!

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

W Tensorflow 2.x tryb chętny jest domyślnie włączony. więc poniższy kod działa z 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.]]

W oparciu o powyższe odpowiedzi za pomocą fragmentu kodu możesz wydrukować produkt w następujący sposób:

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

W Tensorflow 2.0+ (lub w środowisku trybu Eager) możesz wywołać .numpy()metodę:

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 jest przydatny do oceny małych wyrażeń.

tf.keras.backend.eval(op)

Kompatybilny z TF 1.x i TF 2.0.

Minimalny możliwy do zweryfikowania przykład

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)

Jest to przydatne, ponieważ nie trzeba jawnie tworzyć pliku Sessionlub InteractiveSession.

Możesz sprawdzić dane wyjściowe TensorObject bez uruchamiania wykresu w sesji, umożliwiając szybkie wykonywanie .

Po prostu dodaj następujące dwa wiersze kodu: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

zaraz za tobą import tensorflow.

Dane wyjściowe print productw twoim przykładzie będą teraz: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Pamiętaj, że od teraz (listopad 2017 r.) Będziesz musiał zainstalować kompilację nocną Tensorflow, aby umożliwić szybkie wykonanie. Gotowe koła można znaleźć tutaj .

Uwaga: tf.Print()zmieni nazwę tensora. Jeśli tensor, który chcesz wydrukować, jest symbolem zastępczym, podawanie danych do niego zakończy się niepowodzeniem, ponieważ podczas podawania nie zostanie znaleziona oryginalna nazwa. Na przykład:

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

Dane wyjściowe to:

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

Powinieneś pomyśleć o programach TensorFlow Core składających się z dwóch oddzielnych sekcji:

• Budowanie wykresu obliczeniowego.
• Uruchamianie wykresu obliczeniowego.

Tak więc dla poniższego kodu wystarczy zbudować wykres obliczeniowy.

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

Musisz także zainicjować wszystkie zmienne w programie TensorFlow, musisz jawnie wywołać specjalną operację w następujący sposób:

init = tf.global_variables_initializer()

Teraz, gdy budujesz wykres i inicjujesz wszystkie zmienne, następnym krokiem jest ocena węzłów, musisz uruchomić wykres obliczeniowy w ramach sesji. Sesja zawiera kontrolę i stan środowiska wykonawczego TensorFlow.

Poniższy kod tworzy obiekt sesji, a następnie wywołuje metodę uruchamiania, aby uruchomić wystarczającą liczbę wykresów obliczeniowych do oceny product:

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

print(sess.run([product]))

Możesz użyć Keras, odpowiedź w jednym wierszu będzie polegała na użyciu evalmetody takiej jak:

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

Wypróbuj ten prosty kod! (to jest oczywiste)

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)

Nie było mi łatwo zrozumieć, co jest wymagane, nawet po przeczytaniu wszystkich odpowiedzi, dopóki tego nie wykonałem. TensofFlow też jest dla mnie nowy.

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

Ale nadal możesz potrzebować wartości zwracanej przez wykonanie sesji.

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

Zasadniczo w tensorflow, gdy tworzysz tensor dowolnego rodzaju, są one tworzone i przechowywane w środku, do którego dostęp można uzyskać tylko po uruchomieniu sesji tensorflow. Załóżmy, że utworzyłeś stały tensor
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Bez uruchamiania sesji możesz uzyskać
- op: Operację. Operacja obliczająca ten tensor.
- value_index: Int. Indeks punktu końcowego operacji, który wytwarza ten tensor.
-dtype : A Rodzaj. Rodzaj elementów przechowywanych w tym tensorze.

Aby uzyskać wartości, możesz uruchomić sesję z wymaganym tensorem, ponieważ:

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

Wynik będzie mniej więcej taki:

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

Włącz chętne wykonywanie, które jest wprowadzane w tensorflow po wersji 1.10. Jest bardzo łatwy w użyciu.

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

Korzystając ze wskazówek zawartych w https://www.tensorflow.org/api_docs/python/tf/print używam tej log_dfunkcji do drukowania sformatowanych ciągów.

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 jest teraz przestarzałe, oto jak zamiast tego użyć tf.print (małe litery p).

Chociaż prowadzenie sesji jest dobrą opcją, nie zawsze jest to najlepsza droga. Na przykład możesz wydrukować jakiś tensor w konkretnej sesji.

Nowa metoda drukowania zwraca operację drukowania, która nie ma tensorów wyjściowych:

print_op = tf.print(tensor_to_print)

Ponieważ nie ma danych wyjściowych, nie można wstawić go do wykresu w taki sam sposób, jak w przypadku tf.Print. Zamiast tego możesz dodać go, aby kontrolować zależności w sesji, aby wydrukować.

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)

Czasami na większym wykresie, być może utworzonym częściowo w podfunkcjach, niewygodne jest propagowanie print_op do wywołania sesji. Następnie można użyć tf.tuple do powiązania operacji drukowania z inną operacją, która następnie zostanie uruchomiona z tą operacją, w zależności od tego, która sesja wykona kod. Oto jak to się robi:

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.

Pytanie: Jak wydrukować wartość obiektu Tensor w TensorFlow?

Odpowiedź:

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)