วิธีการพิมพ์ค่าของวัตถุ Tensor ใน TensorFlow?

ฉันใช้ตัวอย่างเบื้องต้นของการคูณเมทริกซ์ใน TensorFlow

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

เมื่อฉันพิมพ์ผลิตภัณฑ์จะแสดงเป็นTensorวัตถุ:

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

แต่ฉันจะรู้คุณค่าของได้productอย่างไร

ต่อไปนี้ไม่ได้ช่วย:

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

ฉันรู้ว่ากราฟทำงานSessionsแต่ไม่มีวิธีใดที่ฉันสามารถตรวจสอบผลลัพธ์ของTensorวัตถุโดยไม่เรียกใช้กราฟในsession?

วิธีที่ง่ายที่สุด^[A]ในการประเมินมูลค่าที่แท้จริงของTensorวัตถุคือการส่งผ่านไปยังSession.run()วิธีการหรือโทรTensor.eval()เมื่อคุณมีเซสชั่นเริ่มต้น (เช่นในwith tf.Session():บล็อกหรือดูด้านล่าง) โดยทั่วไป^[B]คุณไม่สามารถพิมพ์ค่าของเมตริกซ์โดยไม่ต้องใช้รหัสในเซสชัน

หากคุณกำลังทดลองกับโมเดลการเขียนโปรแกรมและต้องการวิธีที่ง่ายในการประเมินเทนเซอร์tf.InteractiveSessionให้คุณเปิดเซสชันที่จุดเริ่มต้นของโปรแกรมแล้วใช้เซสชันนั้นสำหรับการโทรTensor.eval()(และOperation.run()) ทั้งหมด สิ่งนี้สามารถทำได้ง่ายขึ้นในการตั้งค่าแบบอินเทอร์แอคทีฟเช่นเชลล์หรือโน้ตบุ๊ก IPython เมื่อมันน่าเบื่อที่จะSessionเคลื่อนที่ไปรอบ ๆวัตถุทุกที่ ตัวอย่างเช่นงานต่อไปนี้ในสมุดบันทึก Jupyter:

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

สิ่งนี้อาจดูโง่เง่าสำหรับนิพจน์ขนาดเล็ก แต่หนึ่งในแนวคิดหลักใน Tensorflow 1.x คือการดำเนินการที่ถูกเลื่อนเวลา : ราคาถูกมากในการสร้างนิพจน์ขนาดใหญ่และซับซ้อนและเมื่อคุณต้องการประเมินมันแบ็กเอนด์ (เพื่อ ซึ่งคุณเชื่อมต่อด้วยSession) สามารถกำหนดเวลาการดำเนินการได้อย่างมีประสิทธิภาพมากขึ้น (เช่นการรันชิ้นส่วนอิสระในแบบขนานและการใช้ GPU)

[A]: หากต้องการพิมพ์ค่าของเมตริกซ์โดยไม่ต้องกลับไปยังโปรแกรมหลามของคุณคุณสามารถใช้tf.print()ประกอบเป็นAndrzej แสดงให้เห็นในคำตอบอื่น ตามเอกสารอย่างเป็นทางการ:

เพื่อให้แน่ใจว่าโอเปอเรเตอร์ทำงานผู้ใช้จะต้องผ่านtf.compat.v1.Sessionวิธีการทำงานของop to 's run หรือเพื่อใช้ op เป็นตัวควบคุมการพึ่งพาสำหรับ op ที่ดำเนินการโดยระบุด้วยtf.compat.v1.control_dependencies([print_op]) ซึ่งถูกพิมพ์ไปยังเอาต์พุตมาตรฐาน

โปรดทราบว่า:

ใน Jupyter โน้ตบุ๊กและ colabs tf.printพิมพ์ไปยังเอาต์พุตของเซลล์โน้ตบุ๊ก มันจะไม่เขียนลงในบันทึกคอนโซลของเคอร์เนลโน้ตบุ๊ค

[B]: คุณอาจจะสามารถใช้tf.get_static_value()ฟังก์ชั่นเพื่อรับค่าคงที่ของเมตริกซ์ที่กำหนดหากค่าของมันสามารถคำนวณได้อย่างมีประสิทธิภาพ

ในขณะที่คำตอบอื่น ๆ นั้นถูกต้องที่คุณไม่สามารถพิมพ์ค่าได้จนกว่าคุณจะประเมินกราฟ แต่พวกเขาจะไม่พูดถึงวิธีง่ายๆในการพิมพ์ค่าในกราฟเมื่อคุณประเมินมัน

วิธีที่ง่ายที่สุดในการดูค่าของเมตริกซ์เมื่อใดก็ตามที่มีการประเมินกราฟ (โดยใช้runหรือeval) จะใช้การPrintดำเนินการตามตัวอย่างนี้:

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

ตอนนี้เมื่อใดก็ตามที่เราประเมินกราฟทั้งหมดเช่นใช้b.eval()เราจะได้รับ:

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

ยืนยันสิ่งที่คนอื่นพูดไม่สามารถตรวจสอบค่าโดยไม่เรียกใช้กราฟ

ตัวอย่างง่ายๆสำหรับทุกคนที่กำลังมองหาตัวอย่างง่ายๆในการพิมพ์ค่ามีดังนี้ รหัสสามารถดำเนินการโดยไม่มีการดัดแปลงใด ๆ ในโน๊ตบุ๊ค 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))

เอาท์พุท:

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

ไม่คุณไม่สามารถดูเนื้อหาของเมตริกซ์ได้โดยไม่ต้องเรียกใช้กราฟ (ทำsession.run()) สิ่งเดียวที่คุณเห็นคือ:

• มิติของเมตริกซ์ (แต่ฉันคิดว่ามันไม่ยากที่จะคำนวณสำหรับรายการการดำเนินการที่ TF มี)
• ประเภทของการดำเนินการที่จะใช้ในการสร้างเมตริกซ์ ( transpose_1:0, random_uniform:0)
• ประเภทขององค์ประกอบในเมตริกซ์ ( float32)

ฉันไม่พบสิ่งนี้ในเอกสาร แต่ฉันเชื่อว่าค่าของตัวแปร (และค่าคงที่บางค่าไม่ถูกคำนวณ ณ เวลาที่มอบหมาย)

ดูตัวอย่างนี้:

import tensorflow as tf
from datetime import datetime
dim = 7000

ตัวอย่างแรกที่ฉันเพิ่งเริ่ม Tensor คงที่ของตัวเลขสุ่มวิ่งประมาณเวลาเดียวกันโดยไม่คำนึงถึงสลัว ( 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

ในกรณีที่สองที่ค่าคงที่ได้รับการประเมินจริงและกำหนดค่าเวลาขึ้นอยู่กับสลัว ( 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

และคุณสามารถทำให้ชัดเจนยิ่งขึ้นโดยการคำนวณบางสิ่ง ( d = tf.matrix_determinant(m1)จำไว้ว่าเวลาจะมาO(dim^2.8))

PS ฉันพบว่ามันถูกอธิบายไว้ในเอกสาร :

วัตถุ Tensor เป็นจุดจับสัญลักษณ์ที่เป็นผลลัพธ์ของการดำเนินการ แต่จริง ๆ แล้วไม่ได้เก็บค่าของเอาต์พุตของการดำเนินการ

ฉันคิดว่าคุณต้องทำให้พื้นฐานถูกต้อง ด้วยตัวอย่างข้างต้นคุณได้สร้างเทนเซอร์ (อาร์เรย์หลายมิติ) แต่สำหรับการไหลของเมตริกซ์ในการทำงานจริง ๆ คุณต้องเริ่มต้น " เซสชั่น " และเรียกใช้ " การดำเนินการ " ของคุณในเซสชั่น สังเกตคำว่า "session" และ "operation" คุณจำเป็นต้องรู้ 4 สิ่งที่จะทำงานกับ tensorflow:

1. เทนเซอร์
2. การดำเนินงาน
3. การประชุม
4. กราฟ

ตอนนี้จากสิ่งที่คุณเขียนคุณได้ให้เมตริกซ์และการดำเนินการ แต่คุณไม่มีเซสชันที่ทำงานหรือกราฟ เทนเซอร์ (ขอบของกราฟ) ไหลผ่านกราฟและถูกควบคุมโดยการดำเนินการ (โหนดของกราฟ) มีกราฟเริ่มต้น แต่คุณสามารถเริ่มต้นของคุณในเซสชั่น

เมื่อคุณพูดพิมพ์คุณจะเข้าถึงเฉพาะรูปร่างของตัวแปรหรือค่าคงที่ที่คุณกำหนด

ดังนั้นคุณสามารถเห็นสิ่งที่คุณขาดหายไป:

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

หวังว่ามันจะช่วย!

ใน 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 โหมดกระตือรือร้นจะถูกเปิดใช้งานตามค่าเริ่มต้น ดังนั้นรหัสต่อไปนี้ทำงานร่วมกับ 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.]]

จากคำตอบข้างต้นด้วยข้อมูลโค้ดเฉพาะของคุณคุณสามารถพิมพ์ผลิตภัณฑ์ดังนี้:

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+ (หรือในสภาพแวดล้อมโหมด Eager) คุณสามารถเรียก.numpy()วิธีการ:

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 มีประโยชน์สำหรับการประเมินนิพจน์ขนาดเล็ก

tf.keras.backend.eval(op)

รองรับ TF 1.x และ TF 2.0

ตัวอย่างที่ตรวจสอบได้น้อยที่สุด

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)

นี้จะเป็นประโยชน์เพราะคุณจะได้ไม่ต้องชัดเจนสร้างหรือSessionInteractiveSession

คุณสามารถตรวจสอบผลลัพธ์ของ TensorObject โดยไม่เรียกใช้กราฟในเซสชันโดยเปิดใช้งานการประมวลผลที่กระตือรือร้นการดำเนินการกระตือรือร้น

เพียงเพิ่มโค้ดสองบรรทัดต่อไปนี้: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

ทันทีหลังจากที่คุณ import tensorflowทันทีหลังจากที่คุณ

ผลลัพธ์ของprint productตัวอย่างของคุณจะเป็น: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

โปรดทราบว่า ณ ตอนนี้ (พฤศจิกายน 2017) คุณจะต้องติดตั้ง Tensorflow nightly build เพื่อเปิดใช้งานการประมวลผลที่กระตือรือร้น ล้อที่สร้างไว้ล่วงหน้าสามารถพบได้ที่นี่

โปรดทราบว่าtf.Print()จะเปลี่ยนชื่อเทนเซอร์ หากเมตริกซ์ที่คุณต้องการพิมพ์เป็นตัวยึดตำแหน่งการป้อนข้อมูลลงในนั้นจะล้มเหลวเนื่องจากจะไม่พบชื่อเดิมในระหว่างการป้อน ตัวอย่างเช่น:

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

ผลลัพธ์คือ:

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 ซึ่งประกอบด้วยสองส่วนแยก:

• การสร้างกราฟการคำนวณ
• เรียกใช้กราฟการคำนวณ

ดังนั้นสำหรับโค้ดด้านล่างคุณเพียงแค่สร้างกราฟการคำนวณ

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

คุณต้องมีเพื่อเริ่มต้นตัวแปรทั้งหมดในโปรแกรม TensorFlow คุณต้องเรียกปฏิบัติการพิเศษอย่างชัดเจนดังนี้:

init = tf.global_variables_initializer()

ตอนนี้คุณสร้างกราฟและเริ่มต้นตัวแปรทั้งหมดแล้วขั้นตอนต่อไปคือการประเมินโหนดคุณต้องรันกราฟการคำนวณภายในเซสชัน เซสชั่นห่อหุ้มการควบคุมและสถานะของรันไทม์ TensorFlow

รหัสต่อไปนี้สร้างวัตถุเซสชันจากนั้นเรียกใช้วิธีการเรียกใช้เพื่อเรียกใช้กราฟการคำนวณเพื่อประเมินproduct:

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

print(sess.run([product]))

คุณสามารถใช้ Keras ได้คำตอบเดียวจะใช้evalวิธีดังนี้:

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

ลองใช้รหัสง่ายๆนี้! (มันเป็นคำอธิบายตัวเอง)

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)

ฉันไม่เข้าใจว่าอะไรเป็นสิ่งจำเป็นแม้หลังจากอ่านคำตอบทั้งหมดจนกว่าฉันจะทำสิ่งนี้ TensofFlow เป็นของใหม่สำหรับฉันเช่นกัน

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

แต่คุณยังอาจต้องการค่าที่ส่งคืนโดยการเรียกใช้งานเซสชัน

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

โดยทั่วไปใน tensorflow เมื่อคุณสร้างเมตริกซ์ของการเรียงลำดับใด ๆ พวกเขาจะสร้างและเก็บไว้ภายในซึ่งสามารถเข้าถึงได้เฉพาะเมื่อคุณเรียกใช้เซสชั่นแรงดึง สมมติว่าคุณได้สร้างเมตริกซ์อย่างต่อเนื่อง
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
โดยไม่ต้องเรียกใช้เซสชันคุณสามารถรับ
- op: การดำเนินการ การดำเนินการที่คำนวณเมตริกซ์นี้
- value_index: int ดัชนีของจุดสิ้นสุดของการดำเนินการที่สร้างเมตริกซ์นี้
- dtype: DType ประเภทขององค์ประกอบที่เก็บไว้ในเมตริกซ์นี้

ในการรับค่าคุณสามารถเรียกใช้เซสชันด้วยเมตริกซ์ที่คุณต้องการดังนี้

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

ผลลัพธ์จะเป็นดังนี้:

อาร์เรย์ ([[1., 2. , 3], [4. , 5. , 6. ]], dtype = float32)

เปิดใช้งานการเรียกใช้ eager ซึ่งเปิดตัวใน tensorflow หลังเวอร์ชั่น 1.10 มันใช้งานง่ายมาก

# 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ฉันใช้log_dฟังก์ชันเพื่อพิมพ์สตริงที่จัดรูปแบบ

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 เลิกใช้แล้วตอนนี้เป็นวิธีการใช้ tf.print (ตัวพิมพ์เล็ก p) แทน

ในขณะที่ใช้เซสชั่นเป็นตัวเลือกที่ดีมันไม่ได้เป็นวิธีที่จะไป ตัวอย่างเช่นคุณอาจต้องการพิมพ์เทนเซอร์ในเซสชั่นหนึ่ง

วิธีการพิมพ์ใหม่ส่งคืนการดำเนินการพิมพ์ที่ไม่มีตัวนับเอาท์พุท:

print_op = tf.print(tensor_to_print)

เนื่องจากมันไม่มีเอาต์พุตคุณจึงไม่สามารถใส่มันลงในกราฟได้เช่นเดียวกับ tf.Print แต่คุณสามารถเพิ่มเข้าไปในการควบคุมการพึ่งพาในเซสชั่นของคุณเพื่อที่จะพิมพ์

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)

บางครั้งในกราฟที่มีขนาดใหญ่กว่าอาจสร้างบางส่วนในฟังก์ชั่นย่อยมันเป็นเรื่องยุ่งยากที่จะเผยแพร่ print_op ไปยังการเรียกใช้เซสชัน จากนั้น tf.tuple สามารถใช้เพื่อจับคู่การดำเนินการพิมพ์กับการดำเนินการอื่นซึ่งจะทำงานด้วยการดำเนินการนั้นไม่ว่าเซสชันใดจะประมวลผลรหัส นี่เป็นวิธีที่ทำได้:

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.

คำถาม: วิธีการพิมพ์ค่าของวัตถุ Tensor ใน TensorFlow ได้อย่างไร

ตอบ:

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)