Tensorflow में global_step का क्या अर्थ है?

Question

इस TensorFlow वेबसाइट से ट्यूटोरियल कोड है,

1. किसी को समझाने में मदद कर सकता है क्या global_stepमतलब है?

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

2. साथ ही, सेट करते समय नंबर 0 का क्या मतलब है global_step?

    def training(loss,learning_rate):
        tf.summary.scalar('loss',loss)
        optimizer = tf.train.GradientDescentOptimizer(learning_rate)
        
        # Why 0 as the first parameter of the global_step tf.Variable?
        global_step = tf.Variable(0, name='global_step',trainable=False)

        train_op = optimizer.minimize(loss, global_step=global_step)
    
        return train_op

Tensorflow doc global_step के अनुसार : चरों को अपडेट करने के बाद एक के बाद एक वृद्धि । क्या एक अपडेट global_step1 हो जाने के बाद इसका मतलब है ?

Answer 1

global_stepग्राफ द्वारा देखे गए बैचों की संख्या को संदर्भित करता है। हर बार एक बैच प्रदान किया जाता है, वज़न को उस दिशा में अपडेट किया जाता है जो नुकसान को कम करता है। global_stepअभी तक देखे गए बैचों की संख्या पर नज़र रखता है। जब इसे minimize()तर्क सूची में पास किया जाता है, तो चर एक से बढ़ जाता है। एक नजर है optimizer.minimize()।

आप global_stepका उपयोग कर मूल्य प्राप्त कर सकते हैं tf.train.global_step()। इसके अलावा उपयोगी तरीके tf.train.get_global_stepया हैंtf.train.get_or_create_global_step ।

0 इस संदर्भ में वैश्विक कदम का प्रारंभिक मूल्य है।

Comments

धन्यवाद! आपके द्वारा दिए गए लिंक में tf.train.global_step(), global_step_tensor10 पर सेट है। क्या इसका मतलब है कि 10 बैच पहले से ही ग्राफ द्वारा देखे गए हैं?

— गेब्रियलचू

@martianwars, मुझे अभी भी global_step होने की बात नहीं आती है। अजगर कार्यक्रम द्वारा संचालित बैचों के लिए लूपिंग नहीं है, इसलिए अजगर कार्यक्रम आसानी से जान सकता है कि कितने बैच किए गए हैं। इस तरह के एक काउंटर को बनाए रखने के लिए टेंसरफ़्लो को परेशान क्यों किया जाता है?

— विक्टर

ऑप्टिमाइज़र भिन्न होते हैं यह वैश्विक चरण @xwk

— martianwars

xwk के प्रश्न का उत्तर देने के लिए, मुझे लगता है कि यदि आप 100 पुनरावृत्तियों के बाद प्रशिक्षण बंद कर देते हैं, और अगले दिन मॉडल को पुनर्स्थापित करते हैं और अन्य 100 पुनरावृत्तियों को चलाते हैं। अब आपका वैश्विक कदम 200 है, लेकिन दूसरे रन में 1 से 100 तक एक स्थानीय पुनरावृत्ति संख्या है, जो कि स्थानीय रूप से वैश्विक पुनरावृति कदम के रूप में है। तो वैश्विक कदम ने पुनरावृत्तियों की कुल संख्या को रिकॉर्ड किया है, शायद सीखने की दर या अन्य हाइपरपरमीटर को बदलने के लिए उपयोग किया जाता है।

— वीआई लियू

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

— मालो मार्रेक

Answer 2

आपको नीचे एक ज्वलंत नमूना दिखाते हैं:

कोड:

train_op = tf.train.GradientDescentOptimizer(learning_rate=LEARNING_RATE).minimize(loss_tensor,global_step=tf.train.create_global_step())
with tf.Session() as sess:
    ...
    tf.logging.log_every_n(tf.logging.INFO,"np.mean(loss_evl)= %f at step %d",100,np.mean(loss_evl),sess.run(tf.train.get_global_step()))

संगत प्रिंट

INFO:tensorflow:np.mean(loss_evl)= 1.396970 at step 1
INFO:tensorflow:np.mean(loss_evl)= 1.221397 at step 101
INFO:tensorflow:np.mean(loss_evl)= 1.061688 at step 201

Answer 3

global_step Variableकार्यों भर में प्रशिक्षण के दौरान चरणों की कुल संख्या रखती है (हर कदम सूचकांक केवल एक ही काम पर होगा)।

हमारे द्वारा बनाई गई एक टाइमलाइन global_stepहमें यह समझने में मदद करती है कि हम अलग-अलग कार्यों में से प्रत्येक में कहाँ ग्रैंड स्कीम में हैं। उदाहरण के लिए, नुकसान और सटीकता global_stepको टेंसरबोर्ड पर देखा जा सकता है ।

Answer 4

ऐसे नेटवर्क हैं, जैसे GAN, कि दो (या अधिक) विभिन्न चरणों की आवश्यकता हो सकती है। डब्ल्यूएजीएन विनिर्देश के साथ एक गण को प्रशिक्षित करने के लिए आवश्यक है कि डिस्क्रिमिनेटर (या आलोचक) डी पर कदम जनरेटर जी पर किए गए से अधिक हैं। उस मामले में, यह विभिन्न global_steps चर घोषित करने के लिए उपयोगी है।

उदाहरण: ( G_lossऔर D_lossजनरेटर और भेदभावकर्ता के नुकसान हैं)

G_global_step = tf.Variable(0, name='G_global_step', trainable=False)
D_global_step = tf.Variable(0, name='D_global_step', trainable=False)

minimizer = tf.train.RMSPropOptimizer(learning_rate=0.00005)

G_solver = minimizer.minimize(G_loss, var_list=params, global_step=G_global_step)
D_solver = minimizer.minimize(D_loss, var_list=params, global_step=D_global_step)