Làm thế nào để in giá trị của một đối tượng Tensor trong TensorFlow?

Tôi đã sử dụng ví dụ giới thiệu về phép nhân ma trận trong TensorFlow.

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

Khi tôi in sản phẩm, nó sẽ hiển thị dưới dạng Tensorđối tượng:

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

Nhưng làm thế nào để tôi biết giá trị của product?

Những điều sau đây không giúp ích gì:

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

Tôi biết rằng đồ thị chạy trên Sessions, nhưng không có cách nào tôi có thể kiểm tra đầu ra của một Tensorđối tượng mà không chạy đồ thị trong một session?

Cách ^[A] dễ nhất để đánh giá giá trị thực của Tensorđối tượng là truyền nó cho Session.run()phương thức hoặc gọi Tensor.eval()khi bạn có phiên mặc định (nghĩa là trong một with tf.Session():khối, hoặc xem bên dưới). Nói chung ^[B] , bạn không thể in giá trị của tenxơ mà không chạy một số mã trong phiên.

Nếu bạn đang thử nghiệm mô hình lập trình và muốn một cách dễ dàng để đánh giá các tenxơ, thì tf.InteractiveSessioncho phép bạn mở một phiên khi bắt đầu chương trình, sau đó sử dụng phiên đó cho tất cả các cuộc gọi Tensor.eval()(và Operation.run()). Điều này có thể dễ dàng hơn trong một cài đặt tương tác, chẳng hạn như vỏ hoặc sổ ghi chép IPython, khi việc đi vòng quanh một Sessionvật thể ở khắp mọi nơi thật tẻ nhạt . Ví dụ: các công việc sau đây trong sổ ghi chép Jupyter:

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

Điều này có vẻ ngớ ngẩn đối với một biểu thức nhỏ như vậy, nhưng một trong những ý tưởng chính trong Tensorflow 1.x bị trì hoãn thực thi : rất rẻ để xây dựng một biểu thức lớn và phức tạp, và khi bạn muốn đánh giá nó, back-end mà bạn kết nối với a Session) có thể lên lịch thực hiện nó hiệu quả hơn (ví dụ: thực hiện song song các phần độc lập và sử dụng GPU).

[A]: Để in giá trị của một tenxơ mà không trả lại cho chương trình Python của bạn, bạn có thể sử dụng tf.print()toán tử, như Andrzej gợi ý trong một câu trả lời khác . Theo tài liệu chính thức:

Để đảm bảo toán tử chạy, người dùng cần truyền tf.compat.v1.Sessionphương thức chạy op được sản xuất hoặc sử dụng op làm phụ thuộc điều khiển cho op thực thi bằng cách chỉ định với tf.compat.v1.control_dependencies([print_op]), được in ra đầu ra tiêu chuẩn.

Cũng lưu ý rằng:

Trong sổ ghi chép Jupyter và bảng màu, tf.printin ra các đầu ra ô của sổ ghi chép. Nó sẽ không ghi vào nhật ký giao diện điều khiển của kernel.

[B]: Bạn có thể sử dụng tf.get_static_value()hàm để lấy giá trị không đổi của tenxơ đã cho nếu giá trị của nó có thể tính toán hiệu quả.

Mặc dù các câu trả lời khác là chính xác mà bạn không thể in giá trị cho đến khi bạn đánh giá biểu đồ, chúng không nói về một cách dễ dàng thực sự in một giá trị bên trong biểu đồ, một khi bạn đánh giá nó.

Cách dễ nhất để xem giá trị của một tenxơ bất cứ khi nào đồ thị được ước tính (sử dụng runhoặc eval) là sử dụng Printthao tác như trong ví dụ này:

# 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ây giờ, bất cứ khi nào chúng tôi đánh giá toàn bộ biểu đồ, ví dụ như sử dụng b.eval(), chúng tôi sẽ nhận được:

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

Lặp lại những gì người khác nói, không thể kiểm tra các giá trị mà không chạy biểu đồ.

Một đoạn mã đơn giản cho bất cứ ai đang tìm kiếm một ví dụ dễ dàng để in các giá trị như dưới đây. Mã có thể được thực thi mà không cần sửa đổi trong sổ ghi chép 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))

Đầu ra:

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

Không, bạn không thể xem nội dung của tenxơ mà không chạy biểu đồ (đang làm session.run()). Những điều duy nhất bạn có thể thấy là:

• kích thước của tenxơ (nhưng tôi cho rằng không khó để tính toán nó cho danh sách các hoạt động mà TF có)
• loại hoạt động sẽ được sử dụng để tạo ra tenxơ ( transpose_1:0, random_uniform:0)
• loại phần tử trong tenor ( float32)

Tôi chưa tìm thấy điều này trong tài liệu, nhưng tôi tin rằng các giá trị của các biến (và một số hằng số không được tính tại thời điểm gán).

Hãy xem ví dụ này:

import tensorflow as tf
from datetime import datetime
dim = 7000

Ví dụ đầu tiên trong đó tôi chỉ khởi tạo một Số lượng ngẫu nhiên các số ngẫu nhiên chạy xấp xỉ cùng thời gian không thể hiểu được của 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

Trong trường hợp thứ hai, trong đó hằng số thực sự được ước tính và các giá trị được gán, thời gian rõ ràng phụ thuộc vào 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

Và bạn có thể làm cho nó rõ ràng hơn bằng cách tính toán một cái gì đó ( d = tf.matrix_determinant(m1), hãy nhớ rằng thời gian sẽ trôi quaO(dim^2.8) )

PS tôi tìm thấy nó được giải thích trong tài liệu :

Một đối tượng Tensor là một điều khiển tượng trưng cho kết quả của một hoạt động, nhưng thực tế không giữ các giá trị đầu ra của hoạt động.

Tôi nghĩ rằng bạn cần phải có được một số nguyên tắc cơ bản đúng. Với các ví dụ ở trên, bạn đã tạo ra các tenxơ (mảng đa chiều). Nhưng để luồng tenor thực sự hoạt động, bạn phải bắt đầu một " phiên " và chạy " hoạt động " của mình trong phiên. Lưu ý từ "phiên" và "hoạt động". Bạn cần biết 4 điều để làm việc với tenorflow:

1. tenxơ
2. Hoạt động
3. Phiên
4. Đồ thị

Bây giờ từ những gì bạn đã viết ra, bạn đã đưa ra tenxơ, và thao tác nhưng bạn không có phiên nào chạy hay biểu đồ. Tenor (các cạnh của biểu đồ) chảy qua các biểu đồ và được thao tác bằng các thao tác (các nút của biểu đồ). Có biểu đồ mặc định nhưng bạn có thể bắt đầu biểu đồ của mình trong một phiên.

Khi bạn nói in, bạn chỉ truy cập hình dạng của biến hoặc hằng bạn đã xác định.

Vì vậy, bạn có thể thấy những gì bạn đang thiếu:

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

Hy vọng nó giúp!

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

Với Tensorflow 2.x, chế độ háo hức được bật theo mặc định. vì vậy đoạn mã sau hoạt động với 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.]]

Dựa trên các câu trả lời ở trên, với đoạn mã cụ thể của bạn, bạn có thể in sản phẩm như thế này:

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

Trong Tensorflow 2.0+ (hoặc trong môi trường chế độ Eager), bạn có thể gọi .numpy()phương thức:

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 rất hữu ích để đánh giá các biểu thức nhỏ.

tf.keras.backend.eval(op)

Tương thích TF 1.x và TF 2.0.

Ví dụ kiểm chứng tối thiểu

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)

Điều này rất hữu ích vì bạn không nhất thiết phải tạo một Sessionhoặc InteractiveSession.

Bạn có thể kiểm tra đầu ra của TensorObject mà không cần chạy biểu đồ trong một phiên, bằng cách cho phép thực thi háo hức .

Chỉ cần thêm hai dòng mã sau: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

ngay sau khi bạn import tensorflow.

Đầu ra của print product ví dụ của bạn bây giờ sẽ là: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Lưu ý rằng kể từ bây giờ (tháng 11 năm 2017), bạn sẽ phải cài đặt bản dựng hàng đêm cho phép thực hiện háo hức. Bánh xe dựng sẵn có thể được tìm thấy ở đây .

Xin lưu ý rằng tf.Print()sẽ thay đổi tên tenor. Nếu tenor bạn tìm cách in là một trình giữ chỗ, dữ liệu cấp dữ liệu cho nó sẽ thất bại vì tên gốc sẽ không được tìm thấy trong khi cho ăn. Ví dụ:

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

Đầu ra là:

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

Bạn nên nghĩ về các chương trình TensorFlow Core bao gồm hai phần riêng biệt:

• Xây dựng đồ thị tính toán.
• Chạy đồ thị tính toán.

Vì vậy, đối với mã bên dưới, bạn chỉ cần Xây dựng biểu đồ tính toán.

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

Bạn cũng cần Để khởi tạo tất cả các biến trong chương trình TensorFlow, bạn phải gọi một thao tác đặc biệt như sau:

init = tf.global_variables_initializer()

Bây giờ bạn xây dựng biểu đồ và khởi tạo tất cả các biến, bước tiếp theo là đánh giá các nút, bạn phải chạy biểu đồ tính toán trong một phiên. Một phiên đóng gói kiểm soát và trạng thái của thời gian chạy TensorFlow.

Đoạn mã sau tạo một đối tượng Phiên và sau đó gọi phương thức chạy của nó để chạy đủ biểu đồ tính toán để đánh giá product:

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

print(sess.run([product]))

Bạn có thể sử dụng Keras, câu trả lời một dòng sẽ là sử dụng evalphương thức như vậy:

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

Hãy thử mã đơn giản này! (nó tự giải thích)

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)

Tôi không thấy dễ hiểu những gì được yêu cầu ngay cả sau khi đọc tất cả các câu trả lời cho đến khi tôi thực hiện điều này. TensofFlow cũng mới đối với tôi.

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

Nhưng bạn vẫn có thể cần giá trị trả về bằng cách thực hiện phiên.

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

Về cơ bản, trong tenorflow khi bạn tạo một tenor của bất kỳ loại nào chúng được tạo và lưu trữ bên trong chỉ có thể được truy cập khi bạn chạy một phiên tenorflow. Giả sử bạn đã tạo một tenxơ không đổi
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
mà không cần chạy phiên, bạn có thể nhận được
- op: Một hoạt động. Hoạt động tính toán tenxơ này.
- value_index: Một int. Chỉ số điểm cuối của hoạt động tạo ra tenxơ này.
- dtype: Một loại. Loại phần tử được lưu trữ trong tenor này.

Để có được các giá trị, bạn có thể chạy một phiên với tenxơ bạn yêu cầu như:

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

Đầu ra sẽ giống như thế này:

mảng ([[1., 2., 3.], [4., 5., 6.]], dtype = float32)

Cho phép thực thi háo hức được giới thiệu trong tenorflow sau phiên bản 1.10. Nó rất dễ sử dụng.

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

Sử dụng các mẹo được cung cấp trong https://www.tensorflow.org/api_docs/python/tf/print Tôi sử dụng log_dchức năng để in các chuỗi được định dạng.

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 hiện không được dùng nữa, đây là cách sử dụng tf.print (chữ thường p) thay thế.

Mặc dù chạy một phiên là một lựa chọn tốt, nhưng nó không phải luôn luôn là cách để đi. Chẳng hạn, bạn có thể muốn in một số tenor trong một phiên cụ thể.

Phương thức in mới trả về thao tác in không có tenxơ đầu ra:

print_op = tf.print(tensor_to_print)

Vì nó không có đầu ra, bạn không thể chèn nó vào biểu đồ theo cách tương tự như với tf.Print. Thay vào đó, bạn có thể thêm nó để kiểm soát các phụ thuộc trong phiên của mình để làm cho nó được in.

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)

Đôi khi, trong một biểu đồ lớn hơn, có thể được tạo một phần trong các hàm con, việc truyền bá print_op vào lệnh gọi phiên là rất khó khăn. Sau đó, tf.tuple có thể được sử dụng để ghép thao tác in với thao tác khác, sau đó sẽ chạy với thao tác đó bất kỳ phiên nào thực thi mã. Đây là cách thực hiện:

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.

Câu hỏi: Làm thế nào để in giá trị của một đối tượng Tensor trong TensorFlow?

Câu trả lời:

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)