बैच आकार बढ़ते समय TensorFlow उदाहरण विफल क्यों होता है?

Question

मैं Tensorflow MNIST example for beginners देख रही है और पाया है कि इस हिस्से में किया गया था:

for i in range(1000): 
    batch_xs, batch_ys = mnist.train.next_batch(100) 
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) 

100 से बैच आकार बदलने 204 से ऊपर होना करने का कारण बनता अभिसरण विफल मॉडल। यह 204 तक काम करता है, लेकिन 205 पर और मैंने जो भी उच्च संख्या की कोशिश की, सटीकता < 10% समाप्त हो जाएगी। क्या यह एक बग है, एल्गोरिदम के बारे में कुछ और, कुछ और?

यह ओएस एक्स के लिए अपनी बाइनरी स्थापना चला रहा है, संस्करण 0.5.0 लगता है।

Answer 1

आप शुरुआती उदाहरण में बहुत ही बुनियादी रैखिक मॉडल का उपयोग कर रहे हैं?

यहाँ यह डिबग करने के लिए एक चाल है - क्रोस एंट्रोपी घड़ी के रूप में आप बैच का आकार बढ़ाने के (पहली पंक्ति, दूसरी मैं सिर्फ जोड़ा उदाहरण से है):

cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 
cross_entropy = tf.Print(cross_entropy, [cross_entropy], "CrossE") 

का एक बैच आकार पर 204, आप देखेंगे:

I tensorflow/core/kernels/logging_ops.cc:64] CrossE[92.37558] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[90.107414] 

लेकिन 205 पर, तो आप इस तरह एक दृश्य देखेंगे, शुरू से ही:

I tensorflow/core/kernels/logging_ops.cc:64] CrossE[472.02966] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[475.11697] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1418.6655] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1546.3833] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1684.2932] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1420.02] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1796.0872] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[nan] 

एएके - नाएन दिखा रहा है। असल में, बड़ा बैच आकार इतना विशाल ढाल बना रहा है कि आपका मॉडल नियंत्रण से बाहर हो रहा है - जो आवेदन इसे लागू कर रहे हैं, वे बहुत बड़े हैं, और दिशा को ओवरहाइट करना इसे एक विशाल मार्जिन से जाना चाहिए।

प्रैक्टिस में, इसे ठीक करने के कुछ तरीके हैं। आप सीखने की दर को .01 से कह सकते हैं, .005, जिसके परिणामस्वरूप 0.92 की अंतिम सटीकता है।

train_step = tf.train.GradientDescentOptimizer(0.005).minimize(cross_entropy) 

या आप एक और अधिक परिष्कृत अनुकूलन एल्गोरिथ्म (एडम, गति, आदि) अधिक करने के लिए ढाल की दिशा यह पता लगाने की कोशिश करता है कि इस्तेमाल कर सकते हैं। या आप एक अधिक जटिल मॉडल का उपयोग कर सकते हैं जिसमें उस बड़े ढाल को फैलाने के लिए अधिक मुक्त पैरामीटर हों।

Answer 2

@ डीजीए ने एक अच्छा जवाब दिया, लेकिन मैं थोड़ा विस्तार करना चाहता था।

जब मैंने लिखा शुरुआती ट्यूटोरियल, मैं इतना की तरह लागत समारोह लागू किया:

cross_entropy = -tf.reduce_sum (y_ * tf.log (y))

मैं इसे लिखा था इस तरह से यह क्रॉस-एन्ट्रॉपी की गणितीय परिभाषा के समान दिखता है। लेकिन यह वास्तव में बेहतर हो सकता है कुछ इस तरह करना है:

cross_entropy = -tf.reduce_mean (y_ * tf.log (y))

क्यों यह एक मतलब का उपयोग करने के बजाय अच्छे हो सकता है योग का? खैर, अगर हम योग करते हैं, तो बैच आकार को दोगुना करने से लागत दोगुना हो जाती है, और ढाल की परिमाण को भी दोगुना कर दिया जाता है। जब तक हम अपनी सीखने की दर को समायोजित न करें (या एक एल्गोरिदम का उपयोग करें जो हमारे लिए इसे समायोजित करता है, जैसे कि @ डीजीए सुझाए गए) हमारे प्रशिक्षण में विस्फोट हो जाएगा! लेकिन अगर हम एक मतलब का उपयोग करते हैं, तो हमारी सीखने की दर हमारे बैच आकार से स्वतंत्र हो जाती है, जो कि अच्छा है।

मैं आपको एडम (tf.train.AdamOptimizer()) की जांच करने के लिए प्रोत्साहित करता हूं। एसजीडी की तुलना में चीजों के साथ झुकाव करना अक्सर अधिक सहनशील होता है।

Answer 3

@ डीगा ने आपको इस तरह के व्यवहार का कारण समझाया (क्रॉस_एन्ट्रॉपी बहुत बड़ा हो जाता है) और इस प्रकार एल्गोरिदम अभिसरण करने में सक्षम नहीं होगा। इसे ठीक करने के कुछ तरीके हैं। उन्होंने पहले ही सीखने की दर कम करने का सुझाव दिया है।

ग्रेडियेंट वंश सबसे बुनियादी एल्गोरिदम है। लगभग सभी अन्य optimizers ठीक से काम किया जाएगा:

train_step = tf.train.AdagradOptimizer(0.01).minimize(cross_entropy) 
train_step = tf.train.AdamOptimizer().minimize(cross_entropy) 
train_step = tf.train.FtrlOptimizer(0.01).minimize(cross_entropy) 
train_step = tf.train.RMSPropOptimizer(0.01, 0.1).minimize(cross_entropy) 

एक और दृष्टिकोण tf.nn.softmax_cross_entropy_with_logits जो संख्यात्मक अस्थायित्व हैंडल का प्रयोग है।

Answer 4

नेन तब होता है जब 0 * लॉग (0) होती है:

बदल देते हैं:

साथ

cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 

:

cross_entropy = -tf.reduce_sum(y_*tf.log(y + 1e-10))