क्रॉस-चैनल स्थानीय प्रतिक्रिया सामान्यीकरण (एलआरएन) परत

Question

के माध्यम से बैकप्रोपैगेशन एल्गोरिदम मैं तंत्रिका नेटवर्क की प्रतिलिपि बनाने पर काम कर रहा हूं। मैं समझने की कोशिश कर रहा हूं कि मानक परत प्रकार कैसे काम करते हैं। विशेष रूप से, मुझे पिछड़े-पास पर क्रॉस-चैनल सामान्यीकरण परतों का व्यवहार करने के तरीके के बारे में कहीं भी विवरण खोजने में परेशानी हो रही है। अगले (अर्थात बाद में) परत से

1. त्रुटि ढ़ाल उन्हें कुछ भी करने के बिना पीछे की ओर पारित कर रहे हैं:

   के बाद से सामान्य परत कोई पैरामीटर है, मैं दो संभव विकल्प लगता है हो सकता है।

2. त्रुटि ग्रेडियेंट सामान्य रूप से आगे बढ़ते समय चैनलों में सक्रियण सामान्यीकृत होते हैं।

मैं, एक कारण नहीं सोच सकते हैं तुम क्यों एक दूसरे के ऊपर किसी भी अंतर्ज्ञान के आधार पर करना चाहते हैं इसलिए मैं क्यों इस पर कुछ मदद करना चाहते हैं।

EDIT1:

परत Caffe में एक मानक परत, के रूप में यहाँ http://caffe.berkeleyvision.org/tutorial/layers.html (देखें 'स्थानीय रिस्पांस सामान्यीकरण (LRN)') का वर्णन किया है।

फॉरवर्ड पास में परत के कार्यान्वयन alexNet कागज की धारा 3.3 में वर्णित है: http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

EDIT2:

मेरा मानना ​​है कि आगे और पीछे पारित एल्गोरिदम दोनों मशाल पुस्तकालय यहाँ में वर्णित हैं: https://github.com/soumith/cudnn.torch/blob/master/SpatialCrossMapLRN.lua

और यहाँ Caffe पुस्तकालय में: https://github.com/BVLC/caffe/blob/master/src/caffe/layers/lrn_layer.cpp

कृपया किसी को भी, जो या तो से परिचित है/इन दोनों को उसका अनुवाद कर सकें सादे अंग्रेजी में पिछड़े पास चरण के लिए विधि?

Answer 1

यह स्थानीय प्रतिक्रिया सामान्यीकरण परत के माध्यम से पीछे की ओर ढाल को प्रसारित करने के लिए चेन नियम का उपयोग करता है। यह कुछ हद तक इस अर्थ में एक nonlinearity परत के समान है (जो अपने आप पर ट्रेन करने योग्य पैरामीटर भी नहीं है, लेकिन पीछे की तरफ जाने वाले ग्रेडियेंट को प्रभावित करता है)।

Caffe में कोड है कि आप करने के लिए मुझे लगता है कि वे एक पैरामीटर के रूप में प्रत्येक न्यूरॉन में त्रुटि लेते हैं, और निम्न कार्य करके पिछले परत के लिए त्रुटि की गणना जुड़ा हुआ से:

पहले, फॉरवर्ड पास पर वे एक तथाकथित पैमाने पर, कि गणना की जाती है कैश (AlexNet कागज के मामले में, खंड 3.3 से सूत्र देखें) के रूप में:

scale_i = k + alpha/n * sum(a_j^2) 

यहाँ और sum नीचे योग j द्वारा अनुक्रमित और max(0, i - n/2) से min(N, i + n/2)

को जाता है

(ध्यान दें कि पेपर में वे n द्वारा सामान्यीकृत नहीं करते हैं, इसलिए मुझे लगता है कि यह ऐसा कुछ है जो कैफे एलेक्सनेट से अलग करता है)। आगे की ओर b_i = a_i + scale_i^-beta के रूप में गणना की जाती है।

पिछली बार त्रुटि प्रसारित करने के लिए, मान लें कि अगली परत से आने वाली त्रुटि be_i है, और त्रुटि जो हमें गणना करने की आवश्यकता है ae_i है।

1. जब आप गणना:

   ae_i = scale_i^-b * be_i - (2 * alpha * beta/n) * a_i * sum(be_j * b_j/scale_j) 
   

   के बाद आप इसे मैन्युअल लागू करने के लिए योजना बना रहे हैं, मैं भी दो चालें कि Caffe उनके कोड है कि कार्यान्वयन सरल बनाता है में उपयोग करता है साझा करेंगे: फिर ae_i के रूप में गणना की जाती है योग के लिए जोड़, N + n - 1 आकार की एक सरणी आवंटित करें, और प्रत्येक छोर पर n/2 शून्य के साथ पैड करें। इस तरह आप i - n/2 से i + n/2 पर शून्य से नीचे और N से परे की देखभाल किए बिना राशि की गणना कर सकते हैं।

2. आप प्रत्येक यात्रा पर sum recompute करने के बजाय (पिछड़े पारित करने के लिए सामने पारित करने के लिए a_j^2, be_j * b_j/scale_j) पहले से addends गणना की जरूरत नहीं है, तो प्रत्येक के लिए i = 0 के लिए sum गणना, और फिर लगातार i बस addend[i + n/2] जोड़ें और addend[i - n/2 - 1] घटाएं, यह आपको निरंतर समय में i के नए मान के लिए राशि का मूल्य देगा।

Answer 2

कारण, आप या तो उनके साथ हुए परिवर्तनों का निरीक्षण करने के लिए वेरिएबल प्रिंट कर सकते हैं या डीबग मॉडल का उपयोग कर सकते हैं यह देखने के लिए कि नेट पास करने के दौरान त्रुटियां कैसे बदलती हैं।

Answer 3

मैं पिछड़े का एक वैकल्पिक तैयार है और मैं नहीं जानता कि अगर यह Caffe के के बराबर है:

तो Caffe के है:

ae_i = scale_i^-b * be_i - (2 * alpha * beta/n) * a_i * sum(be_j * b_j/scale_j) 

मूल अभिव्यक्ति

फर्क द्वारा

b_i = a_i/(scale_i^-b) 

मुझे

मिलता है

ae_i = scale_i^-b * be_i - (2 * alpha * beta/n) * a_i * be_i*sum(ae_j)/scale_i^(-b-1)