TensorFlow में Tensor ऑब्जेक्ट का मान कैसे प्रिंट करें?

258

मैं 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?

python tensorflow tensor

— Dawny33
स्रोत

250

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

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

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

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

[A]: अपने पायथन प्रोग्राम में लौटे बिना किसी टेंसर के मान को प्रिंट करने के लिए, आप tf.print()ऑपरेटर का उपयोग कर सकते हैं , जैसा कि एंडरेज एक अन्य उत्तर में सुझाते हैं । आधिकारिक दस्तावेज के अनुसार:

यह सुनिश्चित करने के लिए कि ऑपरेटर चलता है, उपयोगकर्ताओं को उत्पादित सेशन tf.compat.v1.Sessionविधि को पास करने की आवश्यकता होती है , या ऑप्स को निर्दिष्ट करके ऑप्सन के लिए नियंत्रण निर्भरता के रूप में उपयोग करने की आवश्यकता होती है tf.compat.v1.control_dependencies([print_op]), जो मानक आउटपुट पर मुद्रित होता है।

यह भी ध्यान दें:

जुपिटर नोटबुक और कोलाब में, tf.printनोटबुक सेल आउटपुट पर प्रिंट करता है। यह नोटबुक कर्नेल के कंसोल लॉग में नहीं लिखेगा।

[ख]: आप दिए गए टेंसर के निरंतर मूल्य को प्राप्त करने के लिए फ़ंक्शन का उपयोग करने में सक्षम हो सकते हैं tf.get_static_value()यदि इसका मूल्य कुशलता से गणना योग्य है।

— mrry
स्रोत

17

सत्र.रुण () को बुलाए बिना सेंसर की कुछ विशेषताओं को प्राप्त करना संभव है। उदाहरण के लिए, आप tanor.get_shape () कह सकते हैं। कई मामलों में, यह डीबग करने के लिए पर्याप्त जानकारी देता है।

— इयान गुडफेलो

5

इसे भी देखें और नीचे दिए गए tf.Print ऑप के बारे में जवाब। मैं "टैंसरफ़्लो प्रिंट" के लिए गुग्लिंग करते समय इस स्टैकओवरफ़्लो का उत्तर ढूंढता रहता हूं और यह शीर्ष उत्तर इसे ध्वनि देता है जैसे कोई tf.Print ऑप।

— इयान गुडफेलो

2

मैंने उत्तर के लिए कुछ प्रश्न जोड़े, इसलिए यह अब स्पष्ट होना चाहिए। (मुझे नहीं लगता है कि मूल प्रश्नकर्ता को एक टेंसर का आकार प्राप्त करने में दिलचस्पी थी, बस मूल्य।)

— 22

1

क्या सांत्वना के लिए प्रिंट के बजाय फ़ाइल को सहेजने का एक तरीका है (tf.Print के माध्यम से)?

— थांग

tf.Session()Tensorflow 2 में काम नहीं करता है। आप tf.compat.v1.Session()इसके बजाय उपयोग कर सकते हैं ।

— mic

158

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

जब भी ग्राफ का मूल्यांकन (उपयोग 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]

— आंद्रेज प्रुनोबिस
स्रोत

37

यह बहुत महत्वपूर्ण है कि आप a = tf.print से कुछ और में उपयोग करते हैं! tf.print (a, [a]) अन्यथा कुछ भी नहीं करेंगे

— Fábio Dias

5

हम a.eval()तो उपयोग कर सकते हैं !

— उदयराज देशमुख

1

@FabioDias मुझे नहीं लगता कि मुझे आपकी बात समझ में आई है? जब आपके पास समय हो तो आप कृपया विस्तार से बता सकते हैं ...

— युक्ली

7

कृपया ध्यान दें कि tf.Print()हटा दिया गया है और (अब) हटा दिया गया है। इसके बजाय उपयोग करें tf.print()। डॉक्स देखें: tanorflow.org/api_docs/python/tf/Print और tanorflow.org/api_docs/python/tf/print ।

— हेफेस्टस

1

वाह, मैं एक साल बाद @yuqli पर अपनी टिप्पणी देखकर हैरान हूं लेकिन अब मुझे उनकी बात समझ में आ रही है। इस पोस्ट को देखें , जो अभी भी अपग्रेड किए गए एपीआई के बारे में है लेकिन विचार संभवतः समान हैं।

— युकी

27

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

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

— जीवन
स्रोत

2

बस FYI करें:

WARNING:tensorflow:From <ipython-input-25-8583e1c5b3d6>:1: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02. Instructions for updating: Use 'tf.global_variables_initializer' instead.

— मार्क क्रैमर

20

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

टेंसर की गतिशीलता (लेकिन मुझे लगता है कि यह उन ऑपरेशनों की सूची के लिए गणना करना मुश्किल नहीं है जो TF है)
ऑपरेशन के प्रकार जो टेंसर ( transpose_1:0, random_uniform:0) उत्पन्न करने के लिए उपयोग किए जाएंगे
तत्वों के प्रकार में टेंसर ( float32)

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

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

import tensorflow as tf
from datetime import datetime
dim = 7000

पहला उदाहरण जहां मैं सिर्फ यादृच्छिक संख्याओं का एक निरंतर सेंसर शुरू करता हूं, लगभग एक ही समय में लगभग मंद मंद ( 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 ऑब्जेक्ट किसी ऑपरेशन के परिणाम के लिए एक प्रतीकात्मक संभाल है, लेकिन वास्तव में ऑपरेशन के आउटपुट के मूल्यों को नहीं रखता है।

— साल्वाडोर डाली
स्रोत

15

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

tensors
संचालन
सत्र
रेखांकन

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

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

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

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

आशा करता हूँ की ये काम करेगा!

— मुस्कुराओ
स्रोत

12

में 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.]]

— विष्णुवर्धन जनपति
स्रोत

1

मैंने TensorFlow संस्करण 1.13.2 स्थापित किया है और उत्सुक निष्पादन को सक्षम किया है (यदि tf.executing_eagerly () के साथ चल रहा है और त्रुटि प्राप्त कर रहा है) 'Tensor' ऑब्जेक्ट में कोई विशेषता 'numpy' नहीं है, जब कस्टम हानि फ़ंक्शन के अंदर टेंसर मान का मूल्यांकन करने का प्रयास किया गया हो। मैं वास्तव में इस मुद्दे को हल करने के लिए किसी भी मदद की सराहना करता हूं।

— निको गामुलिन

1

@NikoGamulin सुनिश्चित करें कि आपने अपनी स्क्रिप्ट की शुरुआत में tf.compat.v1.enable_eager_execution () डाल दिया है। मेरे पास संस्करण १.१४.० है, मैं PyCharm पर अपनी स्क्रिप्ट चला रहा हूं, और टेंसर.नम्पी () काम करता है

— टॉमसो डि नोटो

1

@NikoGamulin उस त्रुटि को दिखाता है जब आप ग्राफ़ मोड में किसी टेंसर तक पहुँचने का प्रयास कर रहे हों। मुझे लगता है, हो सकता है उत्सुक निष्पादन ठीक से सक्षम नहीं था। उत्सुक निष्पादन की जांच करने के लिए, बस आ = tf.constant (2.0), b = tf.constant (3.0), प्रिंट (tf.add (a, b)) को परिभाषित करें। यदि आप उत्तर को 5.0 के रूप में देखते हैं तो उत्सुकता ठीक से सक्षम थी।

— विष्णुवर्धन जनपति

9

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

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

— बेन
स्रोत

8

Tensorflow 2.0+ (या ईगर मोड वातावरण में) को आप .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())

— Madiyar
स्रोत

tf.print(product)के रूप में अच्छी तरह से मुझे print(product.numpy())TF 2.0 के साथ के रूप में एक ही उत्पादन देता है ।

— हस्बैंड

8

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)

यह उपयोगी है क्योंकि आपको स्पष्ट रूप से Sessionया बनाने की आवश्यकता नहीं है InteractiveSession।

— cs95
स्रोत

7

आप उत्सुक निष्पादन को सक्षम करके, एक सत्र में ग्राफ को चलाने के बिना एक 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 रात का निर्माण स्थापित करना होगा। यहां पहले से निर्मित पहिए देखे जा सकते हैं ।

— जियोरगोस स्फ़िकस
स्रोत

5

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

— npit
स्रोत

5

आपको TensorFlow Core कार्यक्रमों के बारे में सोचना चाहिए जिसमें दो असतत अनुभाग शामिल हैं:

कम्प्यूटेशनल ग्राफ का निर्माण।
कम्प्यूटेशनल ग्राफ चल रहा है।

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

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

— अहमद गमाल
स्रोत

4

आप केरस का उपयोग कर सकते हैं, एक-लाइन उत्तर इस evalतरह विधि का उपयोग करना होगा :

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

— सीकेएम
स्रोत

3

इस सरल कोड की कोशिश करो! (यह स्वयं व्याख्यात्मक है)

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)

— Ganindu
स्रोत

2

मुझे यह समझना आसान नहीं था कि सभी उत्तरों को पढ़ने के बाद भी क्या आवश्यक है जब तक कि मैंने इसे निष्पादित नहीं किया। 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()

— मोहन राधाकृष्णन
स्रोत

1

मूल रूप से, टेंसरफ़्लो में जब आप किसी भी प्रकार का टेंसर बनाते हैं तो वे निर्मित होते हैं और उनके अंदर संग्रहीत होते हैं, जिसे केवल टेनसफ़्लो सत्र चलाने पर ही एक्सेस किया जा सकता है। कहो कि आपने एक निरंतर टेंसर बनाया है
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)

— भास्कर चक्रधर
स्रोत

1

उत्सुक निष्पादन को सक्षम करें जो संस्करण 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)

— आशीष दहिया
स्रोत

1

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)

— बट्टा
स्रोत

0

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

— प्रखर अग्रवाल
स्रोत

0

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.

— तोरे रुडबर्ग
स्रोत

-1

प्रश्न: TensorFlow में Tensor ऑब्जेक्ट का मान कैसे प्रिंट करें?

उत्तर:

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)

— सिरिल
स्रोत