Tf.placeholder और tf.Variable के बीच क्या अंतर है?

Question

मैं TensorFlow के लिए एक नौसिखिया हूँ। मैं tf.placeholderऔर के बीच के अंतर के बारे में उलझन में हूँ tf.Variable। मेरे विचार में, tf.placeholderइनपुट डेटा के लिए उपयोग किया जाता है, और डेटा tf.Variableकी स्थिति को संग्रहीत करने के लिए उपयोग किया जाता है। यह सब मुझे पता है।

क्या कोई मुझे उनके अंतर के बारे में अधिक विस्तार से समझा सकता है? विशेष रूप से, कब उपयोग करें tf.Variableऔर कब उपयोग करें tf.placeholder?

Comments

सहज रूप से, आप Variables के संबंध में ग्रेडिएंट चाहते हैं , लेकिन placeholderएस नहीं (जिनके मान हमेशा प्रदान किए जाने चाहिए)।

— यिबो यांग

Cs231n.stanford.edu जैसा कोर्स भ्रमित करने वालों की मदद कर सकता है। मुझे यह बहुत पसंद आया! स्पष्ट रूप से अन्य हैं

— नाथन

Answer 1

संक्षेप में, आप tf.Variableअपने मॉडल के लिए ट्रेन योग्य चर जैसे कि वजन (डब्ल्यू) और बायसेज़ (बी) का उपयोग करते हैं।

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                    stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))), name='weights')

biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')

tf.placeholder का उपयोग वास्तविक प्रशिक्षण उदाहरणों को खिलाने के लिए किया जाता है।

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS))
labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

यह है कि आप प्रशिक्षण के दौरान प्रशिक्षण के उदाहरण कैसे खिलाते हैं:

for step in xrange(FLAGS.max_steps):
    feed_dict = {
       images_placeholder: images_feed,
       labels_placeholder: labels_feed,
     }
    _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)

आपका tf.variablesप्रशिक्षित किया जाएगा (संशोधित) इस प्रशिक्षण के परिणाम के रूप में।

Https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html पर अधिक देखें । (उदाहरण वेब पेज से लिए गए हैं।)

Comments

क्या होगा अगर मैं इसे खिलाने से पहले अपनी छवि बनाना चाहता हूं? (उदाहरण के विपरीत इसके विपरीत)। क्या अब मुझे इसके लिए एक चर की आवश्यकता है? यदि हां, तो क्या इसका कोई स्मृति या गति प्रभाव है?

— बस्तियान

आपके द्वारा किया जाने वाला कोई भी प्रीप्रोसेसिंग डेटा को टेंसोफ़्लो ग्राफ (यानी नेटवर्क) में फीड करने से पहले आने वाला है, ताकि काम में तकनीकी रूप से टेन्सरफ़्लो से किसी भी कोड टूल की आवश्यकता न हो। उदाहरण के लिए एक चर अनावश्यक होगा 1. क्योंकि यह इनपुट डेटा है, जो कि ग्राफ में tf.placeholders (चर नहीं) के माध्यम से पारित किया गया है और 2. पूर्वसंक्रमण इस से पहले होता है कि इसे नेटवर्क के माध्यम से वर्तमान पास के लिए प्लेसहोल्डर में लोड किया जा रहा है ।

— पॉल जीपी

बस यह नोट करना चाहता था कि मैं इस उत्तर की कितनी सराहना करता हूं। इस तथ्य के सवाल पर की तुलना में इस जवाब पर अब तक कम upvotes हैं कि बस पता चलता है कि कैसे पल-संतुष्टि लोग हो सकता है चला जाता है, और कैसे फैशनेबल टैग की तरह tensorflowऔर deep learningऔर AIकर रहे हैं।

— नाथन

Answer 2

अंतर यह है कि tf.Variableजब आप इसे घोषित करते हैं तो आपको एक प्रारंभिक मूल्य प्रदान करना होता है। tf.placeholderआप के साथ एक प्रारंभिक मूल्य प्रदान करने की जरूरत नहीं है और आप इसे feed_dictतर्क के साथ समय के अंदर निर्दिष्ट कर सकते हैंSession.run

Comments

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

— क्रिस एंडरसन

@ChrisAnderson क्या हम कह सकते हैं कि यह दृष्टांत गलत है ?! youtu.be/MotG3XI2qSs?t=136

— N0rA

@ChrisAnderson इससे क्या फर्क पड़ता है कि इसका इस्तेमाल किस लिए किया जाना चाहिए था, अगर मतभेद सिर्फ एक प्रारंभिक मूल्य की जरूरत है?

— गोल्डनेम

@Goldname यह वह नहीं है जिसका उपयोग "मतलब" के लिए किया जाना है - यह वह है जो संभव है और संभव नहीं है। वे पूरी तरह से अलग वस्तुएं हैं। वे विनिमेय नहीं हैं, और अंतर "एक प्रारंभिक मूल्य की आवश्यकता" से अधिक हैं।

— क्रिस एंडरसन

Answer 3

चूँकि Tensor Computations रेखांकन की रचना करते हैं, इसलिए रेखांकन के संदर्भ में दोनों की व्याख्या करना बेहतर है।

उदाहरण के लिए साधारण रेखीय प्रतिगमन लीजिए

WX+B=Y

कहाँ Wऔर Bवजन और पूर्वाग्रह और Xटिप्पणियों के इनपुट के Yलिए और टिप्पणियों के आउटपुट के लिए खड़े हैं ।

जाहिर है Xऔर Yएक ही प्रकृति के हैं (प्रकट चर) जो ( Wऔर Bअव्यक्त चर) से भिन्न होते हैं । Xऔर Yनमूने (प्रेक्षण) के मान हैं और इसलिए वेट और पूर्वाग्रह को भरने के लिए एक जगह की आवश्यकता होती है , Wऔर Bवजन और पूर्वाग्रह होते हैं, चर (पिछले मान बाद में प्रभावित करते हैं) जिन्हें विभिन्न Xऔर Yजोड़े का उपयोग करके प्रशिक्षित किया जाना चाहिए । Variables को प्रशिक्षित करने के लिए हम प्लेसहोल्डर्स को अलग-अलग नमूने देते हैं ।

कोड के साथ ग्राफ को बचाने या फिर से बनाने के लिए हमें केवल चर (चौकियों पर) को बचाने या पुनर्स्थापित करने की आवश्यकता है ।

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

 session.run(a_graph, dict = {a_placeholder_name : sample_values}) 

मॉडल सेट करने के लिए प्लेसहोल्डर्स को पैरामीटर के रूप में भी पास किया जाता है।

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

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

कुछ दिलचस्प मॉडल में, एक शैली हस्तांतरण मॉडल की तरह , इनपुट पिक्स को अनुकूलित किया जा रहा है और सामान्य रूप से तथाकथित मॉडल चर तय किए जाते हैं, फिर हमें इनपुट (आमतौर पर यादृच्छिक रूप से प्रारंभिक) को एक चर के रूप में उस लिंक में लागू करना चाहिए।

अधिक जानकारी के लिए कृपया इस सरल और चित्रण डॉक्टर को देखें ।

Answer 4

टी एल; डॉ

चर

• सीखने के लिए मापदंडों के लिए
• मूल्यों को प्रशिक्षण से प्राप्त किया जा सकता है
• प्रारंभिक मान आवश्यक हैं (अक्सर यादृच्छिक)

प्लेसहोल्डर

• डेटा के लिए आवंटित भंडारण (जैसे कि फ़ीड के दौरान छवि पिक्सेल डेटा के लिए)
• प्रारंभिक मानों की आवश्यकता नहीं है (लेकिन सेट किया जा सकता है, देखें tf.placeholder_with_default)

Answer 5

के बीच सबसे स्पष्ट अंतर tf.Variable और tf.placeholder कि है

---

आप मापदंडों को पकड़ने और अद्यतन करने के लिए चर का उपयोग करते हैं। चर में दसियों वाले मेमोरी बफ़र्स होते हैं। उन्हें स्पष्ट रूप से प्रारंभिक किया जाना चाहिए और प्रशिक्षण के दौरान और बाद में डिस्क पर सहेजा जा सकता है। आप बाद में मॉडल को व्यायाम या विश्लेषण करने के लिए सहेजे गए मानों को पुनर्स्थापित कर सकते हैं।

वेरिएबल्स का इनिशियलाइज़ेशन के साथ किया जाता है sess.run(tf.global_variables_initializer())। साथ ही एक वैरिएबल बनाते समय, आपको Variable()कंस्ट्रक्टर के प्रारंभिक मूल्य के रूप में एक Tensor पास करना होगा और जब आप एक वैरिएबल बनाते हैं तो आपको हमेशा अपना आकार पता होता है।

---

दूसरी ओर, आप प्लेसहोल्डर को अपडेट नहीं कर सकते। उन्हें भी आरंभीकृत नहीं किया जाना चाहिए, लेकिन क्योंकि वे एक टेंसर होने का वादा करते हैं, आपको उन्हें मूल्य खिलाने की आवश्यकता है sess.run(<op>, {a: <some_val>})। और अंत में, एक चर की तुलना में, प्लेसहोल्डर को आकार पता नहीं हो सकता है। आप या तो आयामों के कुछ हिस्सों को प्रदान कर सकते हैं या कुछ भी नहीं प्रदान कर सकते हैं।

---

वहाँ अन्य मतभेद:

• अनुकूलन के दौरान चर के अंदर के मूल्यों को अद्यतन किया जा सकता है
• चर साझा किए जा सकते हैं , और गैर-प्रशिक्षित हो सकते हैं
• चर के अंदर के मूल्यों को प्रशिक्षण के बाद संग्रहीत किया जा सकता है
• जब चर बनाया जाता है, तो 3 ऑप्स को एक ग्राफ में जोड़ा जाता है (वैरिएबल सेशन, इनिशियलाइज़र ऑप, प्रारंभिक मूल्य के लिए ऑप्स)
• प्लेसहोल्डर एक फ़ंक्शन है, परिवर्तनीय एक वर्ग है (इसलिए एक अपरकेस)
• जब आप वितरित वातावरण में TF का उपयोग करते हैं, तो चर एक विशेष स्थान ( पैरामीटर सर्वर ) में संग्रहीत होते हैं और श्रमिकों के बीच साझा किए जाते हैं।

दिलचस्प बात यह है कि न केवल प्लेसहोल्डर्स को खिलाया जा सकता है। आप वैरिएबल और यहां तक ​​कि एक स्थिर को मूल्य फ़ीड कर सकते हैं।

Answer 6

अन्य उत्तरों में जोड़ते हुए , वे टेन्सोफ्लो वेबसाइट पर इस MNIST ट्यूटोरियल में भी इसे अच्छी तरह समझाते हैं :

हम प्रतीकात्मक चरों को जोड़कर इन परस्पर क्रिया संचालन का वर्णन करते हैं। चलो एक बनाएँ:

x = tf.placeholder(tf.float32, [None, 784]),

xकोई विशिष्ट मूल्य नहीं है। यह एक प्लेसहोल्डर है, एक मान जिसे हम इनपुट करेंगे जब हम TensorFlow को एक संगणना चलाने के लिए कहते हैं। हम किसी भी संख्या में MNIST छवियों को इनपुट करने में सक्षम होना चाहते हैं, प्रत्येक 784-आयामी वेक्टर में चपटा हुआ है। हम इसे फ्लोटिंग-पॉइंट संख्याओं के 2-डी टेन्सर के रूप में दर्शाते हैं, एक आकृति [कोई नहीं, 784] के साथ। (यहां कोई भी इसका मतलब नहीं है कि एक आयाम किसी भी लंबाई का हो सकता है।)

हमें अपने मॉडल के लिए वज़न और पूर्वाग्रह भी चाहिए। हम अतिरिक्त इनपुट की तरह इनका इलाज करने की कल्पना कर सकते हैं, लेकिन TensorFlow के पास इसे संभालने का एक बेहतर तरीका है Variable:। A Variableएक परिवर्तनीय टेंसर है जो TensorFlow के परस्पर क्रिया संचालन के ग्राफ में रहता है। इसका उपयोग और अभिकलन द्वारा संशोधित भी किया जा सकता है। मशीन सीखने के अनुप्रयोगों के लिए, आम तौर पर एक मॉडल पैरामीटर होता है Variable।

W = tf.Variable(tf.zeros([784, 10]))

b = tf.Variable(tf.zeros([10]))

हम इन बनाने Variableदेकर रों tf.Variableका प्रारंभिक मूल्य Variable: इस मामले में, हम को प्रारंभ दोनों Wऔर bशून्य से भरा tensors के रूप में। चूंकि हम सीखने जा रहे हैं Wऔर bयह बहुत मायने नहीं रखता कि वे शुरू में क्या कर रहे हैं।

Comments

नमस्ते आपके उत्तर के लिए धन्यवाद! आपके द्वारा दिए गए उदाहरण में, हमारे पास xआकार है [batch size, features], हमारे पास इनपुट से लेकर आकार की पहली परत [features, hidden units]और पूर्वाग्रह तक भार है [hidden units]। तो मेरा सवाल है: हम उन्हें एक साथ कैसे गुणा करते हैं? यदि हम करते हैं tf.matmul(x, w)तो हम प्राप्त करने [batch size, hidden units]जा रहे हैं और हम इसे नहीं कर सकते हैं b, क्योंकि इसका आकार है[hidden units]

— Euler_Salter

M.Gorner अपने स्लाइडशो में यह सब बताते हैं "TensorFlow और गहरी सीखो, बिना Ph.D." इससे बेहतर मैं इस टिप्पणी में कभी कर सकता था। तो, कृपया मुझे इस स्लाइड का संदर्भ दें: docs.google.com/pretation/d/…

— टैगोमा

Answer 7

Tensorflow प्रक्रिया को स्टोर / निष्पादित करने के लिए तीन प्रकार के कंटेनरों का उपयोग करता है

1. स्थिरांक: स्थिरांक विशिष्ट डेटा रखता है।

2. चर: डेटा मान बदले जाएंगे, जैसे संबंधित कार्य जैसे cost_function ..

3. प्लेसहोल्डर: प्रशिक्षण / परीक्षण डेटा को ग्राफ़ में पास किया जाएगा।

Answer 8

उदाहरण स्निपेट:

import numpy as np
import tensorflow as tf

### Model parameters ###
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)

### Model input and output ###
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

### loss ###
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares

### optimizer ###
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

### training data ###
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]

### training loop ###
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

जैसा कि नाम कहता है प्लेसहोल्डर बाद में एक मूल्य प्रदान करने का वादा है

चर बस प्रशिक्षण पैरामीटर ( W(मैट्रिक्स), b(पूर्वाग्रह) हैं जो आपके दैनिक उपयोग में आने वाले सामान्य चर के समान हैं, जिसे ट्रेनर प्रत्येक रन / स्टेप पर अपडेट / संशोधित करता है।

जबकि प्लेसहोल्डर को किसी भी प्रारंभिक मूल्य की आवश्यकता नहीं होती है, कि जब आपने बनाया xऔर yTF को कोई मेमोरी आवंटित नहीं की, तो बाद में जब आप प्लेसहोल्डर्स को sess.run()उपयोग feed_dictमें लेते हैं, तो TensorFlow उन्हें ( xऔर y) के लिए उचित आकार की मेमोरी आवंटित करेगा - यह असंबद्ध- नेस हमें डेटा के किसी भी आकार और आकार को खिलाने की अनुमति देता है।

---

संक्षेप में :

चर - एक ऐसा पैरामीटर है जिसे आप चाहते हैं कि ट्रेनर (यानी ग्रैडिएंटसेंटेप्टिमाइज़र) प्रत्येक चरण के बाद अपडेट करें।

प्लेसहोल्डर डेमो -

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

निष्पादन:

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

उत्पादन में जिसके परिणामस्वरूप

7.5
[ 3.  7.]

पहले मामले में 3 और 4.5 के लिए पारित किया जाएगा aऔर badder_node 7. ouputting दूसरे मामले में करने के लिए क्रमश: और फिर वहाँ एक फ़ीड सूची है, पहला कदम 1 और 2, जोड़ दिया जाएगा 3 और 4 ( aऔर b)।

---

प्रासंगिक रीड:

• tf.placeholder डॉक्टर
• tf.Variable डॉक्टर।
• परिवर्तनीय VS प्लेसहोल्डर ।

Answer 9

चर

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

उदाहरण:

x = tf.Variable(3, name="x")
y = tf.Variable(4, name="y")
f = x*x*y + y + 2

यह एक संगणना ग्राफ बनाता है। चर (x और y) को आरंभीकृत किया जा सकता है और कार्य (f) का मूल्यांकन टेंसरफ़्लो सत्र में निम्नानुसार किया जा सकता है:

with tf.Session() as sess:
     x.initializer.run()
     y.initializer.run()
     result = f.eval()
print(result)
42

प्लेसहोल्डर

एक प्लेसहोल्डर एक नोड (एक चर के समान) है जिसका मूल्य भविष्य में आरम्भ किया जा सकता है। ये नोड मूल रूप से रनटाइम के दौरान उन्हें सौंपे गए मूल्य को आउटपुट करते हैं। एक प्लेसहोल्डर नोड को tf.placeholder () वर्ग का उपयोग करके सौंपा जा सकता है जिसमें आप चर और / या इसके आकार जैसे तर्क प्रदान कर सकते हैं। प्लेसहोल्डर का उपयोग मशीन लर्निंग मॉडल में प्रशिक्षण डेटासेट का प्रतिनिधित्व करने के लिए किया जाता है क्योंकि प्रशिक्षण डेटासेट बदलता रहता है।

उदाहरण:

A = tf.placeholder(tf.float32, shape=(None, 3))
B = A + 5

नोट: एक आयाम के लिए 'कोई नहीं' का अर्थ है 'कोई भी आकार'।

with tf.Session as sess:
    B_val_1 = B.eval(feed_dict={A: [[1, 2, 3]]})
    B_val_2 = B.eval(feed_dict={A: [[4, 5, 6], [7, 8, 9]]})

print(B_val_1)
[[6. 7. 8.]]
print(B_val_2)
[[9. 10. 11.]
 [12. 13. 14.]]

संदर्भ:

1. https://www.tensorflow.org/guide/variables
2. https://www.tensorflow.org/api_docs/python/tf/placeholder
3. ओ'रिली: हैंड्स-ऑन मशीन लर्निंग विद स्किकिट-लर्न एंड टेन्सरफ्लो

Answer 10

के बारे में सोचो Variableजो हम भाषाओं प्रोग्रामिंग में उपयोग एक सामान्य चर के रूप में tensorflow में। हम चर को इनिशियलाइज़ करते हैं, हम इसे बाद में भी संशोधित कर सकते हैं। जबकि placeholderप्रारंभिक मूल्य की आवश्यकता नहीं है। प्लेसहोल्डर बस भविष्य के उपयोग के लिए मेमोरी का ब्लॉक आवंटित करता है। बाद में, हम feed_dictडेटा को फीड करने के लिए उपयोग कर सकते हैं placeholder। डिफ़ॉल्ट रूप से, placeholderएक असंबद्ध आकार होता है, जो आपको एक सत्र में विभिन्न आकार के दसियों को खिलाने की अनुमति देता है। आप वैकल्पिक तर्क-पास करके विवश आकार बना सकते हैं, जैसा कि मैंने नीचे किया है।

x = tf.placeholder(tf.float32,(3,4))
y =  x + 2

sess = tf.Session()
print(sess.run(y)) # will cause an error

s = np.random.rand(3,4)
print(sess.run(y, feed_dict={x:s}))

मशीन लर्निंग कार्य करते समय, अधिकांश समय हम पंक्तियों की संख्या से अनजान होते हैं लेकिन (मान लेते हैं) हमें पता है कि कितनी संख्या में सुविधाएँ या कॉलम हैं। उस स्थिति में, हम कोई भी उपयोग नहीं कर सकते।

x = tf.placeholder(tf.float32, shape=(None,4))

अब, रन टाइम में हम किसी भी मैट्रिक्स को 4 कॉलम और किसी भी संख्या में पंक्तियों के साथ फ़ीड कर सकते हैं।

इसके अलावा, प्लेसहोल्डर का उपयोग इनपुट डेटा के लिए किया जाता है (वे एक प्रकार के चर होते हैं, जिनका उपयोग हम अपने मॉडल को खिलाने के लिए करते हैं), जहां वेरिएबल्स ऐसे मापदण्ड हैं, जिन्हें हम समय के साथ प्रशिक्षित करते हैं।

Answer 11

प्लेसहोल्डर:

1. एक प्लेसहोल्डर बस एक चर है जिसे हम बाद की तारीख में डेटा असाइन करेंगे। यह हमें अपने ऑपरेशन बनाने और डेटा की आवश्यकता के बिना, हमारे गणना ग्राफ बनाने की अनुमति देता है। TensorFlow शब्दावली में, हम फिर इन प्लेसहोल्डर्स के माध्यम से ग्राफ में डेटा फ़ीड करते हैं।

2. प्रारंभिक मानों की आवश्यकता नहीं है, लेकिन इसके साथ डिफ़ॉल्ट मान हो सकते हैं tf.placeholder_with_default)

3. हमें रनटाइम पर मूल्य प्रदान करना होगा जैसे:

   a = tf.placeholder(tf.int16) // initialize placeholder value
   b = tf.placeholder(tf.int16) // initialize placeholder value
   
   use it using session like :
   
   sess.run(add, feed_dict={a: 2, b: 3}) // this value we have to assign at runtime

चर:

1. एक TensorFlow चर साझा करने के लिए सबसे अच्छा तरीका है, आपके कार्यक्रम द्वारा निरंतर राज्य का हेरफेर।
2. चर को tf.Variable वर्ग के माध्यम से हेरफेर किया जाता है। एक tf.Variable एक टेंसर का प्रतिनिधित्व करता है जिसका मूल्य उस पर ऑप्स चलाकर बदला जा सकता है।

उदाहरण : tf.Variable("Welcome to tensorflow!!!")

Answer 12

Tensorflow 2.0 संगत उत्तर : प्लेसहोल्डर की अवधारणा, डिफ़ॉल्ट रूप से tf.placeholderउपलब्ध नहीं होगी Tensorflow 2.x (>= 2.0), क्योंकि डिफ़ॉल्ट निष्पादन मोड ईगर निष्पादन है।

हालाँकि, यदि हम Graph Mode( Disable Eager Execution) में इनका उपयोग कर सकते हैं ।

संस्करण 2.x में TF प्लेसहोल्डर के लिए समतुल्य कमांड है tf.compat.v1.placeholder।

संस्करण 2.x में TF वेरिएबल के लिए समतुल्य कमांड है tf.Variableऔर यदि आप कोड को 1.x से 2.x पर माइग्रेट करना चाहते हैं, तो समकक्ष गुण है

tf.compat.v2.Variable।

कृपया Tensorflow Version 2.0 के बारे में अधिक जानकारी के लिए इस Tensorflow Page को देखें ।

कृपया संस्करण 1.x से 2.x में प्रवासन के बारे में अधिक जानकारी के लिए प्रवासन मार्गदर्शिका देखें ।

Answer 13

एक गणना ग्राफ के बारे में सोचो । इस तरह के ग्राफ़ में, हमें अपने डेटा को ग्राफ़ में पास करने के लिए एक इनपुट नोड की आवश्यकता होती है, उन नोड्स को टेनसफ़्लो में प्लेसहोल्डर के रूप में परिभाषित किया जाना चाहिए ।

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