સામગ્રીનું કોષ્ટક[છુપાવો][બતાવો]
મગજ ન્યુરલ નેટવર્ક સાથે તુલનાત્મક છે. આ એક સામ્યતા છે જેનો ઉપયોગ સામાન્ય રીતે વિષયમાં નવી વ્યક્તિને મશીન લર્નિંગ અને કૃત્રિમ ન્યુરલ નેટવર્ક પાછળના વિચારોને સમજવામાં મદદ કરવા માટે થાય છે.
કારણ કે પડદા પાછળ ગાણિતિક અને આંકડાકીય ગણતરીઓના ઘણા સ્તરો ચાલી રહ્યા છે, આ નેટવર્ક્સને ગાણિતિક કાર્ય તરીકે વ્યાખ્યાયિત કરવું એ વધુ અદ્યતન પદ્ધતિ છે.
આ તે લોકો માટે છે કે જેઓ ખરેખર મશીન લર્નિંગમાં રસ ધરાવે છે અને પાયથોન ન્યુરલ નેટવર્ક કોડ કેવી રીતે લખાય છે તે જોવા માંગે છે.
આ લેખમાં, અમે બતાવીશું કે શરૂઆતથી સંપૂર્ણ રીતે કનેક્ટેડ ડીપ ન્યુરલ નેટવર્ક (DNN) કેવી રીતે બનાવવું. પાયથોન 3.
અમારા પાયથોન ન્યુરલ નેટવર્ક કોડ માટે ફાઇલ સ્ટ્રક્ચરની ઝાંખી
અહીં ત્રણ ફાઇલો બનાવવામાં આવશે. પ્રથમ સરળ nn.py ફાઇલ છે, જેની ચર્ચા “સેટિંગ અપ હેલ્પર ફંક્શન્સ” અને “બિલ્ડીંગ ધ ન્યુરલ નેટવર્ક ફ્રોમ સ્ક્રેચ” માં કરવામાં આવશે.
પરીક્ષણ ડેટા લોડ કરવા માટે અમારી પાસે mnist loader.py નામની ફાઇલ પણ હશે, જેમ કે "MNIST ડેટા લોડ કરી રહ્યું છે" માં વર્ણવેલ છે.
છેલ્લે, અમારી પાસે test.py નામની ફાઇલ હશે જે અમારા ન્યુરલ નેટવર્કને ચકાસવા માટે ટર્મિનલમાં લોન્ચ કરવામાં આવશે.
આ ફાઇલનું વિગતવાર વર્ણન "રનિંગ ટેસ્ટ્સ" માં કરવામાં આવ્યું છે.
સ્થાપન
આ ટ્યુટોરીયલને અનુસરવા માટે NumPy Python લાઇબ્રેરી ડાઉનલોડ કરવી આવશ્યક છે. તમે ટર્મિનલ પર નીચેના આદેશનો ઉપયોગ કરીને આ પરિપૂર્ણ કરી શકો છો:
મોડ્યુલ્સ આયાત કરવું અને હેલ્પર ફંક્શન સેટ કરવું
અમને ફક્ત બે લાઇબ્રેરીઓની જરૂર છે રેન્ડમ અને NumPy, જે અમે તરત જ આયાત કરીશું. અમારા ન્યુરલ નેટવર્કના પ્રારંભિક વજન માટે, અમે તેને રેન્ડમ લાઇબ્રેરીનો ઉપયોગ કરીને શફલ કરીશું.
અમારી ગણતરીઓને ઝડપી બનાવવા માટે, અમે NumPy અથવા np નો ઉપયોગ કરીશું (સંમેલન દ્વારા, તે ઘણીવાર np તરીકે આયાત કરવામાં આવે છે). અમારા બે સહાયક કાર્યો અમારી આયાત પછી કરવામાં આવશે. બે સિગ્મોઇડ કાર્યો: એક અને સિગ્મોઇડ પ્રાઇમ.
લોજિસ્ટિક રીગ્રેશન સિગ્મોઇડ ફંક્શનનો ઉપયોગ કરીને ડેટાનું વર્ગીકરણ કરશે, જ્યારે બેકપ્રોપગેશન સિગ્મોઇડ પ્રાઇમ ફંક્શનનો ઉપયોગ કરીને ડેલ્ટા અથવા ગ્રેડિયન્ટની ગણતરી કરશે.
નેટવર્ક ક્લાસ બનાવી રહ્યા છીએ
સંપૂર્ણ રીતે જોડાયેલ ન્યુરલ નેટવર્કનું નિર્માણ આ વિભાગનું એકમાત્ર ધ્યાન છે. નેટવર્ક ક્લાસ પછી આવતા તમામ કાર્યોને સમાવી લેશે. ઑબ્જેક્ટ() { [નેટિવ કોડ] } ફંક્શન શરૂઆતમાં અમારા નેટવર્ક ક્લાસમાં બનાવવામાં આવશે.
ઑબ્જેક્ટ() { [મૂળ કોડ] } ફંક્શન દ્વારા એક દલીલ, માપો જરૂરી છે. માપ ચલ એ આંકડાકીય મૂલ્યોનો સંગ્રહ છે જે આપણા ન્યુરલ નેટવર્કના દરેક સ્તરમાં હાજર ઇનપુટ નોડ્સની સંખ્યા દર્શાવે છે.
અમે અમારી __init__ પદ્ધતિમાં ચાર ગુણધર્મ શરૂ કરીએ છીએ. ઇનપુટ ચલો, કદ, અનુક્રમે સ્તરના કદ અને સ્તરોની સંખ્યા, સંખ્યા સ્તરોની સૂચિ સેટ કરવા માટે વપરાય છે.
પહેલું પગલું એ છે કે ઇનપુટ લેયરને અનુસરતા દરેક સ્તરને અમારા નેટવર્કના પ્રારંભિક પૂર્વગ્રહોને રેન્ડમલી અસાઇન કરવાનું છે.
અંતે, ઇનપુટ અને આઉટપુટ સ્તરો વચ્ચેની દરેક લિંક તેના વજન રેન્ડમલી જનરેટ કરે છે. Np.Random.Randn() સંદર્ભ માટે સામાન્ય વિતરણમાંથી દોરેલા રેન્ડમ નમૂના આપે છે.
ફીડ ફોરવર્ડ કાર્ય
ન્યુરલ નેટવર્કમાં, માહિતી ફીડફોરવર્ડ ફંક્શન દ્વારા આગળ મોકલવામાં આવે છે. એક દલીલ, a, વર્તમાન સક્રિયકરણ વેક્ટર સૂચવે છે, આ કાર્ય દ્વારા જરૂરી રહેશે.
આ ફંક્શન નેટવર્કમાંના તમામ પૂર્વગ્રહો અને વજનને પુનરાવર્તિત કરીને દરેક સ્તર પર સક્રિયકરણનો અંદાજ કાઢે છે. આપેલ જવાબ એ આગાહી છે, જે છેલ્લા સ્તરની સક્રિયકરણો છે.
મીની-બેચ ગ્રેડિયન્ટ ડીસેન્ટ
અમારા નેટવર્ક ક્લાસનું વર્કહોર્સ ગ્રેડિયન્ટ ડીસેન્ટ છે. આ સંસ્કરણમાં, અમે મિની-બેચ (સ્ટોચેસ્ટિક) ગ્રેડિયન્ટ ડિસેન્ટનો ઉપયોગ કરીએ છીએ, જે ગ્રેડિએન્ટ ડિસેન્ટની સંશોધિત વિવિધતા છે.
આ સૂચવે છે કે અમારા મોડલને અપડેટ કરવા માટે ડેટા પોઈન્ટની નાની બેચનો ઉપયોગ કરવામાં આવશે. આ પદ્ધતિમાં ચાર જરૂરી અને એક વૈકલ્પિક દલીલ પસાર કરવામાં આવે છે. ચાર જરૂરી ચલો છે તાલીમ ડેટા સેટ, યુગની સંખ્યા, મિની-બેચનું કદ અને શીખવાનો દર (ઇટા).
ટેસ્ટ ડેટા વિનંતી પર ઉપલબ્ધ છે. જ્યારે અમે આખરે આ નેટવર્કનું મૂલ્યાંકન કરીશું ત્યારે અમે ટેસ્ટ ડેટા સપ્લાય કરીશું. એકવાર તાલીમ ડેટાને સૂચિ પ્રકારમાં રૂપાંતરિત કરવામાં આવે તે પછી આ કાર્યમાં નમૂનાઓની સંખ્યા શરૂઆતમાં સૂચિની લંબાઈ પર સેટ કરવામાં આવે છે.
અમે તે જ પ્રક્રિયાને ચકાસવા માટે પણ લાગુ કરીએ છીએ જે ડેટા આપવામાં આવે છે. આનું કારણ એ છે કે અમને સૂચિ તરીકે પરત કરવાને બદલે, તે ખરેખર સૂચિની ઝિપ છે. જ્યારે અમે MNIST ડેટા સેમ્પલ પછીથી લોડ કરીશું, ત્યારે અમે આ વિશે વધુ જાણીશું.
જો આપણે સુનિશ્ચિત કરી શકીએ કે અમે સૂચિ તરીકે બંને પ્રકારના ડેટા પ્રદાન કરીએ છીએ, તો આ પ્રકાર-કાસ્ટિંગ આવશ્યકપણે આવશ્યક નથી.
એકવાર અમારી પાસે ડેટા હોય, અમે લૂપમાં તાલીમ યુગ પર જઈએ છીએ. તાલીમનો સમયગાળો એ ન્યુરલ નેટવર્ક તાલીમનો માત્ર એક રાઉન્ડ છે. મીની-બેચેસની યાદી બનાવતા પહેલા રેન્ડમનેસની ખાતરી કરવા માટે અમે દરેક યુગમાં પહેલા ડેટાને શફલ કરીએ છીએ.
અપડેટ મીની બેચ કાર્ય, જેની નીચે ચર્ચા કરવામાં આવી છે, દરેક મીની-બેચ માટે બોલાવવામાં આવશે. જો ટેસ્ટ ડેટા ઉપલબ્ધ હશે તો ટેસ્ટની ચોકસાઈ પણ પરત કરવામાં આવશે.
કોસ્ટ-ડેરિવેટિવ હેલ્પર ફંક્શન
ચાલો આપણે ખરેખર બેકપ્રોપેગેશન કોડ બનાવીએ તે પહેલા કોસ્ટ ડેરિવેટિવ નામનું હેલ્પર ફંક્શન વિકસાવીએ. જો આપણે આપણા આઉટપુટ લેયરમાં ભૂલ કરીએ, તો કોસ્ટ ડેરિવેટિવ ફંક્શન તેને બતાવશે.
તેને બે ઇનપુટ્સની જરૂર છે: આઉટપુટ સક્રિયકરણ એરે અને અપેક્ષિત આઉટપુટ મૂલ્યોના y-કોઓર્ડિનેટ્સ.
બેકપ્રોપગેશન કાર્ય
અમારા વર્તમાન સક્રિયકરણ વેક્ટર, સક્રિયકરણ, તેમજ અન્ય કોઈપણ સક્રિયકરણ વેક્ટર, સક્રિયકરણ, અને z-વેક્ટર, zs, બધાને ધ્યાનમાં રાખવા જોઈએ. ઇનપુટ લેયર તરીકે ઓળખાતું એક સ્તર પ્રથમ સક્રિય થાય છે.
અમે તેમને મૂક્યા પછી દરેક પૂર્વગ્રહ અને વજનમાંથી લૂપ કરીશું. દરેક લૂપમાં વજન અને સક્રિયકરણના ડોટ પ્રોડક્ટ તરીકે z વેક્ટરની ગણતરી કરવી, તેને zs ની સૂચિમાં ઉમેરવા, સક્રિયકરણની પુનઃગણતરી અને સક્રિયકરણની સૂચિમાં અપડેટ કરેલ સક્રિયકરણ ઉમેરવાનો સમાવેશ થાય છે.
છેલ્લે, ગણિત. ડેલ્ટા, જે zs વેક્ટર્સના છેલ્લા તત્વના સિગ્મોઇડ પ્રાઇમ દ્વારા ગુણાકાર કરાયેલ અગાઉના સ્તરની ભૂલની બરાબર છે, તે આપણે આપણો પછાત પાસ શરૂ કરીએ તે પહેલાં ગણતરી કરવામાં આવે છે.
નાબલા બીનું છેલ્લું સ્તર ડેલ્ટા તરીકે સેટ કરવામાં આવ્યું છે, અને નાબલા ડબલ્યુનું અંતિમ સ્તર ડેલ્ટાના ડોટ પ્રોડક્ટ અને સક્રિયકરણના બીજા-થી-છેલ્લા સ્તર તરીકે સેટ કરવામાં આવ્યું છે (ટ્રાન્સપોઝ કરવામાં આવ્યું છે જેથી આપણે ખરેખર ગણિત કરી શકીએ) .
અમે પહેલાની જેમ આગળ વધીએ છીએ, બીજા સ્તરથી શરૂ કરીને અને છેલ્લા સ્તર સાથે સમાપ્ત કરીએ છીએ, અને આ છેલ્લા સ્તરોને પૂર્ણ કર્યા પછી પ્રક્રિયાને પુનરાવર્તિત કરીએ છીએ. નાબલોને પછી ટપલ તરીકે પાછા આપવામાં આવે છે.
મિની-બેચ ગ્રેડિયન્ટ ડિસેન્ટ અપડેટ કરી રહ્યું છે
અમારી SGD (સ્ટોકેસ્ટિક ગ્રેડિયન્ટ ડિસેન્ટ) પદ્ધતિમાં મિની-બેચ અપડેટિંગનો સમાવેશ થાય છે. કારણ કે તેનો ઉપયોગ SGD માં થાય છે પણ તેને બેકપ્રોપની પણ જરૂર છે, મેં આ ફંક્શન ક્યાં મૂકવું તે અંગે ચર્ચા કરી.
અંતે, મેં તેને અહીં પોસ્ટ કરવાની પસંદગી કરી. તે અમારા બેકપ્રોપ ફંક્શનની જેમ જ બાયસેસ અને વેટ્સ નાબ્લાસના 0 વેક્ટર જનરેટ કરીને શરૂ થાય છે.
તેને તેના બે ઇનપુટ્સ તરીકે મિની-બેચ અને ઇટા લર્નિંગ રેટની જરૂર છે. મિની-બેચમાં, અમે પછી દરેક ઇનપુટ, x, અને આઉટપુટ, y માટે દરેક નાબલા એરેના ડેલ્ટા મેળવવા માટે બેકપ્રોપ ફંક્શનનો ઉપયોગ કરીએ છીએ. નાબલા સૂચિઓ પછી આ ડેલ્ટા સાથે અપડેટ કરવામાં આવે છે.
છેલ્લે, અમે નેટવર્કના વજન અને પૂર્વગ્રહોને અપડેટ કરવા માટે લર્નિંગ રેટ અને નાબ્લાસનો ઉપયોગ કરીએ છીએ. દરેક મૂલ્યને સૌથી તાજેતરના મૂલ્યમાં અપડેટ કરવામાં આવે છે, ઓછા શીખવાનો દર, મિનિબેચના કદ દ્વારા ગુણાકાર કરવામાં આવે છે, અને પછી નાબલા મૂલ્યમાં ઉમેરવામાં આવે છે.
કાર્યનું મૂલ્યાંકન કરો
મૂલ્યાંકન કાર્ય એ અંતિમ છે જે આપણે લખવાની જરૂર છે. આ કાર્ય માટે ટેસ્ટ ડેટા એકમાત્ર ઇનપુટ છે. આ કાર્યમાં, અમે ફક્ત અપેક્ષિત પરિણામ સાથે નેટવર્કના આઉટપુટની તુલના કરીએ છીએ, y. ઇનપુટ, x, ફોરવર્ડ ફીડ કરીને, નેટવર્કના આઉટપુટ નક્કી થાય છે.
સંપૂર્ણ કોડ
જ્યારે આપણે બધા કોડ ભેગા કરીએ છીએ, ત્યારે તે આ રીતે દેખાય છે.
ન્યુરલ નેટવર્કનું પરીક્ષણ
MNIST ડેટા લોડ કરી રહ્યું છે
આ MNIST ડેટા .pkl.gz ફોર્મેટમાં છે, જેને અમે GZIP નો ઉપયોગ કરીને ખોલીશું અને અથાણાં સાથે લોડ કરીશું. ચાલો આ ડેટાને ત્રણ માપના ટ્યુપલ તરીકે લોડ કરવા માટે એક ઝડપી પદ્ધતિ લખીએ, જે તાલીમ, માન્યતા અને પરીક્ષણ ડેટામાં વિભાજિત છે.
અમારા ડેટાને મેનેજ કરવાનું સરળ બનાવવા માટે, અમે 10-આઇટમ એરેમાં y ને એન્કોડ કરવા માટે બીજું ફંક્શન લખીશું. ઇમેજના યોગ્ય અંક સાથે મેળ ખાતા 0 સિવાય એરે તમામ 1 સે હશે.
અમે અમારા ડેટાને વાંચી શકાય તેવા ફોર્મેટમાં લોડ કરવા માટે મૂળભૂત લોડ ડેટા અને એક હોટ એન્કોડ પદ્ધતિનો ઉપયોગ કરીશું. બીજું ફંક્શન લખવામાં આવશે જે આપણા x મૂલ્યોને 784 કદની સૂચિમાં રૂપાંતરિત કરશે, જે છબીના 784 પિક્સેલ સાથે મેળ ખાશે, અને અમારા y મૂલ્યોને તેમના સિંગલ હોટ એન્કોડેડ વેક્ટર સ્વરૂપમાં રૂપાંતરિત કરશે.
પછી આપણે x અને y ની કિંમતો એવી રીતે જોડીશું કે એક અનુક્રમણિકા બીજા સાથે મેળ ખાય. આ તાલીમ, માન્યતા અને પરીક્ષણ ડેટા સેટને લાગુ પડે છે. અમે પછી બદલાયેલ ડેટા પરત કરીએ છીએ.
ચાલી રહેલ ટેસ્ટ
અમે "mnist લોડર" નામની નવી ફાઇલ બનાવીશું જે અમે પરીક્ષણ શરૂ કરીએ તે પહેલાં અમે અગાઉ સ્થાપિત કરેલ ન્યુરલ નેટવર્ક (સરળ nn) અને MNIST ડેટા સેટ લોડર બંનેને આયાત કરશે.
આ ફાઇલમાં, અમારે માત્ર ડેટા આયાત કરવાની જરૂર છે, 784 ના ઇનપુટ લેયર સાઈઝ અને 10 ના આઉટપુટ લેયર સાઈઝ સાથે નેટવર્ક બનાવવું, ટ્રેનિંગ ડેટા પર નેટવર્કનું SGD ફંક્શન ચલાવવું, પછી ટેસ્ટ ડેટાનો ઉપયોગ કરીને તેનું પરીક્ષણ કરવું.
ધ્યાનમાં રાખો કે અમારી ઇનપુટ સ્તરોની સૂચિ માટે, 784 અને 10 ની વચ્ચેની કોઈપણ સંખ્યા શું છે તેનાથી કોઈ ફરક પડતો નથી. અમે અન્ય સ્તરોને અમને ગમે તે રીતે બદલી શકીએ છીએ; ફક્ત ઇનપુટ અને આઉટપુટ માપો નિશ્ચિત છે.
ત્રણ સ્તરો જરૂરી નથી; આપણે ચાર, પાંચ અથવા તો માત્ર બેનો ઉપયોગ કરી શકીએ છીએ. તેની સાથે પ્રયોગ કરવાની મજા માણો.
ઉપસંહાર
અહીં, Python 3 નો ઉપયોગ કરીને, અમે શરૂઆતથી ન્યુરલ નેટવર્ક બનાવીએ છીએ. ઉચ્ચ-સ્તરના ગણિતની સાથે, અમે અમલીકરણની વિશિષ્ટતાઓની પણ ચર્ચા કરી.
અમે સહાયક કાર્યોનો અમલ કરીને શરૂઆત કરી. ન્યુરોન્સ કામ કરવા માટે, સિગ્મોઇડ અને સિગ્મોઇડ પ્રાઇમ ફંક્શન્સ નિર્ણાયક છે. પછી અમે ફીડફોરવર્ડ ફંક્શનને વ્યવહારમાં મૂકીએ છીએ, જે ન્યુરલ નેટવર્કમાં ડેટા ફીડ કરવાની મૂળભૂત પ્રક્રિયા છે.
આગળ, અમે પાયથોનમાં ગ્રેડિએન્ટ ડિસેન્ટ ફંક્શન બનાવ્યું, એ એન્જિન જે અમારા ન્યુરલ નેટવર્કને ચલાવે છે. "સ્થાનિક મિનિમા" શોધવા અને તેમના વજન અને પૂર્વગ્રહોને ઑપ્ટિમાઇઝ કરવા માટે, અમારું ન્યુરલ નેટવર્ક ગ્રેડિએન્ટ ડિસેન્ટનો ઉપયોગ કરે છે. અમે ઉપયોગ કરીને બેકપ્રોપેગેશન ફંક્શન બનાવ્યું છે ઢાળ વંશ.
જ્યારે આઉટપુટ યોગ્ય લેબલ સાથે મેળ ખાતા ન હોય ત્યારે અપડેટ્સ વિતરિત કરીને, આ કાર્ય ન્યુરલ નેટવર્કને "શીખવા" માટે સક્ષમ કરે છે.
છેલ્લે, અમે અમારું તદ્દન નવું પાયથોન મૂક્યું મજ્જાતંતુકીય નેટવર્ક MNIST ડેટા સેટનો ઉપયોગ કરીને પરીક્ષણ માટે. બધું સરળ રીતે કામ કર્યું.
હેપી કોડિંગ!
એક જવાબ છોડો