Bagaimana cara mencetak nilai objek Tensor di TensorFlow?

Saya telah menggunakan contoh pengantar multiplikasi matriks di TensorFlow.

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

Ketika saya mencetak produk, itu menampilkannya sebagai Tensorobjek:

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

Tapi bagaimana saya tahu nilainya product ?

Berikut ini tidak membantu:

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

Saya tahu bahwa grafik berjalan Sessions, tetapi tidak adakah cara saya dapat memeriksa output dari suatu Tensorobjek tanpa menjalankan grafik dalam session?

Cara ^[A] termudah untuk mengevaluasi nilai aktual suatu Tensorobjek adalah dengan meneruskannya ke Session.run()metode, atau menelepon Tensor.eval()ketika Anda memiliki sesi default (yaitu dalam sebuah with tf.Session():blok, atau lihat di bawah). Secara umum ^[B] , Anda tidak dapat mencetak nilai tensor tanpa menjalankan beberapa kode dalam satu sesi.

Jika Anda bereksperimen dengan model pemrograman, dan ingin cara mudah untuk mengevaluasi tensor, tf.InteractiveSessionmemungkinkan Anda membuka sesi di awal program Anda, dan kemudian menggunakan sesi itu untuk semua Tensor.eval()(dan Operation.run()) panggilan. Ini bisa lebih mudah dalam pengaturan interaktif, seperti shell atau notebook IPython, ketika itu membosankan untuk berkeliling Sessionobjek di mana-mana. Sebagai contoh, berikut ini bekerja di notebook Jupyter:

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

Ini mungkin tampak konyol untuk ekspresi sekecil itu, tetapi salah satu ide kunci dalam Tensorflow 1.x adalah eksekusi yang ditunda : sangat murah untuk membangun ekspresi yang besar dan kompleks, dan ketika Anda ingin mengevaluasinya, back-end (untuk yang Anda hubungkan dengan a Session) dapat menjadwalkan pelaksanaannya secara lebih efisien (mis. mengeksekusi bagian independen secara paralel dan menggunakan GPU).

[A]: Untuk mencetak nilai tensor tanpa mengembalikannya ke program Python Anda, Anda dapat menggunakan tf.print()operator, seperti yang disarankan Andrzej dalam jawaban lain . Menurut dokumentasi resmi:

Untuk memastikan operator berjalan, pengguna harus meneruskan tf.compat.v1.Sessionmetode operasi yang dijalankan ke op, atau menggunakan op sebagai ketergantungan kontrol untuk operasi yang dijalankan dengan menentukan dengan tf.compat.v1.control_dependencies([print_op],), yang dicetak ke output standar.

Perhatikan juga bahwa:

Dalam buku catatan dan colab Jupyter, tf.printdicetak ke keluaran sel buku catatan. Itu tidak akan menulis ke log konsol kernel notebook.

[B]: Anda mungkin dapat menggunakan tf.get_static_value()fungsi untuk mendapatkan nilai konstan dari tensor yang diberikan jika nilainya dapat dihitung secara efisien.

Sementara jawaban lain benar bahwa Anda tidak dapat mencetak nilai sampai Anda mengevaluasi grafik, mereka tidak berbicara tentang satu cara mudah untuk benar-benar mencetak nilai di dalam grafik, setelah Anda mengevaluasinya.

Cara termudah untuk melihat nilai tensor setiap kali grafik dievaluasi (menggunakan runatau eval) adalah dengan menggunakanPrint operasi seperti dalam contoh ini:

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

Sekarang, setiap kali kita mengevaluasi seluruh grafik, misalnya menggunakan b.eval(), kita mendapatkan:

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

Mengulangi apa yang orang lain katakan, itu tidak mungkin untuk memeriksa nilai-nilai tanpa menjalankan grafik.

Cuplikan sederhana untuk siapa saja yang mencari contoh mudah untuk mencetak nilai adalah seperti di bawah ini. Kode ini dapat dijalankan tanpa modifikasi di notebook 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))

Keluaran:

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

Tidak, Anda tidak dapat melihat konten tensor tanpa menjalankan grafik (melakukan session.run()). Satu-satunya hal yang dapat Anda lihat adalah:

• dimensi tensor (tapi saya berasumsi tidak sulit untuk menghitungnya untuk daftar operasi yang dimiliki TF)
• jenis operasi yang akan digunakan untuk menghasilkan tensor ( transpose_1:0,random_uniform:0 )
• jenis elemen dalam tensor ( float32)

Saya belum menemukan ini dalam dokumentasi, tetapi saya percaya bahwa nilai-nilai variabel (dan beberapa konstanta tidak dihitung pada saat penugasan).

Lihatlah contoh ini:

import tensorflow as tf
from datetime import datetime
dim = 7000

Contoh pertama di mana saya baru saja memulai Tensor konstan angka acak berjalan kira-kira waktu yang sama terlepas dari redup ( 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

Dalam kasus kedua, di mana konstanta sebenarnya dievaluasi dan nilai-nilai diberikan, waktu jelas tergantung pada redup ( 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

Dan Anda dapat membuatnya lebih jelas dengan menghitung sesuatu ( d = tf.matrix_determinant(m1), dengan mengingat bahwa waktu akan berjalan O(dim^2.8))

PS yang saya temukan kalau dijelaskan dalam dokumentasi :

Objek Tensor adalah pegangan simbolik untuk hasil operasi, tetapi tidak benar-benar memegang nilai-nilai output operasi.

Saya pikir Anda perlu mendapatkan beberapa dasar yang benar. Dengan contoh di atas, Anda telah membuat tensor (array multi dimensi). Tetapi agar aliran tensor benar-benar berfungsi, Anda harus memulai " sesi " dan menjalankan " operasi " Anda di sesi. Perhatikan kata "sesi" dan "operasi". Anda perlu tahu 4 hal untuk bekerja dengan tensorflow:

1. tensor
2. Operasi
3. Sesi
4. Grafik

Sekarang dari apa yang Anda tuliskan Anda telah memberikan tensor, dan operasi tetapi Anda tidak memiliki sesi berjalan atau grafik. Tensor (tepi grafik) mengalir melalui grafik dan dimanipulasi oleh operasi (node ​​grafik). Ada grafik default tetapi Anda dapat memulai grafik Anda dalam satu sesi.

Ketika Anda mengatakan cetak, Anda hanya mengakses bentuk variabel atau konstanta yang Anda tetapkan.

Jadi Anda dapat melihat apa yang Anda lewatkan:

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

Semoga ini bisa membantu!

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

Dengan Tensorflow 2.x, mode eager diaktifkan secara default. jadi kode berikut berfungsi dengan 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.]]

Berdasarkan jawaban di atas, dengan potongan kode khusus Anda, Anda dapat mencetak produk seperti ini:

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

Di Tensorflow 2.0+ (atau dalam lingkungan mode Eager) Anda dapat memanggil .numpy()metode:

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 berguna untuk mengevaluasi ekspresi kecil.

tf.keras.backend.eval(op)

TF 1.x dan TF 2.0 kompatibel.

Contoh Minimal yang Dapat Diverifikasi

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)

Ini berguna karena Anda tidak harus membuat Sessionatau InteractiveSession.

Anda dapat memeriksa output dari sebuah TensorObject tanpa menjalankan grafik dalam satu sesi, dengan mengaktifkan eksekusi yang cepat .

Cukup tambahkan dua baris kode berikut: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

tepat setelah anda import tensorflow.

Output dari print productdalam contoh Anda sekarang akan menjadi: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Perhatikan bahwa mulai sekarang (November 2017) Anda harus menginstal Tensorflow nightly build untuk mengaktifkan eksekusi yang cepat. Roda pre-built dapat ditemukan di sini .

Harap dicatat bahwa tf.Print()akan mengubah nama tensor. Jika tensor yang ingin Anda cetak adalah placeholder, memasukkan data ke itu akan gagal karena nama aslinya tidak akan ditemukan selama makan. Sebagai contoh:

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

Output adalah:

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

Anda harus menganggap program TensorFlow Core sebagai terdiri dari dua bagian terpisah:

• Membangun grafik komputasi.
• Menjalankan grafik komputasi.

Jadi untuk kode di bawah ini, Anda cukup Bangun grafik komputasi.

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

Anda juga perlu menginisialisasi semua variabel dalam program TensorFlow, Anda harus secara eksplisit memanggil operasi khusus sebagai berikut:

init = tf.global_variables_initializer()

Sekarang Anda membangun grafik dan menginisialisasi semua variabel, langkah selanjutnya adalah mengevaluasi node, Anda harus menjalankan grafik komputasi dalam suatu sesi. Sesi merangkum kontrol dan keadaan runtime TensorFlow.

Kode berikut membuat objek Sesi dan kemudian memanggil metode menjalankannya untuk menjalankan grafik komputasi yang cukup untuk dievaluasi product:

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

print(sess.run([product]))

Anda dapat menggunakan Keras, jawaban satu baris adalah menggunakan evalmetode seperti:

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

Coba kode sederhana ini! (Cukup jelas)

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)

Saya tidak merasa mudah untuk memahami apa yang diperlukan bahkan setelah membaca semua jawaban sampai saya menjalankan ini. TensofFlow juga baru bagi saya.

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

Namun Anda tetap membutuhkan nilai yang dikembalikan dengan menjalankan sesi.

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

Pada dasarnya, dalam tensorflow ketika Anda membuat tensor dalam bentuk apa pun, mereka dibuat dan disimpan di dalamnya yang hanya dapat diakses ketika Anda menjalankan sesi tensorflow. Katakanlah Anda telah membuat tensor konstan
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Tanpa menjalankan sesi, Anda bisa mendapatkan
- op: Suatu Operasi. Operasi yang menghitung tensor ini.
- value_index: Int. Indeks titik akhir operasi yang menghasilkan tensor ini.
- dtype: DType. Jenis elemen yang disimpan dalam tensor ini.

Untuk mendapatkan nilai, Anda dapat menjalankan sesi dengan tensor yang Anda butuhkan sebagai:

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

Outputnya akan seperti ini:

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

Aktifkan eksekusi bersemangat yang diperkenalkan di tensorflow setelah versi 1.10. Ini sangat mudah digunakan.

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

Menggunakan tips yang disediakan di https://www.tensorflow.org/api_docs/python/tf/print Saya menggunakan log_dfungsi ini untuk mencetak string yang diformat.

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 sekarang sudah tidak digunakan lagi, inilah cara menggunakan tf.print (huruf kecil) sebagai gantinya.

Meskipun menjalankan sesi adalah pilihan yang baik, itu tidak selalu merupakan jalan yang harus dilalui. Misalnya, Anda mungkin ingin mencetak beberapa tensor dalam sesi tertentu.

Metode cetak baru mengembalikan operasi cetak yang tidak memiliki tensor keluaran:

print_op = tf.print(tensor_to_print)

Karena tidak memiliki output, Anda tidak dapat memasukkannya dalam grafik dengan cara yang sama seperti yang Anda lakukan dengan tf.Print. Sebagai gantinya, Anda dapat menambahkannya untuk mengontrol dependensi di sesi Anda untuk membuatnya dicetak.

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)

Terkadang, dalam grafik yang lebih besar, mungkin dibuat sebagian dalam subfungsi, sulit untuk menyebarkan print_op ke panggilan sesi. Kemudian, tf.tuple dapat digunakan untuk memasangkan operasi cetak dengan operasi lain, yang kemudian akan berjalan dengan operasi itu di mana sesi sesi mengeksekusi kode. Begini cara melakukannya:

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.

Pertanyaan: Bagaimana cara mencetak nilai objek Tensor di TensorFlow?

Menjawab:

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)