TensorFlow'da bir Tensor nesnesinin değeri nasıl yazdırılır?

TensorFlow'da matris çarpımının giriş örneğini kullanıyorum.

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

Ürünü yazdırdığımda, bir Tensornesne olarak görüntüleniyor :

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

Ama değerini nasıl bilebilirim product?

Aşağıdakiler yardımcı olmaz:

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

Grafikler üzerinde çalıştığını biliyorum Sessions, ama grafik bir çalıştırmadan bir Tensornesnenin çıktısını kontrol edebilirsiniz herhangi bir yolu yok sessionmu?

Bir nesnenin gerçek değerini değerlendirmenin en kolay ^[A] yolu, Tensornesneyi Session.run()yönteme iletmek veya Tensor.eval()varsayılan oturumunuz olduğunda (ör. Bir with tf.Session():blokta veya aşağıya bakın) çağırmaktır . Genel olarak ^[B] , bir oturumda kod çalıştırmadan bir tensörün değerini yazdıramazsınız.

Programlama modeliyle denemeler yapıyorsanız ve tensörleri değerlendirmenin kolay bir yolunu istiyorsanız tf.InteractiveSession, programınızın başlangıcında bir oturum açmanıza ve ardından bu oturumu tüm Tensor.eval()(ve Operation.run()) çağrılar için kullanmanıza izin verir . Kabuk veya IPython dizüstü bilgisayar gibi etkileşimli bir ortamda, Sessionher yerde bir nesnenin etrafından dolaşmak sıkıcı olduğunda bu daha kolay olabilir . Örneğin, Jupyter not defterinde aşağıdakiler çalışır:

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

Bu, küçük bir ifade için aptalca görünebilir, ancak Tensorflow 1.x'teki anahtar fikirlerden biri ertelenmiş yürütmedir : büyük ve karmaşık bir ifade oluşturmak çok ucuzdur ve değerlendirmek istediğinizde, arka uç ( a Session) ile bağlandığınızda, daha verimli bir şekilde çalışmasını programlayabilir (örn. bağımsız parçaları paralel olarak yürütmek ve GPU'ları kullanarak).

[A]: Bir tensörün değerini Python programınıza iade etmeden yazdırmak için, tf.print() , Andrzej'in başka bir cevapta önerdiği gibi operatörü . Resmi belgelere göre:

Operatörün çalıştığından emin olmak için, kullanıcıların üretilen op tf.compat.v1.Sessiontf.compat.v1.control_dependencies([print_op] çıktıya çalıştırma yöntemini , belirtilen) ile çalıştırılan ops için bir kontrol bağımlılığı olarak kullanmaları gerekir .

Ayrıca şunu da unutmayın:

Jupyter defter ve kolablarında, tf.print dizüstü bilgisayar hücre çıktılarına yazdırır. Dizüstü bilgisayar çekirdeğinin konsol günlüklerine yazılmaz.

[B]: Sen belki kullanabilmek için tf.get_static_value()değeri verimli hesaplanabilen ise verilen tensör sabit değerini almak için işlev.

Grafiği değerlendirinceye kadar değeri yazdıramayacağınız diğer yanıtlar doğruysa da, bir kez değerlendirdiğinizde, grafik içindeki bir değeri yazdırmanın kolay bir yolundan bahsetmezler.

Grafik değerlendirildiğinde ( runveya kullanılarak eval) bir tensörün değerini görmenin en kolay yolu , Printişlemi bu örnekte olduğu gibi kullanmaktır :

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

Şimdi, grafiğin tamamını değerlendirdiğimizde, örneğin kullanarak b.eval():

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

Başkalarının söylediklerini yineleyerek, grafiği çalıştırmadan değerleri kontrol etmek mümkün değildir.

Değerleri yazdırmak için kolay bir örnek arayan herkes için basit bir snippet aşağıdaki gibidir. Kod ipython not defterinde herhangi bir değişiklik yapılmadan yürütülebilir.

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

Çıktı:

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

Hayır, grafiği çalıştırmadan (yapıyor session.run()) tensörün içeriğini göremezsiniz . Görebileceğiniz tek şey:

• tensörün boyutsallığı (ancak operasyonların listesi için hesaplamanın zor olmadığını düşünüyorum) TF'nin sahip )
• tensörü ( transpose_1:0, random_uniform:0) oluşturmak için kullanılacak işlemin türü
• tensördeki elemanların türü ( float32)

Bunu dokümantasyonda bulamadım, ancak değişkenlerin değerlerinin (ve bazı sabitlerin atama sırasında hesaplanmadığına) inanıyorum.

Bu örneğe bir göz atın:

import tensorflow as tf
from datetime import datetime
dim = 7000

Rasgele sayıların sabit bir Tensörünü başlattığım ilk örnek dim ( 0:00:00.003261) 'den bağımsız olarak yaklaşık olarak aynı zamanda çalışır

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

Sabitin gerçekten değerlendirildiği ve değerlerin atandığı ikinci durumda, zaman açıkça dim ( 0:00:01.244642) 'ye bağlıdır.

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

Ve bir şeyi hesaplayarak daha açık hale getirebilirsiniz ( d = tf.matrix_determinant(m1), zamanın akacağını unutmayın O(dim^2.8))

PS buldum belgelerinde açıklanmıştır :

Bir Tensör nesnesi, bir işlemin sonucuna ilişkin sembolik bir tanıtıcıdır, ancak aslında işlemin çıktısının değerlerini tutmaz.

Bence bazı temel ilkeleri doğru yapmalısınız. Yukarıdaki örneklerle tensörler (çok boyutlu dizi) oluşturdunuz. Ancak tensör akışının gerçekten işe yaraması için bir " oturum " başlatmanız ve oturumda " operasyonunuzu " çalıştırmanız gerekir . "Oturum" ve "işlem" kelimelerine dikkat edin. Tensorflow ile çalışmak için 4 şey bilmeniz gerekir:

1. tansörler
2. Operasyonlar
3. Oturumlar
4. Grafikler

Şimdi yazdıklarınızdan tensör ve operasyon verdiniz, ancak oturumunuz veya grafiğiniz yok. Tensör (grafiğin kenarları) grafikler boyunca akar ve işlemlerle (grafiğin düğümleri) manipüle edilir. Varsayılan grafik var, ancak bir oturumu kendiniz başlatabilirsiniz.

Yazdır dediğinizde, yalnızca tanımladığınız değişken veya sabitin şekline erişirsiniz.

Böylece neyi kaçırdığınızı görebilirsiniz:

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

Umarım yardımcı olur!

İçinde 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.]]

Tensorflow 2.x ile istekli mod varsayılan olarak etkindir. bu nedenle aşağıdaki kod TF2.0 ile çalışır.

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

Yukarıdaki yanıtlara dayanarak, özel kod snippet'inizle ürünü şu şekilde yazdırabilirsiniz:

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

Tensorflow 2.0+ (veya Eager modu ortamında) .numpy()yöntemini çağırabilirsiniz :

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 küçük ifadelerin değerlendirilmesinde yararlıdır.

tf.keras.backend.eval(op)

TF 1.x ve TF 2.0 uyumlu.

Minimum Doğrulanabilir Örnek

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)

Bu yararlıdır, çünkü açıkça bir Sessionveya oluşturmak zorunda değilsiniz InteractiveSession.

İstekli yürütmeyi etkinleştirerek bir oturumda grafiği çalıştırmadan bir TensorObject çıktısını kontrol edebilirsiniz .

Aşağıdaki iki kod satırını eklemeniz yeterlidir: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

senden hemen sonra import tensorflow .

Çıktı print product şimdi: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Şimdilik (Kasım 2017), istekli bir şekilde yürütmek için bir Tensorflow gecelik derlemesi kurmanız gerektiğini unutmayın. Önceden yapılmış tekerlekleri burada bulabilirsiniz .

tf.Print()Tensör adını değiştireceğini lütfen unutmayın . Yazdırmak istediğiniz tensör bir yer tutucuysa, besleme sırasında orijinal ad bulunmayacağından, veri besleme başarısız olur. Örneğin:

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

Çıktı:

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

TensorFlow Core programlarını iki ayrı bölümden oluşuyor olarak düşünmelisiniz:

• Hesaplamalı grafik oluşturma.
• Hesaplamalı grafiği çalıştırma.

Yani aşağıdaki kod için sadece hesaplama grafiğini oluşturun.

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

Ayrıca bir TensorFlow programındaki tüm değişkenleri başlatmak için özel bir işlemi aşağıdaki gibi açıkça çağırmanız gerekir:

init = tf.global_variables_initializer()

Şimdi grafiği oluşturup tüm değişkenleri başlattınız, bir sonraki adım düğümleri değerlendirmektir, bir oturumda hesaplama grafiğini çalıştırmalısınız. Bir oturum, TensorFlow çalışma zamanının denetimini ve durumunu içerir.

Aşağıdaki kod bir Session nesnesi oluşturur ve daha sonra değerlendirmek için hesaplama grafiğinin yeterince çalışmasını sağlamak için run yöntemini çağırır product:

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

print(sess.run([product]))

Keras'ı kullanabilirsiniz, tek satırlık cevap şöyle bir evalyöntem kullanmak olacaktır :

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

Bu basit kodu deneyin! (kendi kendini açıklar)

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)

Bunu yapana kadar tüm cevapları okuduktan sonra bile neyin gerekli olduğunu anlamak kolay olmadı. TensofFlow benim için de yeni.

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

Ancak yine de oturumu yürüterek döndürülen değere ihtiyacınız olabilir.

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

Temel olarak, tensorflow'da, herhangi bir tür tensör oluşturduğunuzda, içinde yalnızca tensorflow oturumu çalıştırdığınızda erişilebilen bir tür tensör oluşturulur ve saklanır. Eğer sabit bir tensörünü oluşturduk Say
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
bir oturum çalışan olmadan, alabilirsiniz
- op: Bir Operasyonu. Bu tensörü hesaplayan işlem.
- value_index: Bir int. Bu tensörü üreten işlemin uç noktasının dizini.
- dtype: Bir DType. Bu tensörde depolanan elemanların tipi.

Değerleri almak için ihtiyacınız olan tensör ile bir oturum çalıştırabilirsiniz:

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

Çıktı şu şekilde olacaktır:

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

1.10 sürümünden sonra tensorflow'da tanıtılan istekli yürütmeyi etkinleştirin. Kullanımı çok kolay.

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

Https://www.tensorflow.org/api_docs/python/tf/print içinde sağlanan ipuçlarını kullanarak , log_dbiçimlendirilmiş dizeleri yazdırmak için işlevi kullanırım.

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 artık kullanımdan kaldırılmıştır, bunun yerine tf.print (küçük harf p) nasıl kullanılacağı aşağıda açıklanmıştır.

Bir seans yürütmek iyi bir seçenektir, ancak bu her zaman bir yol değildir. Örneğin, belirli bir oturumda bir tensör yazdırmak isteyebilirsiniz.

Yeni yazdırma yöntemi, çıkış tensörü olmayan bir yazdırma işlemi döndürür:

print_op = tf.print(tensor_to_print)

Çıktısı olmadığından, tf.Print ile aynı şekilde bir grafiğe ekleyemezsiniz. Bunun yerine, yazdırmak için oturumunuzdaki bağımlılıkları kontrol etmek için ekleyebilirsiniz.

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)

Bazen, daha büyük bir grafikte, kısmen alt işlevlerde yaratılabilir, print_op'u oturum çağrısına yaymak zahmetlidir. Daha sonra, tf.tuple, yazdırma işlemini başka bir işlemle eşleştirmek için kullanılabilir; bu işlem daha sonra hangi oturum kodu çalıştırırsa o işlemle çalışacaktır. İşte böyle yapılır:

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.

Soru: TensorFlow'da bir Tensor nesnesinin değeri nasıl yazdırılır?

Cevap:

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)