machine learning - प्रशिक्षण के दौरान नैन के सामान्य कारण




machine-learning neural-network (3)

मैंने देखा है कि प्रशिक्षण के दौरान अक्सर होने वाली घटना NAN शुरुआत है।

अक्सर कई बार ऐसा लगता है कि यह इनर-प्रोडक्ट / पूरी तरह से कनेक्टेड या कनवल्शन लेयर्स में वज़न बढ़ा रहा है।

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

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


अच्छा प्रश्न।
मुझे इस घटना के बारे में कई बार पता चला। यहाँ मेरी टिप्पणियों हैं:

धीरे-धीरे झटका

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"Pooling" परत में कर्नेल आकार से बड़ा स्ट्राइड

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

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

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

"BatchNorm" में "BatchNorm"

यह बताया गया था कि कुछ सेटिंग्स के तहत "BatchNorm" परत संख्यात्मक अस्थिरताओं के कारण "BatchNorm" एस का उत्पादन कर सकती है।
यह issue bvlc / caffe में उठाया गया था और issue इसे ठीक करने का प्रयास कर रहा है।

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


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

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

bias_filler {प्रकार: "स्थिर" मान: 0}


यह उत्तर 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 में कुछ बिंदुओं पर 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
  }
}




gradient-descent