GradientDescentOptimizer के लिए अनुकूली सीखने की दर कैसे निर्धारित करें?

Question

मैं एक तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए TensorFlow का उपयोग कर रहा हूं। यह मैं कैसे शुरू कर रहा हूँ GradientDescentOptimizer:

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

mse        = tf.reduce_mean(tf.square(out - out_))
train_step = tf.train.GradientDescentOptimizer(0.3).minimize(mse)

यहाँ बात यह है कि मुझे नहीं पता कि सीखने की दर के लिए एक अद्यतन नियम या उसके लिए एक क्षय मूल्य कैसे निर्धारित किया जाए।

मैं यहां एक अनुकूली सीखने की दर का उपयोग कैसे कर सकता हूं?

Comments

अपने ऑप्टिमाइज़र को निर्दिष्ट करने के बाद सभी चर को शुरू करने की इसकी एक अच्छी आदत है क्योंकि कुछ ऑप्टिमाइज़र जैसे एडमऑप्टिमाइज़र अपने स्वयं के चर का उपयोग करता है जिसे भी आरंभीकृत करने की आवश्यकता होती है। अन्यथा आपको एक त्रुटि मिल सकती है जो इस तरह दिखती है:FailedPreconditionError (see above for traceback): Attempting to use uninitialized value beta2_power

— JYun

मुझे यह उपर्युक्त त्रुटि मिल रही है, जब मैं Tensorflow में एक नई सीखने की दर निर्धारित करने की कोशिश कर रहा हूँ tf.train.GradientDescentOptimizer(new_lr).minimize(loss)। ऐसा लगता है, एक नई सीखने की दर निर्धारित करने के लिए पहले से ही प्रशिक्षित चर के साथ मॉडल को इनिशियलाइज़ करना आवश्यक है। लेकिन यह पता नहीं कर सकते कि ऐसा कैसे किया जाए।

— सिलदित्या

Answer 1

सबसे पहले, tf.train.GradientDescentOptimizerसभी चरणों में सभी चर के लिए एक निरंतर सीखने की दर का उपयोग करने के लिए डिज़ाइन किया गया है। TensorFlow भी सहित बाहर के बॉक्स अनुकूली अनुकूलक प्रदान करता है tf.train.AdagradOptimizerऔर tf.train.AdamOptimizer, और इन ड्रॉप-में प्रतिस्थापन के रूप में इस्तेमाल किया जा सकता।

हालांकि, यदि आप अन्यथा-वेनिला ढाल वंश के साथ सीखने की दर को नियंत्रित करना चाहते हैं, तो आप इस तथ्य का लाभ उठा सकते हैं कि कंस्ट्रक्टर का learning_rateतर्क एक वस्तु हो सकता है । यह आपको प्रत्येक चरण में सीखने की दर के लिए एक अलग मूल्य की गणना करने की अनुमति देता है, उदाहरण के लिए:tf.train.GradientDescentOptimizerTensor

learning_rate = tf.placeholder(tf.float32, shape=[])
# ...
train_step = tf.train.GradientDescentOptimizer(
    learning_rate=learning_rate).minimize(mse)

sess = tf.Session()

# Feed different values for learning rate to each training step.
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.01})
sess.run(train_step, feed_dict={learning_rate: 0.01})

वैकल्पिक रूप से, आप एक स्केलर बना सकते हैं tf.Variableजो सीखने की दर रखता है, और हर बार जब आप सीखने की दर को बदलना चाहते हैं, तो इसे असाइन करें।

Comments

बहुत बढ़िया जवाब। क्या उसी तकनीक का उपयोग ढाल की क्लिपिंग के लिए किया जा सकता है? tf.clip_by_normक्लिप मानदंड के लिए एक टेंसर को स्वीकार नहीं करता है, तो कैसे करने के बारे में [(tf.minimum(gv[0], ct), gv[1]) for gv in optimizer.compute_gradients(cost, vars)], जहांct = tf.placeholder('float32', shape=[])

— Richizy

वह काम करना चाहिए, हाँ। (हालांकि tf.clip_by_norm, यह देखते हुए , केवल एक चीज को एक टेंसर को इनपुट के रूप में स्वीकार करने से रोकना है constant_op.constant(1.0 / clip_norm)। उस अभिव्यक्ति को प्रतिस्थापित math_ops.inv(clip_norm)करने से यह एक प्लेसहोल्डर (या किसी अन्य टेंसर) इनपुट के साथ काम करेगा।)

— mrry

@ श्री ने जैसा आपने कहा और कुछ प्रशिक्षण की गति बहुत धीमी है। क्या यह अपेक्षित है?

— tnq177

Answer 2

Tensorflow स्वचालित रूप से सीखने की दर के लिए एक घातीय क्षय को लागू करने के लिए एक op प्रदान करता है: tf.train.exponential_decay :। उपयोग में इसके एक उदाहरण के लिए, इस लाइन को एमएनआईएसटी कन्वेन्शनल मॉडल उदाहरण में देखें । फिर इस चर को अपनी पसंद के अनुकूलक के लर्निंग_रेट पैरामीटर के रूप में आपूर्ति करने के लिए @ mrry के सुझाव का उपयोग करें।

देखने के लिए मुख्य अंश है:

# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)

learning_rate = tf.train.exponential_decay(
  0.01,                # Base learning rate.
  batch * BATCH_SIZE,  # Current index into the dataset.
  train_size,          # Decay step.
  0.95,                # Decay rate.
  staircase=True)
# Use simple momentum for the optimization.
optimizer = tf.train.MomentumOptimizer(learning_rate,
                                     0.9).minimize(loss,
                                                   global_step=batch)

global_step=batchन्यूनतम करने के लिए पैरामीटर पर ध्यान दें । यह आपके द्वारा हर बार प्रशिक्षित होने पर आपके लिए 'बैच' पैरामीटर को बढ़ाने में मदद करने के लिए ऑप्टिमाइज़र को बताता है।

Comments

आमतौर पर, जिस चर को आप कहते हैं batch, उसे कहा जाता है global_stepऔर इसे बनाने के लिए कई सुविधा फ़ंक्शंस हैं, tf.train.create_global_step()(जो बस एक पूर्णांक बनाता है tf.Variableऔर इसे tf.GraphKeys.GLOBAL_STEPसंग्रह में जोड़ता है ) और tf.train.get_global_step()।

— लेनार होयट

Answer 3

स्नातक वंशज एल्गोरिथ्म निरंतर सीखने की दर का उपयोग करता है जिसे आप आरंभीकरण के दौरान प्रदान कर सकते हैं । आप श्रीमती द्वारा दिखाए गए तरीके से विभिन्न शिक्षण दर पास कर सकते हैं।

लेकिन इसके बजाय आप अधिक उन्नत ऑप्टिमाइज़र का उपयोग कर सकते हैं, जिनके पास तेजी से अभिसरण दर और स्थिति के अनुकूल है।

यहाँ मेरी समझ पर आधारित एक संक्षिप्त विवरण दिया गया है:

• गति मदद करती है संबंधित निर्देशों के साथ नेविगेट करने के लिए और अप्रासंगिक में दोलनों को नरम करने में । यह पिछले चरण की दिशा के एक अंश को वर्तमान चरण में जोड़ता है। यह सही दिशा में गति के प्रवर्धन को प्राप्त करता है और गलत दिशाओं में दोलन को नरम करता है। यह अंश आमतौर पर (0, 1) श्रेणी में होता है। यह भी अनुकूली गति का उपयोग करने के लिए समझ में आता है। एक बड़ी गति सीखने की शुरुआत में केवल आपकी प्रगति में बाधा होगी, इसलिए यह 0.01 की तरह कुछ का उपयोग करने के लिए समझ में आता है और एक बार सभी उच्च ग्रेडिएंट गायब हो जाने पर आप एक बड़ी गति का उपयोग कर सकते हैं। गति के साथ एक समस्या है: जब हम लक्ष्य के बहुत करीब होते हैं, तो ज्यादातर मामलों में हमारी गति बहुत अधिक होती है और यह नहीं जानता कि यह धीमा होना चाहिए। यह मिनीमा के चारों ओर चूकने या थरथराने का कारण बन सकता है
• nesterov त्वरित ढाल इस समस्या को जल्दी धीमा करने के लिए शुरू करके काबू पा लेता है । गति में हम पहले ढाल की गणना करते हैं और फिर उस दिशा में एक छलांग लगाते हैं, जो पहले हमारे पास थी। एनएजी एक ही बात करता है, लेकिन दूसरे क्रम में: सबसे पहले हम अपनी संग्रहीत जानकारी के आधार पर एक बड़ी छलांग लगाते हैं, और फिर हम ढाल की गणना करते हैं और एक छोटा सुधार करते हैं। यह प्रतीत होता है अप्रासंगिक परिवर्तन महत्वपूर्ण व्यावहारिक गति देता है।
• AdaGrad या अनुकूली ढाल सीखने की दर को मापदंडों के आधार पर अनुकूलित करने की अनुमति देता है। यह लगातार मापदंडों के लिए बड़े अपडेट और लगातार एक के लिए छोटे अपडेट करता है। इस वजह से यह विरल डेटा (एनएलपी या छवि मान्यता) के लिए अच्छी तरह से अनुकूल है। एक और लाभ यह है कि यह मूल रूप से सीखने की दर को ट्यून करने की आवश्यकता को कम करता है। प्रत्येक पैरामीटर की अपनी सीखने की दर होती है और एल्गोरिथ्म की ख़ासियत के कारण सीखने की दर नीरस रूप से कम होती है। यह सबसे बड़ी समस्या का कारण बनता है: किसी समय सीखने की दर इतनी कम होती है कि सिस्टम सीखना बंद कर देता है
• AdaDelta AdaGrad में अद्वैत रूप से घटती सीखने की दर की समस्या का समाधान करता है। AdaGrad में सीखने की दर को लगभग वर्गमूल के योग से विभाजित के रूप में गणना की गई थी। प्रत्येक चरण में आप राशि में एक और वर्गमूल जोड़ते हैं, जिससे हर लगातार घटता है। AdaDelta में सभी पिछली वर्गाकार जड़ों को समेटने के बजाय यह स्लाइडिंग विंडो का उपयोग करता है जो योग को कम करने की अनुमति देता है। RMSprop , AdaDelta के समान है

• एडम या एडाप्टिव मोमेंट AdaDelta के समान एक एल्गोरिथ्म है। लेकिन प्रत्येक मापदंडों के लिए सीखने की दरों को संग्रहीत करने के अलावा, यह उनमें से प्रत्येक के लिए अलग-अलग परिवर्तनों को गति प्रदान करता है

  एक कुछ दृश्यावलोकन :

Comments

: TensorFlow में अलग अनुकूलक की तुलना के लिए एक नोटबुक IPython निम्नलिखित पर नजर है github.com/vsmolyakov/experiments_with_python/blob/master/chp03/... के लिए

— वादिम Smolyakov

अधिक उन्नत ऑप्टिमाइज़र को "इसके बजाय" नहीं लिया जाना चाहिए, लेकिन इसके अलावा, आँकड़े

— Dima Lituiev

@DimaLituiev क्या आप एक ही समय में दो ऑप्टिमाइज़र का उपयोग कर सकते हैं? यदि नहीं, तो आप optimizer2 के बजाय optimizer1 का उपयोग कर रहे हैं।

— साल्वाडोर डाली

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

— डिमा लिटिविव

Answer 4

से tensorflow सरकारी डॉक्स

global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
                                       100000, 0.96, staircase=True)

# Passing global_step to minimize() will increment it at each step.
learning_step = (
tf.train.GradientDescentOptimizer(learning_rate)
.minimize(...my loss..., global_step=global_step))

Answer 5

यदि आप जैसे युगों के अंतराल के लिए विशिष्ट सीखने की दर निर्धारित करना चाहते हैं 0 < a < b < c < ...। फिर आप अपने सीखने की दर को एक सशर्त टेंसर, वैश्विक चरण पर सशर्त के रूप में परिभाषित कर सकते हैं, और इसे आशावादी के लिए सामान्य रूप से खिला सकते हैं।

आप इसे नेस्टेड tf.condकथनों के एक समूह के साथ प्राप्त कर सकते हैं , लेकिन इसके टेंसर को फिर से बनाने के लिए आसान है:

def make_learning_rate_tensor(reduction_steps, learning_rates, global_step):
    assert len(reduction_steps) + 1 == len(learning_rates)
    if len(reduction_steps) == 1:
        return tf.cond(
            global_step < reduction_steps[0],
            lambda: learning_rates[0],
            lambda: learning_rates[1]
        )
    else:
        return tf.cond(
            global_step < reduction_steps[0],
            lambda: learning_rates[0],
            lambda: make_learning_rate_tensor(
                reduction_steps[1:],
                learning_rates[1:],
                global_step,)
            )

फिर इसका उपयोग करने के लिए आपको यह जानने की आवश्यकता है कि एक एकल युग में कितने प्रशिक्षण चरण हैं, ताकि हम सही समय पर स्विच करने के लिए वैश्विक कदम का उपयोग कर सकें, और अंत में आप जो युग और सीखने की दर चाहते हैं, उसे परिभाषित कर सकें। इसलिए यदि मैं क्रमशः सीखने की [0.1, 0.01, 0.001, 0.0001]अवधि के दौरान सीखने की दर चाहता [0, 19], [20, 59], [60, 99], [100, \infty]हूं, तो मैं यह करूंगा:

global_step = tf.train.get_or_create_global_step()
learning_rates = [0.1, 0.01, 0.001, 0.0001]
steps_per_epoch = 225
epochs_to_switch_at = [20, 60, 100]
epochs_to_switch_at = [x*steps_per_epoch for x in epochs_to_switch_at ]
learning_rate = make_learning_rate_tensor(epochs_to_switch_at , learning_rates, global_step)