टेन्सोरफ्लो

Question

में variable_scope और name_scope के बीच अंतर variable_scope और name_scope के बीच क्या अंतर है? variable scope tutorialvariable_scope के बारे में वार्तालाप name_scope को स्पष्ट रूप से खोल रहा है। मैंने यह भी देखा कि name_scope में एक चर बनाने के लिए स्वचालित रूप से इसका नाम विस्तारित किया गया है। तो अंतर क्या है?

Answer 1

जब आप tf.get_variable बजाय tf.Variable साथ एक चर बनाने, Tensorflow एक ही विधि के साथ बनाया वार्स के नाम पता चल सके कि वे टकराने को देखने के लिए शुरू कर देंगे। यदि वे करते हैं, तो एक अपवाद उठाया जाएगा। यदि आपने tf.get_variable के साथ एक var बनाया है और आप tf.name_scope संदर्भ प्रबंधक का उपयोग कर अपने चर नामों के उपसर्ग को बदलने का प्रयास करते हैं, तो यह अपवाद को बढ़ाने के Tensorflow को रोक नहीं पाएगा। केवल tf.variable_scope संदर्भ प्रबंधक प्रभावी रूप से इस मामले में आपके var का नाम बदल देगा। या यदि आप चर का पुन: उपयोग करना चाहते हैं तो आपको दूसरी बार var बनाने से पहले scope.reuse_variables() को कॉल करना चाहिए।

सारांश में, tf.name_scope सिर्फ इतना है कि गुंजाइश (tf.get_variable के साथ बनाया वार्स को छोड़कर) में बनाए गए सभी टेन्सर करने के लिए एक उपसर्ग जोड़ने के लिए, और tf.variable_scopetf.get_variable के साथ बनाया चर करने के लिए एक उपसर्ग जोड़ें।

Answer 2

मैं variable_scope और name_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() 

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

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 

आप समान पैटर्न को देखने के लिए यदि आप खुले टीबी (के रूप में आप b देख scope_name आयताकार के बाहर है):

---

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

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

Sharing variables पर एक अच्छा प्रलेखन आपको बताता है कि

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

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