टेंसरफ्लो सरल संचालन: टेंसर बनाम पायथन चर

Question

मैं नीचे 4 भिन्नताओं के बीच व्यावहारिक मतभेदों के बारे में अनिश्चित हूं (वे सभी एक ही मूल्य का मूल्यांकन करते हैं)। मेरी समझ यह है कि अगर मैं tf पर कॉल करता हूं, तो ग्राफ पर एक ऑपरेशन बनाएगा, और अन्यथा यह हो सकता है। अगर मैं शुरुआत में tf.constant() नहीं बनाता, तो मेरा मानना ​​है कि जोड़ों को जोड़ते समय स्थिरांक बनाए जाएंगे; लेकिन tf.add(a,b) बनाम a + b जहां a और b दोनों टेंसर (# 1 और # 3) हैं, मैं डिफ़ॉल्ट नामकरण के अलावा कोई अंतर नहीं देख सकता (पूर्व Add और बाद वाला एक add है)। क्या कोई भी उन लोगों के बीच मतभेदों पर कुछ प्रकाश डाल सकता है, और प्रत्येक को कब उपयोग करना चाहिए?

## 1 
a = tf.constant(1) 
b = tf.constant(1) 
x = tf.add(a, b) 
with tf.Session() as sess: 
    x.eval() 

## 2 
a = 1 
b = 1 
x = tf.add(a, b) 
with tf.Session() as sess: 
    x.eval() 

## 3 
a = tf.constant(1) 
b = tf.constant(1) 
x = a + b 
with tf.Session() as sess: 
    x.eval() 

## 4 
a = 1 
b = tf.constant(1) 
x = a + b 
with tf.Session() as sess: 
    x.eval() 

Answer 1

आपके द्वारा दिए गए चार उदाहरण सभी एक ही परिणाम देंगे, और एक ही ग्राफ उत्पन्न करेंगे (यदि आप अनदेखा करते हैं कि ग्राफ में कुछ ऑपरेशन नाम अलग हैं)। TensorFlow कई अलग-अलग पायथन ऑब्जेक्ट्स को tf.Tensor ऑब्जेक्ट्स में परिवर्तित कर देगा जब उन्हें टेंसरफ्लो ऑपरेटर, जैसे tf.add() पर तर्क के रूप में पारित किया जाता है। + ऑपरेटर tf.add() पर बस एक साधारण रैपर है, और ओवरलोड का उपयोग तब किया जाता है जब बाएं हाथ या दाएं हाथ का तर्क tf.Tensor (या tf.Variable) होता है।

यह देखते हुए कि आप टेंसरफ्लो ऑपरेटरों को कई पाइथन ऑब्जेक्ट्स पास कर सकते हैं, आप कभी भी tf.constant() का उपयोग क्यों करेंगे? ऐसे कुछ कारण हैं:

• आप एक से अधिक विभिन्न कार्यों के लिए तर्क के रूप में एक ही अजगर वस्तु का उपयोग करते हैं, TensorFlow एक टेन्सर कई बार करने के लिए इसे परिवर्तित कर देंगे, और ग्राफ में उन लोगों के tensors से प्रत्येक का प्रतिनिधित्व करते हैं। इसलिए, यदि आपकी पायथन ऑब्जेक्ट एक बड़ी NumPy सरणी है, तो आप उस सरणी के डेटा की बहुत अधिक प्रतियां बनाते समय स्मृति से बाहर हो सकते हैं।उस मामले में, आप स्पष्ट रूप से आप अपने name संपत्ति है, जो TensorBoard डिबगिंग और ग्राफ दृश्य के लिए उपयोगी हो सकता है विज्ञापन समूह के लिए tf.constant() बनाना एक tf.Tensor एक बार

• को सरणी परिवर्तित करने के लिए इच्छा हो सकती है। (नोट करें कि डिफ़ॉल्ट TensorFlow ऑप्स सेशन के तर्क के नाम पर आधारित है, प्रत्येक स्वचालित रूप से परिवर्तित टेन्सर के लिए एक सार्थक नाम देने के लिए प्रयास करेंगे।)

• एक tf.constant() बनाना स्पष्ट रूप से आप का सही तत्व प्रकार सेट करने की अनुमति देता है टेन्सर। टेंसरफ्लो पाइथन int ऑब्जेक्ट्स को tf.int32, और float ऑब्जेक्ट्स tf.float32 में परिवर्तित करेगा। यदि आप tf.int64 या tf.float64 चाहते हैं, तो आप इसे उसी मान को tf.constant() पर पास करके और एक स्पष्ट dtype तर्क पास करके प्राप्त कर सकते हैं।

• tf.constant() समारोह भी जब एक दोहराया मूल्य के साथ बड़े tensors बनाने एक उपयोगी सुविधा प्रदान करता है:

  c = tf.constant(17.0, shape=[1024, 1024], dtype=tf.float32) 
  

  टेन्सर c ऊपर 4 * 1024 * 1024 डेटा के बाइट्स का प्रतिनिधित्व करता है, लेकिन TensorFlow में दृढ़तापूर्वक यह प्रतिनिधित्व करेंगे एक फ्लोट 17.0 प्लस आकार की जानकारी के रूप में ग्राफ़ जो इंगित करता है कि इसका अर्थ कैसे किया जाना चाहिए। यदि आपके ग्राफ में कई बड़े, भरे स्थिरांक हैं, तो यह उन्हें इस तरह से बनाने के लिए और अधिक कुशल हो सकता है।

Answer 2

वे सभी समान हैं।

एक + बी में अजगर - '+' को टेंसफोर्लो द्वारा पकड़ा जाता है और वास्तव में उसी op को उत्पन्न करता है जैसे tf.add (a, b) करता है।

tf.conctant आपको अधिक विशिष्टताओं की अनुमति देता है, जैसे कि बनाए गए टेंसर के आकार, प्रकार और नाम को परिभाषित करना। लेकिन फिर tensorflow आपके उदाहरण में "ए" का मालिक है = 1 और यह tf.constant (1) के बराबर है (इस मामले में एक इंट-वैल्यू के रूप में स्थिरता का इलाज)

Answer 3

परिणाम वही है क्योंकि प्रत्येक ऑपरेटर (add या __add__ जो + का अधिभार है) अपने ऑपरेटरों पर tf.convert_to_tensor पर कॉल करें।

tf.add(a + b) और a + b के बीच का अंतर यह है कि पूर्व आपको name पैरामीटर के साथ ऑपरेशन का नाम देने की क्षमता देता है। उत्तरार्द्ध, इसके बजाय, आपको यह क्षमता नहीं देता है और यह भी संभव बनाता है कि गणना टिन्सोर्लो पर्यावरण में पाइथन दुभाषिया द्वारा की जाती है और इसके बाहर नहीं।

ऐसा होता है अगर (और केवल अगर) a और bTensor ऑब्जेक्ट्स नहीं हैं और इस प्रकार टेन्सफोर्लो गणना में शामिल नहीं होंगे।