Loading [MathJax]/jax/output/HTML-CSS/jax.js
मालिकाना हक का डेमो

बैक-प्रोपेगेशन एल्गोरिदम

बड़े न्यूरल नेटवर्क के बारे में तेज़ी से ट्रेनिंग देने के लिए, बैकप्रॉपेशन एल्गोरिदम ज़रूरी है. इस लेख में बताया गया है कि एल्गोरिदम कैसे काम करता है.

कृपया नीचे स्क्रोल करें...

सामान्य न्यूरल नेटवर्क

दाईं ओर, आपको एक इनपुट नेटवर्क के साथ न्यूरल नेटवर्क दिखेगा. इसमें एक आउटपुट नोड और दो छिपी हुई लेयर होती हैं. हर नोड में दो नोड होते हैं.

आस-पास के लेयर में मौजूद नोड, वेट से जुड़े होते हैं wij, जो कि नेटवर्क पैरामीटर होते हैं.

ऐक्टिवेशन फ़ंक्शन

हर नोड में कुल इनपुट x, ऐक्टिवेशन फ़ंक्शन f(x) और आउटपुट y=f(x)होता है. f(x) यह नॉन-लीनियर फ़ंक्शन होना चाहिए, नहीं तो न्यूरल नेटवर्क सिर्फ़ लीनियर मॉडल सीख सकता है.

आम तौर पर, ऐक्टिवेशन फ़ंक्शन Sigmoid फ़ंक्शन होता है: f(x)=11+ex.

फ़ंक्शन में गड़बड़ी

लक्ष्य के तौर पर, नेटवर्क से डेटा का अपने-आप यह पता लगाना है कि अनुमानित आउटपुट youtput सभी इनपुट के लिए ytarget टारगेट के करीब है xinput.

हम लक्ष्य से कितनी दूर हैं, यह मापने के लिए, गड़बड़ी के फ़ंक्शन का इस्तेमाल करें E. आम तौर पर, गड़बड़ी वाला फ़ंक्शन E(youtput,ytarget)=12(youtputytarget)2.

फ़ॉरवर्ड प्रसार

हम इनपुट का एक उदाहरण लेते हैं (xinput,ytarget) और नेटवर्क की इनपुट लेयर को अपडेट करते हैं.

एक जैसा काम करने के लिए, हम इनपुट को किसी भी दूसरे नोड की तरह ही मानते हैं.हालांकि, इसे चालू करने का फ़ंक्शन नहीं दिया जाता है. इसलिए, इसका आउटपुट इनपुट के बराबर होता है, जैसे कि y1=xinput.

फ़ॉरवर्ड प्रसार

अब, हम पहली छिपी हुई लेयर को अपडेट करते हैं. हम पिछली लेयर में मौजूद नोड से मिलने वाले आउटपुट y का इस्तेमाल करते हैं और अगली लेयर में मौजूद नोड के इनपुट x का हिसाब लगाने के लिए वेट का इस्तेमाल करते हैं.
xj=
iin(j)wijyi+bj

फ़ॉरवर्ड प्रसार

फिर हम पहली छिपी हुई लेयर में मौजूद नोड के आउटपुट को अपडेट करते हैं. इसके लिए, हम ऐक्टिवेशन फ़ंक्शन f(x)का इस्तेमाल करेंगे.
y=f(x)

फ़ॉरवर्ड प्रसार

इन दो फ़ॉर्मूले का इस्तेमाल करके हम पूरे नेटवर्क में लागू होते हैं और नेटवर्क का आखिरी आउटपुट पाते हैं.
y=f(x)
xj=
iin(j)wijyi+bj

पहले से मौजूद गड़बड़ी

बैक-प्रॉप्लेशन एल्गोरिदम यह तय करता है कि किसी खास उदाहरण के लिए आउटपुट के साथ अनुमानित आउटपुट की तुलना करने के बाद, नेटवर्क के हर वज़न को कितना अपडेट किया जाएगा. इसके लिए, हमें यह पता लगाना होता है कि हर वज़न के हिसाब से गड़बड़ी में क्या बदलाव आता है dEdwij.
गड़बड़ी मिलने पर, हम आसान अपडेट नियम का इस्तेमाल करके ट्रैफ़िक अपडेट कर सकते हैं:
wij=wijαdEdwij
जहां α पॉज़िटिव कॉन्सटेंट होता है, जिसे लर्निंग रेट कहा जाता है. इसे पारदर्शी तौर पर बेहतर बनाने की ज़रूरत है.

[नोट] अपडेट करने का नियम बहुत आसान है: अगर वज़न बढ़ने पर गड़बड़ी कम होती है (dEdwij<0), तो वज़न बढ़ाएं, नहीं तो वज़न बढ़ाने (dEdwij>0) पर गड़बड़ी होने पर, वज़न को कम करें.

पहले से मौजूद डेरिवेटिव

हिसाब लगाने में मदद करने के लिए dEdwij, हम हर नोड के लिए दो और डेरिवेटिव सेव करते हैं: गड़बड़ी में क्या बदलाव होता है:
  • नोड का कुल इनपुट dEdx और
  • नोड का आउटपुट dEdy.

पिछला प्रसार

आइए, गड़बड़ी के पहले ही पता लगाने में मदद करते हैं. हमारे पास इस खास इनपुट के लिए अनुमानित आउटपुट है. इसलिए, हम यह पता लगा सकते हैं कि उस आउटपुट में गड़बड़ी कैसे बदलती है. हमारे गड़बड़ी फ़ंक्शन को देखते हुए E=12(youtputytarget)2 हमारे पास ये हैं:
Eyoutput=youtputytarget

पिछला प्रसार

अब हमारे पास dEdy चैनल के नियम का इस्तेमाल dEdx किया जा सकता है.
Ex=dydxEy=ddxf(x)Ey
जहां ddxf(x)=f(x)(1f(x)) f(x) , Sigmoid ऐक्टिवेशन फ़ंक्शन हो.

पिछला प्रसार

जैसे ही हमें किसी नोड के कुल इनपुट से जुड़ी गड़बड़ी की जानकारी मिलती है, हम उस नोड में आने वाले महत्व के हिसाब से गड़बड़ी का पता लगा सकते हैं.
Ewij=xjwijExj=yiExj

पिछला प्रसार

चेन नियम का इस्तेमाल करके, हम पिछली लेयर से भी dEdy मिल सकते हैं. हमने एक संपूर्ण सर्कल बना दिया है.
Eyi=jout(i)xjyiExj=jout(i)wijExj

पिछला प्रसार

बचे हुए तीन फ़ॉर्मूला को तब तक दोहराना है, जब तक हमने सभी गड़बड़ियों के डेरिवेटिव की गिनती नहीं कर ली.

खत्म.

1y1xinput2y2x2dE/dy2dE/dx2fw12dE/dw3y3x3dE/dy3dE/dx3fw13dE/dw4y4x4dE/dy4dE/dx4fw24dE/dww34dE/dw5y5x5dE/dy5dE/dx5fw25dE/dww35dE/dw6youtputx6dE/dy6dE/dx6fw46dE/dww56dE/dwEytarget
गिनती की जा रही है...