टेंसरफ्लो में टेंसर ऑब्जेक्ट के मान को प्रिंट कैसे करें?

Question

मैं टेंसरफ्लो में मैट्रिक्स गुणा के प्रारंभिक उदाहरण का उपयोग कर रहा हूं।

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 पर चलने पता है, लेकिन वहाँ किसी भी तरह से मैं एक session में ग्राफ चलने के बिना एक Tensor वस्तु के उत्पादन में जाँच कर सकते हैं नहीं है?

Answer 1

सबसे आसान * जिस तरह से एक Tensor वस्तु के वास्तविक मूल्य का मूल्यांकन करने के आप एक डिफ़ॉल्ट सत्र (एक with tf.Session(): ब्लॉक में यानी, या नीचे देखें) जब Session.run() विधि करने के लिए इसे पारित, या Tensor.eval() कॉल करने के लिए है। आम तौर पर, ** आप सत्र में कुछ कोड चलाने के बिना एक टेंसर के मान को मुद्रित नहीं कर सकते हैं।

आप प्रोग्रामिंग मॉडल के साथ प्रयोग कर रहे हैं, और tensors का मूल्यांकन करने के लिए एक आसान तरीका चाहते हैं, tf.InteractiveSession आप अपने कार्यक्रम की शुरुआत में एक सत्र को खोलने की सुविधा देता है, और तब सभी Tensor.eval() (और Operation.run()) के लिए है कि सत्र का उपयोग कहता है। यह किसी इंटरैक्टिव सेटिंग में आसान हो सकता है, जैसे शैल या आईपीथन नोटबुक, जब कहीं भी Session ऑब्जेक्ट को पास करना कठिन होता है।

इस तरह के एक छोटे से अभिव्यक्ति के लिए मूर्खतापूर्ण लग सकता है लेकिन Tensorflow में प्रमुख विचारों में से एक आस्थगित निष्पादन है: यह एक बड़े और जटिल अभिव्यक्ति का निर्माण करने की बहुत सस्ता है, और आप इसे का मूल्यांकन करना चाहते हैं, पीठ अंत (जिसे आप Session से कनेक्ट करते हैं) अपने निष्पादन को अधिक कुशलता से निर्धारित करने में सक्षम है (उदाहरण के लिए समानांतर में स्वतंत्र भागों को निष्पादित करना और GPUs का उपयोग करना)।

---

*   अपने अजगर कार्यक्रम के लिए यह लौटने के बिना एक टेन्सर का मूल्य मुद्रित करने के लिए, आप tf.Print() ऑपरेटर का उपयोग कर सकते Andrzej suggests in another answer के रूप में,। ध्यान दें कि आपको अभी भी इस आउटपुट के आउटपुट को देखने के लिए ग्राफ़ का हिस्सा चलाने की आवश्यकता है, जो मानक आउटपुट पर मुद्रित है। यदि आप वितरित TensorFlow चला रहे हैं, tf.Print() उस आउटपुट को उस कार्य के मानक आउटपुट पर प्रिंट करेगा जहां वह ऑप चलता है।

**   आप प्रयोगात्मक tf.contrib.util.constant_value() समारोह का उपयोग करने के लिए एक निरंतर टेन्सर का मूल्य प्राप्त करने में सक्षम हो सकता है, लेकिन यह सामान्य उपयोग के लिए इरादा नहीं है, और यह कई ऑपरेटरों के लिए परिभाषित नहीं है।

Answer 2

नहीं, आप ग्राफ चलाने के बिना टेंसर की सामग्री नहीं देख सकते (session.run() कर रहे हैं)।केवल बातें आप देख सकते हैं कर रहे हैं:

• टेन्सर की आयामी स्वरूप (लेकिन मुझे लगता है यह list of the operations TF है कि के लिए यह गणना करने के लिए कठिन नहीं है) आपरेशन कि उत्पन्न करने के लिए इस्तेमाल किया जाएगा की
• प्रकार टेन्सर (transpose_1:0, random_uniform:0)
• टेन्सर में तत्वों के प्रकार (float32)

मैं दस्तावेज में यह नहीं मिला है, लेकिन मुझे विश्वास है कि चरों के मान (और स्थिरांक के कुछ असाइनमेंट के समय गणना नहीं की जाती है)।

---

इस उदाहरण पर एक नज़र डालें:

import tensorflow as tf 
from datetime import datetime 
dim = 7000 

पहला उदाहरण है, जहां मैं सिर्फ यादृच्छिक संख्या की एक निरंतर टेन्सर आरंभ लगभग एक ही समय irrespectibly के मंद (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)

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) में चलेंगे)

पी एस द्वारा स्पष्ट कर सकते हैं मैं थे पाया यह documentation में समझाया गया है:

एक टेन्सर वस्तु एक ऑपरेशन, का परिणाम के लिए एक प्रतीकात्मक संभाल है, लेकिन वास्तव में आपरेशन के उत्पादन के मूल्यों नहीं रखता है।

Answer 3

जबकि अन्य उत्तरों सही हैं कि जब तक आप ग्राफ का मूल्यांकन नहीं करते हैं तब तक आप मूल्य मुद्रित नहीं कर सकते हैं, वे मूल्यांकन करने के बाद, ग्राफ के अंदर वास्तव में एक मूल्य प्रिंट करने का एक आसान तरीका नहीं बोलते हैं। अब

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

, जब भी हम पूरे का मूल्यांकन:

एक टेन्सर जब भी ग्राफ मूल्यांकन किया जाता है के एक मूल्य को देखने के लिए सबसे आसान तरीका है (run या eval का प्रयोग करके) इस उदाहरण में Print आपरेशन उपयोग करने के लिए है ग्राफ, उदाहरण के लिए b.eval() का उपयोग कर, हम पाते हैं:

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

Answer 4

दोहराते क्या अन्य लोगों ने कहा, इसकी संभव नहीं ग्राफ चलने के बिना मूल्यों की जाँच करने के लिए।

मूल्यों को मुद्रित करने के लिए आसान उदाहरण की तलाश करने वाले किसी के लिए एक साधारण स्निपेट नीचे जैसा है।कोड 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]] 

Answer 5

ऊपर जवाब, अपने विशेष कोड के साथ के आधार पर स्निपेट आप इस तरह उत्पाद मुद्रित कर सकते हैं:

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

Answer 6

इस सरल कोड को आजमाएं! (यह स्वयं व्याख्यात्मक है)

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) 

Answer 7

मुझे लगता है कि आपको कुछ बुनियादी सिद्धांतों को सही करने की आवश्यकता है। उपर्युक्त उदाहरणों के साथ आपने टेंसर (बहु आयामी सरणी) बनाई है। लेकिन वास्तव में काम करने के लिए टेंसर प्रवाह के लिए आपको "सत्र" शुरू करना होगा और सत्र में अपना "ऑपरेशन" चलाएं। "सत्र" और "ऑपरेशन" शब्द पर ध्यान दें। आप tensorflow साथ काम करने के 4 बातें पता करने की जरूरत:

1. tensors
2. संचालन
3. सत्र
4. रेखांकन

क्या तुम बाहर लिखा था आप टेन्सर दे दिया है से

अब, और ऑपरेशन लेकिन आपके पास कोई सत्र नहीं चल रहा है और न ही ग्राफ है। टेंसर (ग्राफ के किनारों) ग्राफ के माध्यम से बहते हैं और संचालन (ग्राफ के नोड्स) द्वारा छेड़छाड़ किए जाते हैं। डिफ़ॉल्ट ग्राफ है लेकिन आप सत्र में अपना आरंभ कर सकते हैं।

जब आप प्रिंट कहते हैं, तो आप केवल वेरिएबल या स्थिर परिभाषित आकार के आकार तक पहुंच सकते हैं।

तो आप देख सकते है कि तुम क्या याद कर रहे हैं:

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

आशा है कि यह मदद करता है!

Answer 8

कृपया ध्यान दें कि 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 

Answer 9

आप दो असतत वर्गों से मिलकर TensorFlow कोर कार्यक्रमों में से सोचना चाहिए:

• कम्प्यूटेशनल ग्राफ बिल्डिंग।
• कम्प्यूटेशनल ग्राफ चलाना।

तो नीचे दिए गए कोड के लिए बस कम्प्यूटेशनल ग्राफ बनाएं।

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

तुम भी जरूरत है एक TensorFlow कार्यक्रम में सभी चर को प्रारंभ करने के लिए, आप स्पष्ट रूप से इस प्रकार एक विशेष आपरेशन कॉल करना होगा:

init = tf.global_variables_initializer() 

अब आप ग्राफ के निर्माण और सभी चर प्रारंभ, अगले कदम है नोड्स का मूल्यांकन करने के लिए, आपको एक सत्र के भीतर कम्प्यूटेशनल ग्राफ को चलाना होगा। एक सत्र टेंसरफ्लो रनटाइम के नियंत्रण और स्थिति को समाहित करता है। एक सत्र में ग्राफ चलने के बिना

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

print(sess.run([product])) 

Answer 10

आप एक TensorObject के उत्पादन में देख सकते हैं:

निम्नलिखित कोड एक सत्र वस्तु बनाता है और फिर product मूल्यांकन करने के लिए कम्प्यूटेशनल ग्राफ के लिए पर्याप्त चलाने के लिए अपनी दौड़ विधि का आह्वान , eager execution सक्षम करके। आप import tensorflow के बाद सही import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

:

सीधे शब्दों में कोड की निम्न दो पंक्तियाँ जोड़ें।

अपने उदाहरण में print product के उत्पादन में अब होगा: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

ध्यान दें कि अब से (नवंबर 2017) के रूप में आप एक Tensorflow स्थापित करने के लिए हर रात को उत्सुक निष्पादन सक्षम करने के लिए का निर्माण होगा। प्री-बिल्ट व्हील here पाया जा सकता है।