सवाल प्रशिक्षण के दौरान नैन के आम कारण


मैंने देखा है कि प्रशिक्षण के दौरान लगातार घटना होती है NANपेश किया जा रहा है।

कई बार ऐसा लगता है कि आंतरिक उत्पाद / पूरी तरह से जुड़े या संकल्प परतों में वजन घटाने से वजन घटता है।

क्या ऐसा हो रहा है क्योंकि ढाल गणना गणना हो रही है? या वजन घटाने के कारण यह है (यदि हां, तो वजन शुरू करने का यह प्रभाव क्यों होता है)? या यह इनपुट डेटा की प्रकृति के कारण होने की संभावना है?

यहां पर अत्यधिक सवाल यह है कि: प्रशिक्षण के दौरान एनएएन के लिए होने का सबसे आम कारण क्या है? और दूसरी बात, इस पर मुकाबला करने के लिए कुछ तरीके क्या हैं (और वे क्यों काम करते हैं)?


53
2017-11-27 17:23


मूल


क्या आप विशिष्ट MATLAB फ़ंक्शंस को कॉल कर रहे हैं? क्या यह सब तुम्हारा कोड है? - Matthew Gunn
@MatthewGunn मुझे नहीं लगता कि यह सवाल matlab- विशिष्ट है, बल्कि caffe-सम्बंधित। - Shai


जवाब:


अच्छा प्रश्न।
मैं इस घटना में कई बार आया था। यहां मेरे अवलोकन हैं:


ग्रेडियेंट उड़ना

कारण: बड़े ग्रेडियेंट सीखने की प्रक्रिया ऑफ-ट्रैक फेंक देते हैं।

आपको क्या उम्मीद करनी चाहिए: रनटाइम लॉग को देखते हुए, आपको प्रति-पुनरावृत्ति मानों को देखना चाहिए। आप देखेंगे कि नुकसान बढ़ने लगता है काफी पुनरावृत्ति से पुनरावृत्ति तक, आखिर में नुकसान एक फ्लोटिंग पॉइंट वेरिएबल द्वारा प्रतिनिधित्व करने के लिए बहुत बड़ा होगा और यह बन जाएगा nan

तुम क्या कर सकते हो: कम करें base_lr (solver.prototxt में) परिमाण के क्रम से (कम से कम)। यदि आपके पास कई हानि परतें हैं, तो आपको यह देखने के लिए लॉग का निरीक्षण करना चाहिए कि ढाल के लिए कौन सी परत ज़िम्मेदार है और कम करें loss_weight (train_val.prototxt में) सामान्य की बजाय उस विशिष्ट परत के लिए base_lr


खराब सीखने की दर नीति और पैराम

कारण: कैफे वैध सीखने की दर की गणना करने में विफल रहता है और हो जाता है 'inf' या 'nan' इसके बजाए, यह अमान्य दर सभी अपडेटों को गुणा करती है और इस प्रकार सभी मानकों को अमान्य कर देती है।

आपको क्या उम्मीद करनी चाहिए: रनटाइम लॉग को देखते हुए, आपको देखना चाहिए कि सीखने की दर ही बन जाती है 'nan', उदाहरण के लिए:

... sgd_solver.cpp:106] Iteration 0, lr = -nan

तुम क्या कर सकते हो: अपने सीखने की दर को प्रभावित करने वाले सभी मानकों को ठीक करें 'solver.prototxt' फ़ाइल।
उदाहरण के लिए, यदि आप उपयोग करते हैं lr_policy: "poly" और आप परिभाषित करना भूल जाते हैं max_iter पैरामीटर, आप के साथ खत्म हो जाएगा lr = nan...
कैफी में सीखने की दर के बारे में अधिक जानकारी के लिए, देखें यह धागा


दोषपूर्ण हानि समारोह

कारण: कभी-कभी हानि परतों में हानि की गणना का कारण बनता है nanदिखने के लिए है। उदाहरण के लिए, भोजन InfogainLoss गैर-सामान्यीकृत मानों के साथ परत, बग, आदि के साथ कस्टम हानि परत का उपयोग कर

आपको क्या उम्मीद करनी चाहिए: रनटाइम लॉग को देखते हुए आप शायद असामान्य कुछ भी नहीं देखेंगे: नुकसान धीरे-धीरे घट रहा है, और अचानक एक nan प्रकट होता है।

तुम क्या कर सकते हो: देखें कि क्या आप त्रुटि को पुन: उत्पन्न कर सकते हैं, हानि परत में प्रिंटआउट जोड़ें और त्रुटि डीबग करें।

उदाहरण के लिए: एक बार मैंने एक नुकसान का उपयोग किया जो बैच में लेबल घटना की आवृत्ति द्वारा दंड को सामान्यीकृत करता था। ऐसा ही हुआ कि अगर बैच में प्रशिक्षण लेबल में से कोई भी दिखाई नहीं दे रहा था - उत्पादित हानि की गणना की गई nanरों। उस स्थिति में, इस त्रुटि से बचने के लिए पर्याप्त पर्याप्त बैचों (सेट में लेबल की संख्या के संबंध में) के साथ काम करना पर्याप्त था।


दोषपूर्ण इनपुट

कारण: आपके पास एक इनपुट है nan इस में!

आपको क्या उम्मीद करनी चाहिए: एक बार सीखने की प्रक्रिया इस दोषपूर्ण इनपुट "हिट" हो जाती है - आउटपुट बन जाता है nan। रनटाइम लॉग को देखते हुए आप शायद असामान्य कुछ भी नहीं देखेंगे: नुकसान धीरे-धीरे घट रहा है, और अचानक एक nan प्रकट होता है।

तुम क्या कर सकते हो: अपने इनपुट डेटासेट (एलएमडीबी / लेवलडीएन / एचडीएफ 5 ...) को फिर से बनाएं, सुनिश्चित करें कि आपके प्रशिक्षण / सत्यापन सेट में आपके पास खराब छवि फ़ाइलें नहीं हैं। डीबग के लिए आप एक साधारण नेट बना सकते हैं जो इनपुट परत को पढ़ता है, इसके ऊपर एक डमी नुकसान होता है और सभी इनपुट के माध्यम से चलता है: यदि उनमें से एक दोषपूर्ण है, तो यह डमी नेट भी उत्पादित करना चाहिए nan


कर्नेल आकार से बड़े पैमाने पर आगे बढ़ें "Pooling" परत

किसी कारण से, चुनना stride > kernel_size पूलिंग के लिए परिणाम हो सकता है nanरों। उदाहरण के लिए:

layer {
  name: "faulty_pooling"
  type: "Pooling"
  bottom: "x"
  top: "y"
  pooling_param {
    pool: AVE
    stride: 5
    kernel: 3
  }
}

के साथ परिणाम nanएस में y


में विकलांगता "BatchNorm"

यह बताया गया था कि कुछ सेटिंग्स के तहत "BatchNorm" परत उत्पादन हो सकता है nanसंख्यात्मक अस्थिरता के कारण है।
इस मुद्दा Bvlc / कैफे में उठाया गया था और पीआर # 5136 इसे ठीक करने का प्रयास कर रहा है।


हाल ही में, मुझे पता चला debug_info ध्वज: सेटिंग debug_info: true में 'solver.prototxt' प्रशिक्षण के दौरान अधिक डीबग जानकारी (ढाल परिमाण और सक्रियण मान सहित) लॉग इन करने के लिए कैफे प्रिंट बनाएगा: यह जानकारी कर सकती है प्रशिक्षण प्रक्रिया में ढाल blowups और अन्य समस्याओं को खोजने में मदद करें


86
2017-11-29 06:50



धन्यवाद, उन संख्याओं की व्याख्या कैसे करता है? ये संख्या क्या हैं? pastebin.com/DLYgXK5v प्रति परत उत्पादन केवल एक नंबर क्यों है ?? उन संख्याओं को कैसा दिखना चाहिए ताकि कोई जानता है कि कोई समस्या है या कोई नहीं है !? - Breeze
@ होसेनिन यह बिल्कुल वैसा ही है ये पद बारे मे। - Shai
आप एक कोण हैं;) धन्यवाद आदमी - Breeze
@ होससेन खुश मैं मदद कर सकता था: डी - Shai


मेरे मामले में, संकल्प / deconvolution परतों में पूर्वाग्रह स्थापित नहीं कारण था।

उपाय: संकल्प परत पैरामीटर में निम्नलिखित जोड़ें।

bias_filler {       टाइप करें: "निरंतर"       मान: 0     }


3
2017-07-11 20:24



यह matconvnet में कैसे देखेंगे? मेरे पास 'biases'.init_bias * जैसे कुछ है (1,4, एकल) - h612


यह उत्तर किसी कारण के बारे में नहीं है nanएस, बल्कि इसे डीबग करने में मदद करने के लिए एक तरीका प्रस्तावित करता है। आपके पास यह पायथन परत हो सकती है:

class checkFiniteLayer(caffe.Layer):
  def setup(self, bottom, top):
    self.prefix = self.param_str
  def reshape(self, bottom, top):
    pass
  def forward(self, bottom, top):
    for i in xrange(len(bottom)):
      isbad = np.sum(1-np.isfinite(bottom[i].data[...]))
      if isbad>0:
        raise Exception("checkFiniteLayer: %s forward pass bottom %d has %.2f%% non-finite elements" %
                        (self.prefix,i,100*float(isbad)/bottom[i].count))
  def backward(self, top, propagate_down, bottom):
    for i in xrange(len(top)):
      if not propagate_down[i]:
        continue
      isf = np.sum(1-np.isfinite(top[i].diff[...]))
        if isf>0:
          raise Exception("checkFiniteLayer: %s backward pass top %d has %.2f%% non-finite elements" %
                          (self.prefix,i,100*float(isf)/top[i].count))

इस परत को अपने अंदर जोड़ना train_val.prototxt कुछ बिंदुओं पर आपको संदेह हो सकता है कि समस्या हो सकती है:

layer {
  type: "Python"
  name: "check_loss"
  bottom: "fc2"
  top: "fc2"  # "in-place" layer
  python_param {
    module: "/path/to/python/file/check_finite_layer.py" # must be in $PYTHONPATH
    layer: "checkFiniteLayer"
    param_str: "prefix-check_loss" # string for printouts
  }
}

2
2018-01-06 06:25





मैं एक स्पैस ऑटोनेकोडर बनाने की कोशिश कर रहा था और इसमें स्पर्सिटी को प्रेरित करने के लिए कई परतें थीं। मेरा नेट चलाने के दौरान, मुझे नाएन का सामना करना पड़ा। कुछ परतों को हटाने पर (मेरे मामले में, मुझे वास्तव में 1 को हटाना पड़ा), मैंने पाया कि NaN गायब हो गया है। तो, मुझे लगता है कि बहुत अधिक दुर्लभता NaN के साथ भी हो सकती है (कुछ 0/0 गणनाएं लागू की जा सकती हैं !?)


-1
2017-07-20 09:39



क्या आप थोड़ा और स्पष्ट कर सकते हैं? क्या आप उस कॉन्फ़िगरेशन पर विवरण प्रदान कर सकते हैं जो था nanएस और निश्चित विन्यास? किस प्रकार की परतें? क्या पैरामीटर? - Shai
@ शाई मैंने कई इनरप्रॉडक्ट (lr_mult 1, decay_mult 1, lr_mult 2, decay_mult 0, xavier, std: 0.01) परतों का उपयोग किया था, प्रत्येक के बाद ReLU (अंतिम को छोड़कर)। मैं एमएनआईएसटी के साथ काम कर रहा था, और अगर मुझे सही याद है, तो आर्किटेक्चर 784 -> 1000 -> 500 -> 250 -> 100 -> 30 (और एक सममित डीकोडर चरण) था; अपने रेएलयू के साथ 30 परत को हटाने से नाएन गायब हो गया। - LKB