दिलचस्प पोस्ट
पायथन: urllib2.urlopen कॉल से HTTP हेडर प्राप्त करें? C # में स्ट्रिंग फ़ॉर्मेटिंग नामांकित प्रतिबंध केवल एक रिकॉर्ड के लिए डिफ़ॉल्ट के रूप में चिह्नित है लाइब्रेरी लोड नहीं हुई: libmysqlclient.16.dylib त्रुटि जब mysql2 मणि ​​के साथ ओएस एक्स 10.6 पर 'रेल सर्वर' को चलाने की कोशिश कर रहा है अंतरिक्ष वर्ण से इनपुट से स्ट्रिंग पढ़ना? किसी दूसरे वर्ग से प्रवेश फार्म घटक सी # का उपयोग करते हुए Excel फ़ाइल के डेटा को कैसे पढ़ें? सबसे अच्छा ओपन सोर्स जावा चार्टिंग लाइब्रेरी क्या है? (jfreechart के अलावा) एक बुलियन / स्ट्रिंग नक्शा के लिए फ़ायरबेज रीसायकलउपएडैप्टर को युग्लिंग CSS का उपयोग करते हुए वैकल्पिक तालिका पंक्ति का रंग? एंड्रॉइड ऐप में पीडीएफ कैसे बनाएं? अजगर setup.py बनाम बनाम स्थापित करें कोणीय सामग्री में एमडी-डेडेक्कर का प्रारूप बदलें क्षैतिजस्क्रॉलदृश्य: जब नया दृश्य जोड़े जाते हैं तो ऑटो-स्क्रॉल समाप्त हो जाता है? जीडीबी के साथ प्रोग्राम के मुख्य डंप फ़ाइल का विश्लेषण कैसे करें?

नाम का अंतर और tensorflow में एक चर गुंजाइश क्या है?

इन कार्यों के बीच अंतर क्या है?

tf.variable_op_scope(values, name, default_name, initializer=None)

वेरिएबल बनाता है एक सेशन परिभाषित करने के लिए एक संदर्भ प्रबंधक लौटाता है यह संदर्भ प्रबंधक पुष्टि करता है कि दिए गए मान समान ग्राफ़ से हैं, यह सुनिश्चित करता है कि आलेख डिफ़ॉल्ट ग्राफ़ है, और एक नाम का दायरा और एक चर गुंजाइश


tf.op_scope(values, name, default_name=None)

पायथन ऑप परिभाषित करते समय उपयोग के लिए एक संदर्भ प्रबंधक लौटाता है यह संदर्भ प्रबंधक पुष्टि करता है कि दिए गए मान समान ग्राफ़ से हैं, यह सुनिश्चित करता है कि आलेख डिफ़ॉल्ट ग्राफ़ है, और एक नाम का दायरा देता है


tf.name_scope(name)

Graph.name_scope() लिए रैपर। Graph.name_scope() डिफ़ॉल्ट ग्राफ का उपयोग कर। अधिक जानकारी के लिए Graph.name_scope() देखें।


tf.variable_scope(name_or_scope, reuse=None, initializer=None)

वेरिएबल गुंजाइश के लिए एक संदर्भ देता है। परिवर्तनीय गुंजाइश नए चर बनाने की अनुमति देता है और पहले से तैयार किए गए शेयरों को साझा करने की अनुमति देता है, जबकि दुर्घटना के कारण या नहीं साझा करने के लिए चेक प्रदान करते हैं। विवरण के लिए, वेरिएबल स्कोप देखें कि कैसे, यहां हम केवल कुछ बुनियादी उदाहरण प्रस्तुत करते हैं।

वेब के समाधान से एकत्रित समाधान "नाम का अंतर और tensorflow में एक चर गुंजाइश क्या है?"

चलो शुरू करने के लिए एक संक्षिप्त परिचय द्वारा चर साझाकरण। यह TensorFlow में एक तंत्र है जो कोड के विभिन्न हिस्सों में उपयोग किए जाने वाले वेरिएबल्स को चारों ओर चर के संदर्भ को बिना गुजारने के लिए अनुमति देता है। विधि tf.get_variable का उपयोग चर के नाम के साथ किया जा सकता है तर्क के रूप में या तो इस तरह के नाम के साथ एक नया चर बनाने या पहले बनाया गया था जो एक को पुनः प्राप्त। यह tf.Variable कन्स्ट्रक्टर का उपयोग करने से भिन्न है जो हर बार जब इसे कहा जाता है (और संभवतः वेरिएबल नाम पर एक प्रत्यय जोड़ते हैं, यदि ऐसा नाम वाला एक चर पहले से मौजूद है) एक नया चर बना देगा। यह चर साझाकरण तंत्र के उद्देश्य के लिए है कि एक अलग प्रकार का दायरा (चर का गुंजाइश) पेश किया गया था।

परिणामस्वरूप, हम दो अलग-अलग प्रकार के स्कोप वाले होते हैं:

  • नाम स्कोप , tf.name_scope का उपयोग करके बनाया tf.name_scope
  • चर गुंजाइश , tf.variable_scope का उपयोग कर बनाई गई

दोनों स्कोप का उपयोग सभी कार्यों के साथ-साथ tf.Variable के उपयोग के साथ-साथ चर को भी tf.Variable , अर्थात, कार्यक्षेत्र या चर नाम के लिए एक उपसर्ग के रूप में जोड़ा जाएगा।

हालांकि, नाम का क्षेत्र tf.get_variable द्वारा अनदेखा किया गया है हम निम्नलिखित उदाहरण में देख सकते हैं:

 with tf.name_scope("my_scope"): v1 = tf.get_variable("var1", [1], dtype=tf.float32) v2 = tf.Variable(1, name="var2", dtype=tf.float32) a = tf.add(v1, v2) print(v1.name) # var1:0 print(v2.name) # my_scope/var2:0 print(a.name) # my_scope/Add:0 

एक चर में tf.get_variable का उपयोग कर एक चर tf.get_variable का एकमात्र तरीका है एक चर का उपयोग, निम्न उदाहरण के रूप में:

 with tf.variable_scope("my_scope"): v1 = tf.get_variable("var1", [1], dtype=tf.float32) v2 = tf.Variable(1, name="var2", dtype=tf.float32) a = tf.add(v1, v2) print(v1.name) # my_scope/var1:0 print(v2.name) # my_scope/var2:0 print(a.name) # my_scope/Add:0 

इससे हमें प्रोग्राम के विभिन्न हिस्सों में आसानी से चर को साझा करने की सुविधा मिलती है, यहां तक ​​कि अलग-अलग नामों के भीतर भी:

 with tf.name_scope("foo"): with tf.variable_scope("var_scope"): v = tf.get_variable("var", [1]) with tf.name_scope("bar"): with tf.variable_scope("var_scope", reuse=True): v1 = tf.get_variable("var", [1]) assert v1 == v print(v.name) # var_scope/var:0 print(v1.name) # var_scope/var:0 

अद्यतनः op_scope / variable_op_scope नापसंद है!

संस्करण r0.11 के अनुसार, op_scope और variable_op_scope दोनों को नापसंद किया गया है और name_scope और variable_scope द्वारा प्रतिस्थापित किया गया है।

नामस्थान एक प्रकार है चर और ऑपरेटर के लिए नामों को क्रमबद्ध तरीके से व्यवस्थित करना (उदाहरण के लिए "स्कोपए / स्कोप बी / स्कोपसी / ऑप 1")

  • tf.name_scope ऑपरेटरों के लिए डिफ़ॉल्ट ग्राफ़ में नेमस्पेस बनाता है।
  • tf.variable_scope डिफ़ॉल्ट ग्राफ में दोनों चर और ऑपरेटरों के लिए नेमस्पेस बनाता है।

  • tf.op_scope समान है, लेकिन उस ग्राफ़ के लिए जिसमें निर्दिष्ट चर बनाया गया था।

  • tf.variable_op_scope समान है, लेकिन उस tf.variable_scope लिए जिसमें निर्दिष्ट चर बनाया गया था

उपरोक्त स्रोतों की लिंक्स इस दस्तावेज़ीकरण समस्या को स्पष्ट करने में सहायता करते हैं।

यह उदाहरण बताता है कि सभी प्रकार के स्कोप निम्न अंतर वाले चर और ऑपरेटर दोनों के लिए नामस्थान को परिभाषित करते हैं:

  1. tf.variable_op_scope या tf.variable_scope द्वारा परिभाषित स्कोप tf.variable_scope के साथ संगत हैं (यह दो अन्य स्कोप की उपेक्षा करता है)
  2. tf.op_scope और tf.variable_op_scope लिए एक स्कोप बनाने के लिए केवल निर्दिष्ट चर की सूची से एक ग्राफ़ चुनें। तदनुसार tf.name_scope और tf.variable_scope बराबर उनके व्यवहार के अलावा
  3. tf.variable_scope और variable_op_scope निर्दिष्ट या डिफ़ॉल्ट प्रारंभकर्ता जोड़ें

दोनों variable_op_scope और op_scope को अब पदावनत किया गया है और इसका उपयोग बिल्कुल भी नहीं किया जाना चाहिए।

अन्य दो के बारे में, मुझे एक साधारण उदाहरण बनाकर सब कुछ कल्पना करने की कोशिश करने से पहले चर_सस्कोप और नेम_स्स्कोप (वे लगभग एक ही दिख रहे थे) के बीच अंतर को समझने में समस्याएं थीं:

 import tensorflow as tf def scoping(fn, scope1, scope2, vals): with fn(scope1): a = tf.Variable(vals[0], name='a') b = tf.get_variable('b', initializer=vals[1]) c = tf.constant(vals[2], name='c') with fn(scope2): d = tf.add(a * b, c, name='res') print '\n '.join([scope1, a.name, b.name, c.name, d.name]), '\n' return d d1 = scoping(tf.variable_scope, 'scope_vars', 'res', [1, 2, 3]) d2 = scoping(tf.name_scope, 'scope_name', 'res', [1, 2, 3]) with tf.Session() as sess: writer = tf.summary.FileWriter('logs', sess.graph) sess.run(tf.global_variables_initializer()) print sess.run([d1, d2]) writer.close() 

यहाँ मैं एक ऐसा फ़ंक्शन बनाता हूं जो कुछ चर और स्थिरांक बनाता है और उनको स्कोप (उन प्रकारों के आधार पर प्रदान करता है) के आधार पर समूह बनाता है। इस समारोह में, मैं सभी चर के नाम भी प्रिंट करता हूं। इसके बाद, मैं ग्राफ़ को निष्पादित मानों के मूल्य प्राप्त करने और ईवेंट-फाइलों को बचाने के लिए उन्हें TensorBoard में जांचने के लिए चलाता है यदि आप इसे चलाते हैं, तो आपको निम्नलिखित मिलेगा:

 scope_vars scope_vars/a:0 scope_vars/b:0 scope_vars/c:0 scope_vars/res/res:0 scope_name scope_name/a:0 b:0 scope_name/c:0 scope_name/res/res:0 

यदि आप टेन्सरबोर्ड को खोलते हैं तो आप समान पैटर्न देखते हैं (जैसा कि आप देखेंगे कि scope_name आयताकार के बाहर है): यहां छवि विवरण दर्ज करें


यह आपको जवाब देता है :

अब आप देखते हैं कि tf.variable_scope() सभी चर के नाम (कोई फर्क नहीं पड़ता कि आप उन्हें कैसे बनाते हैं), ऑप्स, स्थिरांकों के लिए उपसर्ग जोड़ता है दूसरी तरफ tf.name_scope() के साथ बनाए गए चर को अनदेखा करता है क्योंकि यह मानता है कि आप जानते हैं कि किस चर और किस दायरे में आप उपयोग करना चाहते हैं

शेयरिंग वेरिएबल्स पर एक अच्छा दस्तावेज आपको बताता है कि

tf.variable_scope() : tf.variable_scope() को पास किए गए नामों के लिए नामस्थान प्रबंधित करता है।

वही प्रलेखन अधिक विवरण प्रदान करता है कि कैसे वेरिएबल स्कोप काम करता है और जब यह उपयोगी होता है।

एपीआई r0.11 के लिए, op_scope और variable_op_scope दोनों नापसंद होते हैं । name_scope और variable_scope नेस्टेड किया जा सकता है:

 with tf.name_scope('ns'): with tf.variable_scope('vs'): v1 = tf.get_variable("v1",[1.0]) #v1.name = 'vs/v1:0' v2 = tf.Variable([2.0],name = 'v2') #v2.name= 'ns/vs/v2:0' v3 = v1 + v2 #v3.name = 'ns/vs/add:0' 

आप उन्हें दो समूहों के रूप में सोच सकते हैं: variable_op_scope और op_scope इनपुट के रूप में चर का एक सेट लेते हैं और ऑपरेशन बनाने के लिए डिज़ाइन किए जाते हैं। फ़र्क यह है कि कैसे वे tf.get_variable चर के निर्माण को प्रभावित करते हैं:

 def mysum(a,b,name=None): with tf.op_scope([a,b],name,"mysum") as scope: v = tf.get_variable("v", 1) v2 = tf.Variable([0], name="v2") assert v.name == "v:0", v.name assert v2.name == "mysum/v2:0", v2.name return tf.add(a,b) def mysum2(a,b,name=None): with tf.variable_op_scope([a,b],name,"mysum2") as scope: v = tf.get_variable("v", 1) v2 = tf.Variable([0], name="v2") assert v.name == "mysum2/v:0", v.name assert v2.name == "mysum2/v2:0", v2.name return tf.add(a,b) with tf.Graph().as_default(): op = mysum(tf.Variable(1), tf.Variable(2)) op2 = mysum2(tf.Variable(1), tf.Variable(2)) assert op.name == 'mysum/Add:0', op.name assert op2.name == 'mysum2/Add:0', op2.name 

दो उदाहरणों में चर v का नाम देखें

tf.name_scope और tf.variable_scope लिए समान:

 with tf.Graph().as_default(): with tf.name_scope("name_scope") as scope: v = tf.get_variable("v", [1]) op = tf.add(v, v) v2 = tf.Variable([0], name="v2") assert v.name == "v:0", v.name assert op.name == "name_scope/Add:0", op.name assert v2.name == "name_scope/v2:0", v2.name with tf.Graph().as_default(): with tf.variable_scope("name_scope") as scope: v = tf.get_variable("v", [1]) op = tf.add(v, v) v2 = tf.Variable([0], name="v2") assert v.name == "name_scope/v:0", v.name assert op.name == "name_scope/Add:0", op.name assert v2.name == "name_scope/v2:0", v2.name 

आप ट्यूटोरियल में चर गुंजाइश के बारे में अधिक पढ़ सकते हैं। स्टैक ओवरफ्लो पर पहले भी एक समान सवाल पूछा गया था।

Tensorflow प्रलेखन के इस पृष्ठ के अंतिम खंड से: ops के नाम tf.variable_scope()tf.variable_scope()

[…] जब हम with tf.variable_scope("name") , तो यह एक tf.name_scope("name") खोलता है। उदाहरण के लिए:

 with tf.variable_scope("foo"): x = 1.0 + tf.get_variable("v", [1]) assert x.op.name == "foo/add" 

नाम स्कोप को एक चर के दायरे के अतिरिक्त खोला जा सकता है, और उसके बाद वे केवल ऑप्स के नाम को प्रभावित करेंगे, लेकिन वेरिएबल्स के नहीं।

 with tf.variable_scope("foo"): with tf.name_scope("bar"): v = tf.get_variable("v", [1]) x = 1.0 + v assert v.name == "foo/v:0" assert x.op.name == "foo/bar/add" 

जब किसी स्ट्रिंग के बजाय किसी कैद ऑब्जेक्ट का उपयोग करके एक चर गुंजाइश खोलते हैं, तो हम ऑप्स के लिए वर्तमान नाम का दायरा नहीं बदलते।