Talaan ng nilalaman[Tago][Ipakita]
Ang utak ay maihahambing sa mga neural network. Ito ang pagkakatulad na karaniwang ginagamit upang tulungan ang isang bago sa paksa na maunawaan ang mga ideya sa likod ng machine learning at mga artipisyal na neural network.
Dahil mayroong ilang mga layer ng mathematical at statistical computations na nangyayari sa likod ng mga eksena, ang pagtukoy sa mga network na ito bilang isang mathematical function ay isang mas advanced na paraan.
Ito ay para sa mga taong talagang interesado sa machine learning at gustong makita kung paano isinulat ang Python neural network code.
Sa artikulong ito, ipapakita namin kung paano bumuo ng isang ganap na konektado na deep neural network (DNN) mula sa simula Sawa 3.
Isang Pangkalahatang-ideya ng File Structure para sa Aming Python Neural Network Code
Magkakaroon ng tatlong file na gagawin dito. Ang una ay ang simpleng nn.py file, na tatalakayin sa "Pag-set Up ng Mga Function ng Helper" at "Pagbuo ng Neural Network mula sa Scratch."
Magkakaroon din kami ng file na pinangalanang mnist loader.py upang i-load ang data ng pagsubok, tulad ng inilarawan sa "Naglo-load ng Data ng MNIST."
Sa wakas, magkakaroon kami ng file na pinangalanang test.py na ilulunsad sa terminal upang subukan ang aming neural network.
Ang file na ito ay inilarawan nang detalyado sa "Mga Pagpapatakbo ng Pagsusuri."
instalasyon
Ang NumPy Python library ay dapat ma-download upang masundan ang tutorial na ito. Magagawa mo ito sa pamamagitan ng paggamit ng sumusunod na command sa terminal:
Pag-import ng mga Module at pag-set up ng function na Helper
Ang dalawang library lang na kailangan namin ay random at NumPy, na ii-import namin kaagad. Para sa mga paunang timbang ng aming neural network, isa-shuffle namin ang mga ito gamit ang random na library.
Upang mapabilis ang aming mga pagkalkula, gagamitin namin ang NumPy o np (ayon sa convention, madalas itong ini-import bilang np). Ang aming dalawang pag-andar ng katulong ay gagawin pagkatapos ng aming mga pag-import. Dalawang sigmoid function: isa at sigmoid prime.
Ang logistic regression ay mag-uuri ng data gamit ang sigmoid function, habang ang backpropagation ay kakalkulahin ang delta o gradient gamit ang sigmoid prime function.
Paglikha ng Network Class
Ang pagbuo ng isang ganap na naka-link na neural network ay ang tanging pokus ng seksyong ito. Ang klase ng network ay sumasaklaw sa lahat ng mga function na kasunod nito. Ang function na Object() { [native code] } ay unang gagawin sa aming network class.
Ang isang argumento, mga laki, ay kinakailangan ng function na Object() { [native code] }. Ang variable ng laki ay isang koleksyon ng mga numeric na halaga na kumakatawan sa bilang ng mga input node na nasa bawat layer ng aming neural network.
Sinisimulan namin ang apat na katangian sa aming __init__ na pamamaraan. Ang mga variable ng input, laki, ay ginagamit upang itakda ang listahan ng mga laki ng layer at ang bilang ng mga layer, num layer, ayon sa pagkakabanggit.
Ang unang hakbang ay ang random na pagtatalaga ng mga paunang bias ng aming network sa bawat layer na sumusunod sa input layer.
Sa wakas, ang bawat link sa pagitan ng input at output layer ay may mga timbang na random na nabuo. Nagbibigay ang Np.Random.Randn() ng random na sample na nakuha mula sa normal na distribution para sa konteksto.
Feed Forward Function
Sa isang neural network, ipinapadala ang impormasyon sa pamamagitan ng feedforward function. Isang argumento, a, na nagpapahiwatig ng kasalukuyang activation vector, ay kakailanganin ng function na ito.
Tinatantya ng function na ito ang mga pag-activate sa bawat layer sa pamamagitan ng pag-ulit sa lahat ng mga bias at timbang sa network. Ang sagot na ibinigay ay ang hula, na kung saan ay ang mga pag-activate ng huling layer.
Mini-batch Gradient Descent
Ang workhorse ng aming klase sa Network ay Gradient Descent. Sa bersyong ito, gumagamit kami ng mini-batch (stochastic) gradient descent, isang binagong variation ng gradient descent.
Isinasaad nito na isang maliit na batch ng mga data point ang gagamitin para i-update ang aming modelo. Apat na kinakailangan at isang opsyonal na argumento ang ipinasa sa pamamaraang ito. Ang apat na kinakailangang variable ay ang training data set, ang bilang ng mga epoch, ang laki ng mini-batch, at ang learning rate (eta).
Available ang data ng pagsubok kapag hiniling. Magbibigay kami ng data ng pagsubok kapag nasuri namin ang network na ito. Ang bilang ng mga sample sa function na ito ay unang itinakda sa haba ng listahan kapag ang data ng pagsasanay ay nabago sa isang uri ng listahan.
Inilapat din namin ang parehong proseso sa pagsubok ng data na ibinigay. Ito ay dahil sa halip na ibalik sa amin bilang mga listahan, sila ay talagang mga zip ng mga listahan. Kapag na-load namin ang mga sample ng data ng MNIST sa ibang pagkakataon, malalaman namin ang higit pa tungkol dito.
Kung masisiguro namin na ibinibigay namin ang parehong uri ng data bilang mga listahan, ang ganitong uri ng pag-cast ay hindi kinakailangang mahalaga.
Sa sandaling mayroon na kami ng data, tatalakayin namin ang mga panahon ng pagsasanay sa isang loop. Ang panahon ng pagsasanay ay isang round lamang ng pagsasanay sa neural network. I-shuffle muna namin ang data sa bawat panahon para matiyak ang randomness bago gumawa ng listahan ng mga mini-batch.
Ang pag-update ng mini batch function, na tinalakay sa ibaba, ay tatawagin para sa bawat mini-batch. Ibabalik din ang katumpakan ng pagsubok kung magagamit ang data ng pagsubok.
Cost-derivative helper function
Bumuo muna tayo ng helper function na tinatawag na cost derivative bago tayo gumawa ng backpropagation code. Kung magkamali tayo sa ating output layer, ipapakita ito ng cost derivative function.
Nangangailangan ito ng dalawang input: ang output activations array at ang y-coordinate ng mga inaasahang output value.
Pag-andar ng backpropagation
Ang aming kasalukuyang activation vector, activation, pati na rin ang anumang iba pang activation vectors, activation, at z-vectors, zs, ay dapat isaisip lahat. Ang isang layer na tinatawag na input layer ay na-activate muna.
Susuriin namin ang bawat bias at timbang pagkatapos ilagay ang mga ito. Ang bawat loop ay nagsasangkot ng pagkalkula ng z vector bilang tuldok na produkto ng mga timbang at ang pag-activate, pagdaragdag nito sa listahan ng mga zs, muling pagkalkula ng pag-activate, at pagdaragdag ng na-update na pag-activate sa listahan ng mga pag-activate.
Sa wakas, ang matematika. Ang delta, na katumbas ng error mula sa nakaraang layer na pinarami ng sigmoid prime ng huling elemento ng zs vectors, ay kinukuwenta bago natin simulan ang ating backward pass.
Ang huling layer ng nabla b ay nakatakdang maging delta, at ang huling layer ng nabla w ay nakatakdang maging tuldok na produkto ng delta at ang pangalawa-sa-huling layer ng mga pag-activate (na-transpose para talagang magawa natin ang matematika) .
Nagpapatuloy kami tulad ng dati, nagsisimula sa pangalawang layer at nagtatapos sa huli, at ulitin ang proseso pagkatapos makumpleto ang mga huling layer na ito. Ang nablas ay ibinalik bilang isang tuple.
Ina-update ang Mini-batch gradient descent
Isinasama ng aming SGD (stochastic gradient descent) na paraan bago ang mini-batch na pag-update. Dahil ito ay ginagamit sa SGD ngunit nangangailangan din ng backprop, pinagtatalunan ko kung saan ilalagay ang function na ito.
Sa wakas, nagpasya akong i-post ito dito. Nagsisimula ito sa pamamagitan ng pagbuo ng 0 vectors ng mga biases' at weights' nablas, tulad ng ginawa ng aming backprop function.
Ito ay nangangailangan ng mini-batch at ang eta learning rate bilang dalawang input nito. Sa mini-batch, gagamitin namin ang backprop function para makuha ang delta ng bawat nabla array para sa bawat input, x, at output, y. Ang mga listahan ng nabla ay ina-update sa mga delta na ito.
Panghuli, ginagamit namin ang rate ng pagkatuto at ang nablas para i-update ang mga timbang at bias ng network. Ang bawat halaga ay ina-update sa pinakakamakailang halaga, mas mababa ang rate ng pagkatuto, i-multiply sa laki ng minibatch, at pagkatapos ay idinagdag sa halaga ng nabla.
Suriin ang function
Ang function ng pagsusuri ay ang pangwakas na kailangan nating isulat. Ang data ng pagsubok ay ang tanging input para sa function na ito. Sa function na ito, inihahambing lamang namin ang mga output ng network sa inaasahang resulta, y. Sa pamamagitan ng pagpapakain sa input, x, forward, ang mga output ng network ay natutukoy.
Kumpletuhin ang Code
Kapag pinagsama namin ang lahat ng code, ito ay kung paano ito lilitaw.
Pagsubok sa Neural Network
Nilo-load ang data ng MNIST
Ang data ng MNIST ay nasa .pkl.gz na format, na bubuksan namin gamit ang GZIP at i-load ng atsara. Sumulat tayo ng mabilis na paraan upang mai-load ang data na ito bilang isang tuple na may tatlong sukat, na nahahati sa data ng pagsasanay, pagpapatunay, at pagsubok.
Upang gawing mas madaling pamahalaan ang aming data, magsusulat kami ng isa pang function upang i-encode ang y sa isang 10-item array. Ang array ay magiging 0s lahat maliban sa isang 1 na tumutugma sa wastong digit ng larawan.
Gagamitin namin ang pangunahing data ng pag-load at isang paraan ng hot encode para i-load ang aming data sa isang nababasang format. Isa pang function ang isusulat na magko-convert sa aming mga x value sa isang listahan na may sukat na 784, na tumutugma sa 784 pixels ng imahe, at ang aming mga y value sa kanilang nag-iisang mainit na naka-encode na vector form.
Pagkatapos ay pagsasamahin namin ang mga halaga ng x at y upang ang isang index ay tumutugma sa isa pa. Nalalapat ito sa mga set ng data ng pagsasanay, pagpapatunay, at pagsubok. Pagkatapos ay ibabalik namin ang binagong data.
Pagpapatakbo ng mga Pagsusulit
Gagawa kami ng bagong file na tinatawag na "mnist loader" na mag-i-import ng neural network na itinatag namin dati (simple nn) at ang MNIST data set loader bago namin simulan ang pagsubok.
Sa file na ito, ang kailangan lang nating gawin ay mag-import ng data, bumuo ng isang network na may laki ng input layer na 784 at isang laki ng layer ng output na 10, patakbuhin ang SGD function ng network sa data ng pagsasanay, pagkatapos ay subukan ito gamit ang data ng pagsubok.
Tandaan na para sa aming listahan ng mga layer ng input, walang pagkakaiba kung ano ang alinman sa mga numero sa pagitan ng 784 at 10. Maaari naming baguhin ang iba pang mga layer sa anumang paraan na gusto namin; naayos lang ang laki ng input at output.
Hindi kinakailangan ang tatlong layer; maaari tayong gumamit ng apat, lima, o kahit dalawa lang. Magsaya sa pag-eksperimento dito.
Konklusyon
Dito, gamit ang Python 3, lumikha kami ng neural network mula sa simula. Kasama ng mataas na antas ng matematika, tinalakay din namin ang mga detalye ng pagpapatupad.
Nagsimula kami sa pamamagitan ng pagpapatupad ng mga function ng helper. Para gumana ang mga neuron, mahalaga ang sigmoid at sigmoid prime function. Pagkatapos ay isinabuhay namin ang feedforward function, na siyang pangunahing proseso para sa pagpapakain ng data sa neural network.
Susunod, ginawa namin ang gradient descent function sa Python, ang makina na nagtutulak sa aming neural network. Upang mahanap ang "lokal na minima" at i-optimize ang kanilang mga timbang at bias, ang aming neural network ay gumagamit ng gradient descent. Ginawa namin ang backpropagation function gamit ang gradient descent.
Sa pamamagitan ng paghahatid ng mga update kapag ang mga output ay hindi tumutugma sa mga wastong label, ang function na ito ay nagbibigay-daan sa neural network na "matuto."
Sa wakas, inilagay namin ang aming bagong-bagong Python neural network sa pagsubok gamit ang MNIST data set. Ang lahat ay gumana nang maayos.
Maligayang Coding!
Mag-iwan ng Sagot