Neural network sa python. Paano lumikha ng isang neural network gamit ang Keras library sa Python: isang halimbawa

Ang bahaging ito ay naglalaman ng mga link sa mga artikulo mula sa RuNet tungkol sa kung ano ang mga neural network. Marami sa mga artikulo ay nakasulat sa orihinal, buhay na buhay na wika at napakalinaw. Gayunpaman, dito, para sa karamihan, tanging ang mga pangunahing kaalaman, ang pinakasimpleng mga disenyo, ang isinasaalang-alang. Dito maaari ka ring makahanap ng mga link sa panitikan sa mga neural network. Ang mga aklat-aralin at mga aklat, tulad ng nararapat, ay nakasulat sa akademiko o katulad na wika at naglalaman ng mga hindi malinaw, abstract na mga halimbawa ng pagbuo ng mga neural network, kanilang pagsasanay, atbp. Dapat itong isipin na ang terminolohiya sa iba't ibang mga artikulo ay "lumulutang", tulad ng maaari makikita mula sa mga komento hanggang sa mga artikulo. Dahil dito, sa una ay maaaring magkaroon ng "gulo sa ulo."

  • Paano pinagbukud-bukod ng isang Japanese na magsasaka ang mga pipino gamit ang deep learning at TensorFlow
  • Mga neural network sa mga larawan: mula sa isang neuron hanggang sa malalalim na arkitektura
  • Isang halimbawa ng isang neural network program na may source code sa C++.
  • Pagpapatupad ng isang solong-layer na neural network - perceptron para sa problema ng pag-uuri ng sasakyan
  • Mag-download ng mga aklat sa mga neural network. Malusog!
  • Mga teknolohiya sa stock market: 10 maling kuru-kuro tungkol sa mga neural network
  • Algorithm para sa pagsasanay ng isang multilayer neural network gamit ang paraan ng backpropagation

Mga neural network sa Python

Maaari mong basahin nang maikli ang tungkol sa kung anong mga aklatan ang umiiral para sa Python. Mula dito kukuha ako ng mga halimbawa ng pagsubok upang matiyak na ang kinakailangang pakete ay na-install nang tama.

tensorflow

Ang gitnang bagay ng TensorFlow ay ang data flow graph na kumakatawan sa computation. Ang mga vertice ng graph ay kumakatawan sa mga operasyon, at ang mga gilid ay kumakatawan sa mga tensor (tensor) ( multidimensional na mga array, na siyang batayan ng TensorFlow). Ang data flow graph sa kabuuan ay buong paglalarawan mga kalkulasyon na ipinatupad sa loob ng isang session at ginagawa sa mga device (CPU o GPU). Tulad ng maraming iba pang modernong sistema para sa siyentipikong pag-compute at machine learning Ang TensorFlow ay may mahusay na dokumentadong API para sa Python, kung saan ang mga tensor ay kinakatawan bilang pamilyar na NumPy ndarray arrays. Nagsasagawa ang TensorFlow ng mga kalkulasyon gamit ang lubos na na-optimize na C++ at sinusuportahan din ang mga native na API para sa C at C++.
  • Panimula sa machine learning na may tensorflow. Sa ngayon, ang unang artikulo lamang sa apat na inihayag ay nai-publish.
  • Nakakadismaya ang TensorFlow. Ang malalim na pag-aaral ng Google ay kulang sa "depth"
  • Machine Learning sa isang Sulyap: Pag-uuri ng Teksto sa Mga Neural Network at TensorFlow
  • Google TensorFlow machine learning library – mga unang impression at paghahambing sa sarili naming pagpapatupad

Ang pag-install ng tensorflow ay mahusay na inilarawan sa artikulo sa unang link. Gayunpaman, inilabas na ngayon ang Python 3.6.1. Hindi ito magiging posible na gamitin ito. Hindi bababa sa asupre sa ngayon (06/03/2017). Nangangailangan ng bersyon 3.5.3, na maaaring ma-download. Sa ibaba ay ibibigay ko ang pagkakasunud-sunod na nagtrabaho para sa akin (medyo naiiba sa artikulo mula sa Habr). Hindi malinaw kung bakit, ngunit ginawa ang Python 64-bit processor ng AMD naaayon, lahat ng iba pa ay napupunta sa ilalim nito. Pagkatapos i-install ang Phyton, huwag kalimutang magtakda ng ganap na access para sa mga user kung ang Python ay na-install para sa lahat.

pip install --upgrade pip
pip install -U pip setuptools
pip3 install --upgrade tensorflow
pip3 install --upgrade tensorflow-gpu
pip install matplotlib /*Nag-download ng 8.9 MB at ilang mas maliliit na file */
pip install jupyter

Ang "Naked Python" ay maaaring mukhang hindi kawili-wili. Samakatuwid, nasa ibaba ang mga tagubilin para sa pag-install sa kapaligiran ng Anaconda. Ito ay isang alternatibong build. Python na isinama dito.

Nagtatampok muli ang site ng bagong bersyon para sa Python 3.6, na hindi pa sinusuportahan ng bagong produkto ng Google. Samakatuwid, agad kong kinuha ang isang mas naunang bersyon mula sa archive, katulad ng Anaconda3-4.2.0 - angkop ito. Huwag kalimutang suriin ang Python 3.5 registration box. Sa partikular, bago i-install ang Anaconda, mas mahusay na isara ang terminal, kung hindi man ay patuloy itong gagana sa isang hindi napapanahong PATH. Gayundin, huwag kalimutang baguhin ang mga karapatan sa pag-access ng gumagamit, kung hindi, walang gagana.

conda lumikha -n tensorflow
buhayin ang tensorflow
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*Na-download mula sa Internet 19.4 MB, pagkatapos ay 7 , 7 MB at isa pang 0.317 MB*/
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-1.1.0-cp35-cp35m-win_amd64.whl /*Download 48.6 MB */

Screenshot ng screen ng pag-install: maayos ang lahat sa Anaconda.

Gayundin para sa pangalawang file.

Buweno, sa konklusyon: upang gumana ang lahat ng ito, kailangan mong i-install ang pakete ng CUDA Toolkits mula sa NVIDEA (kung sakaling paggamit ng GPU). Ang kasalukuyang sinusuportahang bersyon ay 8.0. Kakailanganin mo ring i-download at i-unpack ang cuDNN v5.1 library sa CUDA folder, ngunit hindi isang mas bagong bersyon! Pagkatapos ng lahat ng manipulasyong ito, gagana ang TensorFlow.

Theano

  • Sinuri ng paulit-ulit na neural network sa 10 linya ng code ang feedback mula sa mga manonood ng bagong episode ng "Star Wars"

Ang Theano package ay kasama sa sariling PyPI ng Python. Sa pamamagitan ng kanyang sarili ito ay maliit - 3.1 MB, ngunit ito ay kumukuha ng isa pang 15 MB ng mga dependencies - scipy. Upang i-install ang huli, kailangan mo rin ang lapack module... Sa pangkalahatan, ang pag-install ng theano package sa ilalim ng Windows ay nangangahulugang "pagsasayaw gamit ang tamburin." Sa ibaba ay susubukan kong ipakita ang pagkakasunud-sunod ng mga aksyon para gumana ang package.

Kapag gumagamit ng Anaconda, ang "pagsasayaw gamit ang tamburin" sa panahon ng pag-install ay hindi nauugnay. Ang utos ay sapat na:

conda install theano

at awtomatikong nagaganap ang proseso. Siyanga pala, naka-load din ang mga GCC packages.

Scikit-Matuto

Sa ilalim ng Python 3.5.3, higit lamang sa maagang bersyon 0.17.1 na maaari mong kunin. Mayroong isang normal na installer. Gayunpaman, hindi ito gagana nang direkta sa ilalim ng Windows - kailangan mo ang scipy library.

Pag-install ng Helper Package

Upang gumana ang dalawang pakete sa itaas (pinag-uusapan natin ang tungkol sa "hubad" na Phyton), kailangan mong gumawa ng ilang mga paunang hakbang.

SciPy

Upang ilunsad ang Scikit-Learn at Theano, tulad ng naging malinaw mula sa itaas, kakailanganin mong "magsayaw na may tamburin." Ang unang bagay na ibinibigay sa amin ng Yandex ay isang kamalig ng karunungan, kahit na sa Ingles, ang mapagkukunang stackoverflow.com, kung saan nakakita kami ng isang link sa isang mahusay na archive ng halos lahat ng umiiral na mga pakete ng Python na pinagsama-sama para sa Windows - lfd.uci.edu

Narito ang mga handa-i-install na mga asembliya ng mga pakete na kasalukuyan kang interesado, na pinagsama-sama iba't ibang bersyon sawa. Sa aming kaso, kinakailangan ang mga bersyon ng file, na naglalaman ng linyang "-cp35-win_amd64" sa pangalan nito dahil ito mismo ang Pakete ng Python ay ginamit para sa pag-install. Sa stakowerflow, kung maghahanap ka, mahahanap mo rin ang "mga tagubilin" para sa pag-install ng aming mga partikular na package.

pip install --upgrade --ignore-installed http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
pip install --upgrade --ignore-insalled http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/scipy-0.19.0-cp35-cp35m-win_amd64.whl
pip --upgrade --ignore-installed pandas
pip install --upgrade --ignore-installed matplotlib

Ang huling dalawang pakete ay lumitaw sa aking kadena dahil sa "pagsayaw ng ibang tao na may tamburin." Hindi ko napansin ang mga ito sa mga dependency ng mga naka-install na pakete, ngunit tila ang ilan sa kanilang mga bahagi ay kailangan para sa normal na proseso ng pag-install.

Lapack/Blas

Ang dalawang nauugnay na mababang antas na mga aklatan, na nakasulat sa Fortran, ay kailangan upang mai-install ang Theano package. Ang Scikit-Learn ay maaari ding gumana sa mga naka-install na "nakatago" sa iba pang mga pakete (tingnan sa itaas). Sa totoo lang, kung naka-install ang Theano version 0.17 mula sa exe file, gagana rin ito. Hindi bababa sa Anaconda. Gayunpaman, ang mga aklatang ito ay matatagpuan din sa Internet. Halimbawa . Higit pang mga kamakailang build. Para gumana ang natapos na pakete nakaraang bersyon kasya ito. Ang pagbuo ng bagong package ay mangangailangan ng mga bagong bersyon.

Dapat ding tandaan na sa isang ganap na sariwang build ng Anaconda, ang Theano package ay mas madaling mai-install - sa isang utos, ngunit sa totoo lang, wala akong pakialam sa yugtong ito(zero) na pinagkadalubhasaan ang mga neural network, mas nagustuhan ko ang TensorFlow, ngunit hindi pa ito palakaibigan sa mga bagong bersyon ng Python.

  • Programming
    • Pagsasalin

    Tungkol saan ang artikulo?

    Sa personal, pinakamahusay akong natututo gamit ang maliit na working code na maaari kong paglaruan. Sa tutorial na ito, malalaman natin ang backpropagation algorithm gamit ang isang maliit na neural network na ipinatupad sa Python bilang isang halimbawa.

    Bigyan mo ako ng code!

    X = np.array([ ,,, ]) y = np.array([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 para sa j sa xrange(60000): l1 = 1/(1+np.exp(-(np.dot(X,syn0)))) l2 = 1/(1+np. exp(-(np.dot(l1,syn1)))) l2_delta = (y - l2)*(l2*(1-l2)) l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1 )) syn1 += l1.T.dot(l2_delta) syn0 += X.T.dot(l1_delta)

    Masyadong compressed? Hatiin natin ito sa mas simpleng bahagi.

    Bahagi 1: Maliit na laruang neural network

    Ang isang neural network na sinanay sa pamamagitan ng backpropagation ay sumusubok na gumamit ng input data upang mahulaan ang output data.

    Sabihin nating kailangan nating hulaan kung ano ang magiging hitsura ng column ng output batay sa data ng input. Ang problemang ito ay maaaring malutas sa pamamagitan ng pagkalkula ng istatistikal na pagsusulatan sa pagitan nila. At makikita natin na ang kaliwang column ay 100% na nakakaugnay sa output.

    Ang backpropagation, sa pinakasimpleng kaso nito, ay kinakalkula ang mga istatistika tulad ng mga ito upang lumikha ng isang modelo. Subukan natin.

    Neural network sa dalawang layer

    mag-import ng numpy bilang np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x) )) # input data set X = np.array([ , , , ]) # output data y = np.array([]).T # do random na mga numero mas tiyak np.random.seed(1) # randomize ang pagsisimula ng mga timbang na may average na 0 syn0 = 2*np.random.random((3,1)) - 1 para sa iter sa xrange(10000): # forward propagation l0 = X l1 = nonlin(np.dot(l0,syn0)) # gaano tayo naging mali?

    l1_error = y - l1 # multiply ito sa slope ng sigmoid # batay sa mga halaga sa l1 l1_delta = l1_error * nonlin(l1,True) # !!!

    # i-update ang mga timbang syn0 += np.dot(l0.T,l1_delta) # !!! i-print ang "Output pagkatapos ng pagsasanay:" i-print ang l1






    Output pagkatapos ng pagsasanay: [[ 0.00966449] [ 0.00786506] [ 0.99358898] [ 0.99211957]]
    Mga variable at ang kanilang mga paglalarawan.
    "*" - element-wise multiplication - dalawang vector na magkapareho ang laki ay nagpaparami ng katumbas na halaga, at ang output ay isang vector ng parehong laki

    • "-" – element-wise na pagbabawas ng mga vectors
    • x.dot(y) – kung ang x at y ay mga vector, ang output ay magiging scalar product. Kung ito ay mga matrice, ang resulta ay matrix multiplication. Kung ang matrix ay isa lamang sa kanila, ito ay ang pagpaparami ng isang vector at isang matrix.
    • ihambing ang l1 pagkatapos ng unang pag-ulit at pagkatapos ng huli
    • tingnan ang nonlin function.
    • tingnan kung paano nagbabago ang l1_error

    parse line 36 - ang pangunahing lihim na sangkap ay nakolekta dito (minarkahan!!!)

    parse line 39 - ang buong network ay naghahanda nang tumpak para sa operasyong ito (minarkahan!!!)

    Hatiin natin ang linya ng code sa bawat linya

    import numpy bilang np

    Nag-import ng numpy, isang linear algebra library. Ang tanging adiksyon namin.

    Def nonlin(x,deriv=False):

    Ang aming nonlinearity. Ang partikular na function na ito ay lumilikha ng isang "sigmoid". Ito ay tumutugma sa anumang numero na may halaga mula 0 hanggang 1 at nagko-convert ng mga numero sa mga probabilidad, at mayroon ding ilang iba pang mga katangian na kapaki-pakinabang para sa pagsasanay ng mga neural network.

    If(deriv==True):

    Ang function na ito ay maaari ding gumawa ng derivative ng sigmoid (deriv=True). Ito ay isa sa mga kapaki-pakinabang na katangian nito. Kung ang output ng function ay isang out variable, ang derivative ay lalabas * (1-out). Epektibo.

    X = np.array([ , …

    Sinisimulan ang input data array bilang isang numpy matrix. Ang bawat linya ay isang halimbawa ng pagsasanay. Ang mga column ay mga input node. Nagtatapos kami ng 3 input node sa network at 4 na halimbawa ng pagsasanay.

    Y = np.array([]).T

    Salamat dito, ang random na pamamahagi ay magiging pareho sa bawat oras. Ito ay magpapahintulot sa amin na mas madaling masubaybayan ang network pagkatapos naming gumawa ng mga pagbabago sa code.

    Syn0 = 2*np.random.random((3,1)) – 1

    Matrix ng timbang ng network. Ang ibig sabihin ng syn0 ay "synapse zero". Dahil mayroon lamang tayong dalawang layer, input at output, kailangan natin ng isang weight matrix na magkokonekta sa kanila. Ang dimensyon nito ay (3, 1), dahil mayroon kaming 3 input at 1 output. Sa madaling salita, ang l0 ay may sukat na 3 at ang l1 ay may sukat na 1. Dahil ikinokonekta namin ang lahat ng mga node sa l0 sa lahat ng mga node sa l1, kailangan namin ng isang matrix ng dimensyon (3, 1).

    Tandaan na ito ay random na pinasimulan at ang mean ay zero. Mayroong isang medyo kumplikadong teorya sa likod nito. Sa ngayon, gagawin lang namin ito bilang isang rekomendasyon. Tandaan din na ang aming neural network ay ang mismong matrix na ito. Mayroon kaming "mga layer" l0 at l1, ngunit ito ay mga pansamantalang halaga batay sa set ng data. Hindi namin sila iniimbak. Ang lahat ng pagsasanay ay naka-imbak sa syn0.

    Para sa iter sa xrange(10000):

    Dito magsisimula ang pangunahing code ng pagsasanay sa network. Ang code loop ay paulit-ulit nang maraming beses at ino-optimize ang network para sa set ng data.

    Ang unang layer, l0, ay data lamang. Ang X ay naglalaman ng 4 na halimbawa ng pagsasanay. Ipoproseso namin silang lahat nang sabay-sabay - ito ay tinatawag na group training. Sa kabuuan mayroon kaming 4 magkaibang linya l0, ngunit maaari mong isipin ang mga ito bilang isang halimbawa ng pagsasanay - sa yugtong ito ay hindi mahalaga (maaari mong i-load ang 1000 o 10000 sa kanila nang walang anumang pagbabago sa code).

    L1 = nonlin(np.dot(l0,syn0))

    Ito ay isang hakbang ng hula. Hinahayaan namin ang network na subukang hulaan ang output batay sa input. Pagkatapos ay makikita natin kung paano niya ito ginagawa para ma-tweak natin ito para sa pagpapabuti.

    Mayroong dalawang hakbang sa bawat linya. Ang una ay gumagawa ng matrix multiplication ng l0 at syn0. Ang pangalawa ay pumasa sa output sa pamamagitan ng sigmoid. Ang kanilang mga sukat ay ang mga sumusunod:

    (4 x 3) tuldok (3 x 1) = (4 x 1)

    Ang pagpaparami ng matrix ay nangangailangan na ang mga sukat ay pareho sa gitna ng equation. Ang panghuling matrix ay may parehong bilang ng mga hilera gaya ng una, at parehong bilang ng mga hanay gaya ng pangalawa.

    Nag-load kami ng 4 na halimbawa ng pagsasanay at nakakuha ng 4 na hula (4x1 matrix). Ang bawat output ay tumutugma sa hula ng network para sa isang ibinigay na input.

    L1_error = y - l1

    Dahil ang l1 ay naglalaman ng mga hula, maaari nating ihambing ang kanilang pagkakaiba sa katotohanan sa pamamagitan ng pagbabawas ng l1 mula sa tamang sagot na y. Ang l1_error ay isang vector ng positibo at negatibong mga numero na nagpapakilala sa isang "miss" ng network.

    At narito ang sikretong sangkap. Ang linyang ito ay kailangang i-parse nang paisa-isa.

    Unang bahagi: derivative

    Nonlin(l1,Totoo)

    Ang L1 ay kumakatawan sa tatlong puntong ito, at ang code ay gumagawa ng slope ng mga linyang ipinapakita sa ibaba. Tandaan na para sa malalaking halaga tulad ng x=2.0 (berdeng tuldok) at napakaliit na halaga tulad ng x=-1.0 (purple) ang mga linya ay may bahagyang slope. Ang pinakamalaking anggulo sa puntong x=0 (asul). Malaki ang pagkakaiba nito. Tandaan din na ang lahat ng mga derivative ay mula 0 hanggang 1.

    Buong expression: error-weighted derivative

    L1_delta = l1_error * nonlin(l1,True)

    Sa matematika, may mga mas tumpak na pamamaraan, ngunit sa aming kaso ang isang ito ay angkop din. Ang l1_error ay isang (4,1) matrix. Ang nonlin(l1,True) ay nagbabalik ng (4,1) matrix. Dito pinarami namin ang mga ito ng elemento sa pamamagitan ng elemento, at sa output ay nakuha din namin ang matrix (4,1), l1_delta.

    Sa pamamagitan ng pagpaparami ng mga derivative sa mga error, binabawasan namin ang mga error ng mga hula na ginawa nang may mataas na kumpiyansa. Kung ang slope ng linya ay maliit, kung gayon ang network ay naglalaman ng alinman sa isang napakalaki o napakaliit na halaga. Kung ang hula ng network ay malapit sa zero (x=0, y=0.5), kung gayon hindi ito partikular na kumpiyansa. Ina-update namin ang mga hindi tiyak na hulang ito at hinahayaan namin ang mga hula na may mataas na kumpiyansa sa pamamagitan ng pagpaparami ng mga ito sa mga halagang malapit sa zero.

    Syn0 += np.dot(l0.T,l1_delta)

    Handa kaming i-update ang network. Tingnan natin ang isang halimbawa ng pagsasanay. Sa loob nito ay i-update namin ang mga timbang. I-update ang pinakakaliwang timbang (9.5)

    Weight_update = input_value * l1_delta

    Para sa pinakakaliwang timbang ito ay magiging 1.0 * l1_delta. Marahil ito ay tataas lamang nang bahagya ang 9.5. bakit naman Dahil ang hula ay medyo kumpiyansa na, at ang mga hula ay halos tama. Ang isang maliit na error at isang bahagyang slope ng linya ay nangangahulugan ng isang napakaliit na update.

    Ngunit dahil gumagawa kami ng grupong pagsasanay, inuulit namin ang hakbang sa itaas para sa lahat ng apat na halimbawa ng pagsasanay. Kaya't mukhang halos kapareho sa larawan sa itaas. Kaya ano ang ginagawa ng aming linya? Binibilang nito ang mga update sa timbang para sa bawat timbang, para sa bawat halimbawa ng pagsasanay, nagbubuod ng mga ito at ina-update ang lahat ng mga timbang - lahat sa isang linya.

    Pagkatapos obserbahan ang pag-update ng network, bumalik tayo sa aming data ng pagsasanay. Kapag ang parehong input at output ay 1, pinapataas namin ang bigat sa pagitan ng mga ito. Kapag ang input ay 1 at ang output ay 0, binabawasan namin ang timbang.

    Input Output 0 0 1 0 1 1 1 1 1 0 1 1 1 0 1 1 0

    Kaya, sa aming apat mga halimbawa ng pagsasanay sa ibaba, ang bigat ng unang input na nauugnay sa output ay tataas o mananatiling pare-pareho, at ang iba pang dalawang timbang ay tataas at bababa depende sa mga halimbawa. Ang epektong ito ay nag-aambag sa pag-aaral ng network batay sa mga ugnayan ng input at output data.

    Bahagi 2: isang mas mahirap na gawain

    Input Output 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

    Subukan nating hulaan ang output data batay sa tatlong column ng input data. Wala sa mga column ng input ang 100% na nauugnay sa output. Ang ikatlong hanay ay hindi konektado sa anumang bagay, dahil naglalaman ito ng lahat ng paraan. Gayunpaman, dito makikita mo ang pattern - kung ang isa sa unang dalawang column (ngunit hindi pareho nang sabay-sabay) ay naglalaman ng 1, kung gayon ang resulta ay magiging katumbas din ng 1.

    Ito ay isang non-linear na disenyo dahil walang direktang isa-sa-isang pagsusulatan sa pagitan ng mga column. Ang tugma ay batay sa kumbinasyon ng mga input, column 1 at 2.

    Kapansin-pansin, ang pagkilala sa pattern ay isang katulad na gawain. Kung mayroon kang 100 larawan ng mga bisikleta at tubo na may parehong laki, ang pagkakaroon ng ilang pixel sa ilang partikular na lugar ay hindi direktang nauugnay sa pagkakaroon ng bisikleta o pipe sa larawan. Sa istatistika, ang kanilang kulay ay maaaring lumitaw nang random. Ngunit ang ilang kumbinasyon ng mga pixel ay hindi basta-basta - yaong mga bumubuo ng imahe ng isang bisikleta (o tubo).


    Diskarte

    Upang pagsamahin ang mga pixel sa isang bagay na maaaring magkaroon ng isa-sa-isang sulat sa output, kailangan mong magdagdag ng isa pang layer. Pinagsasama ng unang layer ang input, ang pangalawa ay nagtatalaga ng isang tugma sa output gamit ang output ng unang layer bilang input. Bigyang-pansin ang mesa.

    Input (l0) Mga nakatagong timbang (l1) Output (l2) 0 0 1 0.1 0.2 0.5 0.2 0 0 1 1 0.2 0.6 0.7 0.1 1 1 0 1 0.3 0.2 0.3 0.9 1 1 .

    Sa pamamagitan ng random na pagtatalaga ng mga timbang, nakakakuha kami ng mga nakatagong halaga para sa layer No. 1. Kapansin-pansin, ang pangalawang nakatagong hanay ng mga timbang ay mayroon nang maliit na ugnayan sa output. Hindi perpekto, ngunit doon. At ito ay isa ring mahalagang bahagi ng proseso ng pagsasanay sa network. Ang pagsasanay ay magpapatibay lamang sa ugnayang ito. Ia-update nito ang syn1 para italaga ang pagmamapa nito sa output data, at syn0 para mas mahusay na makuha ang input data.

    Neural network sa tatlong layer

    mag-import ng numpy bilang np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # random na sinisimulan ang mga timbang, sa average - 0 syn0 = 2*np.random. random ((3,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 para sa j sa xrange(60000): # sumulong sa mga layer 0, 1 at 2 l0 = X l1 = nonlin(np.dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # gaano tayo nagkamali tungkol sa kinakailangang halaga?

    l2_error = y - l2 if (j% 10000) == 0: i-print ang "Error:" + str(np.mean(np.abs(l2_error))) # saan ka dapat lumipat?

    # kung tiwala kami sa hula, hindi na namin kailangang baguhin ito ng marami l2_delta = l2_error*nonlin(l2,deriv=True) # gaano kalaki ang epekto ng mga value ng l1 sa mga error sa l2?

    l1_error = l2_delta.dot(syn1.T) # saang direksyon tayo dapat lumipat para makarating sa l1?
    # kung tiwala kami sa hula, hindi na namin ito kailangang baguhin nang malaki l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot (l1_delta)
    Error:0.496410031903 Error:0.00858452565325 Error:0.00578945986251 Error:0.00462917677677 Error:0.00395876528020 Error:506.8020 Error:506.
    Mga variable at ang kanilang mga paglalarawan
    Ang X ay ang matrix ng input data set; mga string - mga halimbawa ng pagsasanay
    y – matrix ng output data set; mga string - mga halimbawa ng pagsasanay
    l0 – ang unang layer ng network na tinukoy ng input data
    l1 – pangalawang layer ng network, o nakatagong layer
    Ang l2 ay ang huling layer, ito ang aming hypothesis. Habang nagsasanay ka, dapat kang lumapit sa tamang sagot.
    syn0 – ang unang layer ng mga timbang, Synapse 0, pinagsasama ang l0 at l1.
    syn1 – Ang pangalawang layer ng mga timbang, Synapse 1, ay pinagsasama ang l1 at l2.

    l2_error – error sa network sa dami ng termino

    l2_delta – error sa network, depende sa kumpiyansa ng hula. Halos magkapareho sa error, maliban sa mga kumpiyansa na hula

    Gumagamit ng mga error na natimbang ng kumpiyansa ng mga hula mula sa l2 upang kalkulahin ang error para sa l1. Nakukuha namin, maaaring sabihin ng isa, ang isang error na natimbang ng mga kontribusyon - kinakalkula namin kung gaano kalaki ang kontribusyon ng mga halaga sa mga node l1 sa mga error sa l2. Ang hakbang na ito ay tinatawag na backpropagation mga pagkakamali. Pagkatapos ay ina-update namin ang syn0 gamit ang parehong algorithm tulad ng dalawang-layer na neural network.

    Keras- sikat na aklatan malalim na pag-aaral, na gumawa ng malalaking kontribusyon sa komersyalisasyon ng malalim na pag-aaral. Ang Keras ay madaling gamitin at nagbibigay-daan sa iyo na lumikha ng mga neural network gamit lamang ang ilang linya ng Python code.

    Sa artikulong ito, matututunan mo kung paano gamitin ang Keras para gumawa ng neural network na hinuhulaan kung paano ire-rate ng mga user ang isang produkto batay sa kanilang mga review, na inuuri ito sa dalawang kategorya: positibo o negatibo. Ang gawaing ito ay tinatawag pagsusuri ng damdamin (pagsusuri ng damdamin), at lulutasin namin ito sa tulong ng site ng pagsusuri ng pelikula na IMDb. Ang modelong gagawin namin ay maaari ding ilapat upang malutas ang iba pang mga problema pagkatapos ng maliliit na pagbabago.

    Pakitandaan na hindi kami magdedetalye tungkol sa Keras at malalim na pag-aaral. Ang post na ito ay inilaan upang magbigay ng isang eskematiko sa Keras at ipakilala ang pagpapatupad nito.

    • Ano ang Keras?
    • Ano ang pagsusuri ng damdamin?
    • Dataset IMDB
    • Paggalugad ng Data
    • Paghahanda ng datos
    • Paglikha ng modelo at pagsasanay

    Ano ang Keras?

    Ang Keras ay isang open-source na library ng Python source code, na nagpapadali sa paggawa ng mga neural network. Ang library ay katugma sa , Microsoft Cognitive Toolkit, Theano at MXNet. Ang Tensorflow at Theano ay ang pinakakaraniwang ginagamit na Python numerical frameworks para sa pagbuo ng malalim na mga algorithm sa pag-aaral, ngunit medyo mahirap gamitin ang mga ito.


    Pagtatasa sa kasikatan ng mga machine learning framework sa 7 kategorya

    Ang Keras, sa kabilang banda, ay nagbibigay ng simple at maginhawang paraan upang lumikha ng mga modelo ng malalim na pag-aaral. Ang lumikha nito, si François Chollet, ay binuo ito upang mapabilis at gawing simple ang proseso ng paglikha ng mga neural network hangga't maaari. Nakatuon siya sa extensibility, modularity, minimalism, at suporta sa Python. Maaaring gamitin ang Keras sa GPU at CPU; sinusuportahan nito ang parehong Python 2 at Python 3. Keras Google ay gumawa ng malaking kontribusyon sa komersyalisasyon ng malalim na pag-aaral at dahil naglalaman ito ng makabagong mga algorithm ng malalim na pag-aaral na dati ay hindi lamang naa-access, ngunit hindi rin magagamit.

    Ano ang pagsusuri ng damdamin (pagsusuri ng damdamin)?

    Maaaring gamitin ang pagsusuri ng sentimento upang matukoy ang saloobin ng isang tao (i.e., mood) patungo sa teksto, isang pakikipag-ugnayan, o isang kaganapan. Samakatuwid, ang pagsusuri ng damdamin ay kabilang sa larangan ng pagproseso natural na wika, kung saan ang kahulugan ng teksto ay dapat matukoy upang makuha ang tonality at damdamin mula dito.


    Halimbawa ng isang sukatan ng pagsusuri ng damdamin

    Ang mood spectrum ay karaniwang nahahati sa positibo, negatibo at neutral mga kategorya. Gamit ang pagsusuri ng damdamin, maaari mong, halimbawa, hulaan ang mga opinyon ng mga customer at ang kanilang saloobin sa isang produkto batay sa mga review na kanilang isinusulat. Samakatuwid, malawakang inilalapat ang pagsusuri ng damdamin sa mga pagsusuri, survey, teksto at marami pang iba.

    IMDb dataset


    Mga review sa IMDb

    Ang dataset ng IMDb ay binubuo ng 50,000 review ng pelikula mula sa mga user, na may label na positibo (1) at negatibo (0).

    • Ang mga review ay paunang naproseso at ang bawat isa ay naka-encode na may pagkakasunod-sunod ng mga indeks ng salita bilang mga integer.
    • Ang mga salita sa mga review ay ini-index ayon sa kanilang pangkalahatang dalas ng paglitaw sa dataset. Halimbawa, ang integer na "2" ay nag-encode ng pangalawang pinakamadalas na ginagamit na salita.
    • Ang 50,000 review ay nahahati sa dalawang set: 25,000 para sa pagsasanay at 25,000 para sa pagsubok.

    Ang dataset ay nilikha ng mga mananaliksik sa Stanford University at ipinakita sa isang 2011 na papel, kung saan ang nakamit na katumpakan ng hula ay 88.89%. Ginamit din ang dataset bilang bahagi ng isang kumpetisyon sa komunidad ng Keggle "Bag of Words Meet Bags of Popcorn" noong 2011.

    Pag-import ng mga Dependency at Pagkuha ng Data

    Magsimula tayo sa pamamagitan ng pag-import ng mga kinakailangang dependency upang i-preprocess ang data at bumuo ng modelo.

    %matplotlib inline import matplotlib import matplotlib.pyplot bilang plt import numpy bilang np mula sa keras.utils import to_categorical mula sa mga hard import na modelo mula sa hard import layers

    I-load natin ang dataset ng IMDb, na naka-built na sa Keras. Dahil ayaw naming magkaroon ng 50/50 na data ng pagsasanay at pagsubok, agad naming isasama ang data na ito pagkatapos mag-load para sa paghahati sa ibang pagkakataon sa isang ratio na 80/20:

    Mula sa keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate((training_data, testing_data), axis=0) targets = np.concatenate((training_targets , testing_targets), axis=0)

    Paggalugad ng Data

    Pag-aralan natin ang ating dataset:

    Print("Mga Kategorya:", np.unique(mga target)) print("Bilang ng mga natatanging salita:", len(np.unique(np.hstack(data)))) Mga Kategorya: Bilang ng mga natatanging salita: 9998 haba = print ("Average na haba ng Review:", np.mean(length)) print("Standard Deviation:", round(np.std(length))) Average na haba ng Review: 234.75892 Standard Deviation: 173.0

    Makikita mo na ang lahat ng data ay nabibilang sa dalawang kategorya: 0 o 1, na kumakatawan sa damdamin ng pagsusuri. Ang buong dataset ay naglalaman ng 9998 natatanging salita, ang average na sukat ng pagsusuri ay 234 na salita na may karaniwang paglihis na 173.

    Tingnan natin ang isang simpleng paraan upang matuto:

    Print("Label:", mga target) Label: 1 print(data)

    Dito makikita mo ang unang pagsusuri mula sa dataset, na minarkahan bilang positibo (1). Ang sumusunod na code ay gumagawa baligtad na conversion ini-index sa mga salita upang mabasa natin ang mga ito. Sa loob nito, ang bawat hindi kilalang salita ay pinapalitan ng "#". Ginagawa ito gamit ang function get_word_index().

    Index = imdb.get_word_index() reverse_index = dict([(value, key) para sa (key, value) sa index.items()]) decoded = " ".join() print(decoded) # ang pelikulang ito ay napakatalino ng casting location scenery story direction everyone"s really suit the part they played and you could just imagine na nandoon si robert # ay isang kamangha-manghang aktor at ngayon ay pareho na siyang direktor # ama ay nagmula sa parehong isla ng scottish gaya ko kaya nagustuhan ko ang katotohanang mayroong isang tunay na koneksyon sa pelikulang ito ang mga nakakatawang pananalita sa buong pelikula ay mahusay ito ay napakatalino kaya binili ko ang pelikula sa sandaling ito ay inilabas para sa # at irerekomenda ito sa lahat na panoorin at ang fly fishing ay kamangha-manghang talagang umiyak sa end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also # to the two little boys"s that played the # of Norman and Paul they were just brilliant children are often naiwan sa # listahan sa tingin ko dahil ang Ang mga bituin na gumaganap sa kanilang lahat ay nasa hustong gulang ay napakalaking profile para sa buong pelikula ngunit ang mga batang ito ay kamangha-mangha at dapat purihin sa kanilang nagawa, hindi mo ba naisip na ang buong kuwento ay napakaganda dahil ito ay totoo at isang tao. buhay pagkatapos ng lahat na ibinahagi sa ating lahat

    Paghahanda ng datos

    Panahon na upang ihanda ang data. Kailangan nating i-vector ang bawat pagsusuri at punan ito ng mga zero upang ang vector ay naglalaman ng eksaktong 10,000 na numero. Nangangahulugan ito na pinupuno namin ng mga zero ang bawat pagsusuri na mas maikli sa 10,000 salita. Ginagawa ito dahil ang pinaka mahusay na pagsusuri ay halos magkapareho ang laki, at ang bawat elemento ng input data sa aming neural network ay dapat magkapareho ang laki. Kailangan mo ring i-convert ang mga variable upang mag-type lumutang.

    Def vectorize(sequence, dimension = 10000): results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequence): results = 1 return results data = vectorize(data) mga target = np. array(targets).astype("float32")

    Hatiin natin ang dataset sa mga set ng pagsasanay at pagsubok. Ang set ng pagsasanay ay bubuo ng 40,000 mga pagsusuri, ang hanay ng pagsubok ay bubuo ng 10,000.

    Test_x = data[:10000] test_y = mga target[:10000] train_x = data train_y = mga target

    Paglikha ng modelo at pagsasanay

    Ngayon ay maaari kang lumikha ng isang simpleng neural network. Magsimula tayo sa pamamagitan ng pagtukoy sa uri ng modelo na gusto nating gawin. Mayroong dalawang uri ng mga modelo na available sa Keras: sequential at functional API.

    Pagkatapos ay kailangan mong magdagdag ng input, hidden at output layer. Para maiwasan ang overfitting, gagamit kami ng exception sa pagitan nila ( "dropout"). Tandaan na dapat mong palaging gumamit ng rate ng pagbubukod sa pagitan ng 20% ​​at 50%. Gumagamit ang bawat layer ng isang function "siksik" upang ganap na ikonekta ang mga layer sa bawat isa. Sa hidden layers ang gagamitin natin "relu", dahil halos palaging humahantong ito sa mga kasiya-siyang resulta. Huwag matakot na mag-eksperimento sa iba pang mga activation function. Sa output layer, gumagamit kami ng sigmoid function na nagre-renormalize ng mga value sa range mula 0 hanggang 1. Tandaan na itinakda namin ang laki ng mga input na elemento ng dataset sa 10,000 dahil ang aming mga review ay hanggang 10,000 integer ang laki. Ang input layer ay tumatanggap ng mga elemento na may sukat na 10,000 at naglalabas ng mga elemento na may sukat na 50.

    Panghuli, hayaan ang Keras na mag-print ng maikling paglalarawan ng modelong kakagawa lang namin.

    # Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add(layers.Dropout(0.3, noise_shape=None, seed=None) ) model.add(layers.Dense(50, activation = "relu") model.add(layers.Dropout(0.2, noise_shape=None, seed=None)) model.add(layers.Dense(50, activation = "relu ")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ======= ================================================================== === ======== siksik_1 (Siksil) (Wala, 50) 500050 ______________________________________________________________ dropout_1 (Dropout) (Wala, 50) 0 _________________________________________________________________ siksik_2 (Sikip) (Wala, 50) 2550 _____________________________________________________________________ dropout_2 (Nonerop , 50) 0 _________________________________________________________________ siksik_3 (Sikip) (Wala, 50) 2550 _________________________________________________________________ siksik_4 (Sikip) (Wala, 1) 51 ============= =========== =========================== Kabuuang params: 505,201 Trainable params: 505,201 Non-trainable params : 0 _________________________________________________________________

    Ngayon kailangan naming i-compile ang aming modelo, iyon ay, mahalagang i-set up ito para sa pagsasanay. Gagamitin natin optimizer "adam". Ang isang optimizer ay isang algorithm na nagbabago ng mga timbang at bias sa panahon ng pagsasanay. Bilang mga function ng pagkawala Gumagamit kami ng binary cross-entropy (dahil nagtatrabaho kami sa binary classification), ang katumpakan bilang isang sukatan ng pagsusuri.

    Model.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["katumpakan"])

    Ngayon ay maaari na nating sanayin ang ating modelo. Gagawin natin ito sa laki ng batch na 500 at dalawang epoch lang noong nalaman ko iyon ang modelo ay nagsisimula sa muling pagsasanay, kung sanayin mo ito nang mas matagal. Tinutukoy ng laki ng batch ang bilang ng mga elemento na ibabahagi sa buong network, at ang panahon ay isang pass sa lahat ng elemento ng dataset. Karaniwan mas malaking sukat ang batch ay humahantong sa mas mabilis na pag-aaral, ngunit hindi palaging sa mabilis na pagsasama-sama. Ang isang mas maliit na laki ng batch ay nagsasanay nang mas mabagal, ngunit maaaring mag-converge nang mas mabilis. Ang pagpili ng isa o ang isa ay tiyak na nakasalalay sa uri ng problemang niresolba, at mas mainam na subukan ang bawat isa sa kanila. Kung bago ka dito, iminumungkahi kong gamitin mo muna laki ng lot 32, na isang uri ng pamantayan.

    Mga resulta = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) Magsanay sa 40000 sample, validate sa 10000 sample Epoch 1/2 40000/40000 [======== =======================] - 5s 129us/step - loss: 0.4051 - acc: 0.8212 - val_loss: 0.2635 - val_acc: 0.8945 Epoch 2/2 40000 /40000 [============================] - 4s 90us/step - loss: 0.2122 - acc: 0.9190 - val_loss: 0.2598 - val_acc: 0.8950

    Suriin natin ang pagganap ng modelo:

    Print(np.mean(results.history["val_acc"])) 0.894750000536

    Mahusay! Ang aming simpleng modelo ay nasira na ang rekord ng katumpakan sa isang artikulo noong 2011 nabanggit sa simula ng post. Huwag mag-atubiling mag-eksperimento sa mga parameter ng network at ang bilang ng mga layer.

    Ang kumpletong code ng modelo ay ibinigay sa ibaba:

    Mag-import ng numpy bilang np mula sa keras.utils import to_categorical mula sa mga hard import na modelo mula sa mga hard import layer mula sa keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate( (training_data, testing_data), axis=0) mga target = np.concatenate((training_targets, testing_targets), axis=0) def vectorize(sequence, dimension = 10000): results = np.zeros((len(sequences), dimension) ) para sa i, sequence in enumerate(sequences): results = 1 return results data = vectorize(data) targets = np.array(targets).astype("float32") test_x = data[:10000] test_y = targets[:10000 ] train_x = data train_y = target model = models.Sequential() # Input - Mga layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add( layers.Dropout(0.3, noise_shape=Wala, seed=None)) model.add(layers.Dense(50, activation = "relu")) model.add(layers.Dropout(0.2, noise_shape=None, seed=None) ) model.add(layers.Dense(50, activation = "relu")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # compiling the model model. compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["katumpakan"]) resulta = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print( "Test-Accuracy:", np.mean(results.history["val_acc"]))

    Mga resulta

    Natutunan mo kung ano ang pagsusuri ng damdamin at kung bakit isa ang Keras sa pinakasikat na mga library ng malalim na pag-aaral.

    Gumawa kami ng simpleng neural network na may anim na layer na maaaring kalkulahin ang damdamin ng mga tagasuri ng pelikula na may 89% na katumpakan. Magagamit mo na ngayon ang modelong ito upang pag-aralan ang mga binary na sentimento sa iba pang mga pinagmumulan, ngunit para magawa ito kailangan mong gawing katumbas ng 10,000 ang laki nito o baguhin ang mga parameter ng input layer.

    Ang modelong ito (na may maliliit na pagbabago) ay maaaring ilapat sa iba pang mga problema sa machine learning.

    Ang mga artipisyal na neural network (ANN) ay mga modelo ng matematika, pati na rin ang kanilang mga pagpapatupad ng software o hardware, na binuo sa prinsipyo ng organisasyon at paggana ng mga biological neural network - mga network ng mga nerve cell ng isang buhay na organismo.

    Ang mga ANN ay isang sistema ng konektado at nakikipag-ugnayan mga simpleng processor(artipisyal na mga neuron).

    Ang mga neural network ay hindi naka-program sa karaniwang kahulugan ng salita, sila ay sinanay. Ang kakayahang matuto ay isa sa mga pangunahing bentahe ng mga neural network sa mga tradisyonal na algorithm. wikipedia

    Ang mga neural network ay inspirasyon ng sarili nating utak. Ang karaniwang modelo ng neuron ay naimbento higit sa limampung taon na ang nakalilipas at binubuo ng tatlong pangunahing bahagi:

    • (mga) dentista- responsable para sa pagkolekta ng mga papasok na signal;
    • Soma- responsable para sa pangunahing pagproseso at pagbubuod ng mga signal;
    • Axon- ay responsable para sa pagpapadala ng mga signal sa iba pang mga dendrite.

    Ang gawain ng isang neuron ay maaaring ilarawan tulad nito: ang mga dendrite ay nangongolekta ng mga signal na natanggap mula sa iba pang mga neuron, pagkatapos ang mga somas ay nagsasagawa ng pagbubuo at pagkalkula ng mga signal at data, at sa wakas, batay sa resulta ng pagproseso, maaari nilang "sabihin" ang mga axon na ipadala ang signal pa. Ang paglipat ay higit na nakasalalay sa ilang mga salik, ngunit maaari nating imodelo ang gawi na ito bilang isang transfer function na kumukuha ng mga input, nagpoproseso ng mga ito, at naghahanda ng mga output kung ang mga katangian ng transfer function ay nasiyahan.

    Ang biological neuron ay isang kumplikadong sistema, modelo ng matematika na hindi pa ganap na naitayo. Maraming mga modelo ang ipinakilala, na nag-iiba sa computational complexity at pagkakatulad sa isang tunay na neuron. Ang isa sa pinakamahalaga ay ang pormal na neuron (FN). Sa kabila ng pagiging simple ng functional function, ang mga network na binuo mula sa naturang mga neuron ay maaaring bumuo ng isang arbitrary multidimensional function sa output (source: Zaentsev I.V. Neural network: basic models).

    Ang isang neuron ay binubuo ng isang weighted adder at isang nonlinear na elemento. Ang paggana ng isang neuron ay tinutukoy ng mga formula:

    Ang isang neuron ay may maraming input signal x at isang output signal LABAS. Ang mga parameter ng isang neuron na tumutukoy sa operasyon nito ay: vector ng mga timbang w, antas ng threshold θ at uri ng activation function F.

    Ang mga neural network ay nakakaakit ng pansin dahil sa mga sumusunod na kakayahan:

    • ay kayang lutasin ang mahirap na gawing pormal ang mga problema;
    • ang parallel na prinsipyo ng operasyon ay likas, na napakahalaga kapag nagpoproseso ng malalaking volume ng data;
    • kakayahan sa pagkatuto at kakayahan sa paglalahat;
    • pagpapaubaya sa mga pagkakamali;

    Ang mga pangunahing katangian ng mga neural network ay kinabibilangan ng:

      Kakayahang matuto. Ang mga neural network ay hindi naka-program, ngunit sinanay ng mga halimbawa. Sa sandaling ipinakita ang mga signal ng input (maaaring kasama ang mga kinakailangang output), inaayos ng network ang mga parameter nito upang maibigay ang kinakailangang tugon.

      Paglalahat. Ang tugon ng network pagkatapos ng pagsasanay ay maaaring medyo hindi sensitibo sa maliliit na pagbabago sa mga signal ng input. Ang likas na kakayahang "makita" ang isang pattern sa pamamagitan ng ingay at pagbaluktot ay napakahalaga para sa pagkilala ng pattern Mahalagang tandaan na ang isang artipisyal na neural network ay awtomatikong gumagawa ng mga generalization dahil sa disenyo nito, sa halip na sa pamamagitan ng paggamit ng "katalinuhan ng tao" sa. anyo ng mga espesyal na nakasulat na programa sa computer.

      Paralelismo. Ang impormasyon sa network ay pinoproseso nang magkatulad, na ginagawang posible na magsagawa ng medyo kumplikadong pagproseso ng data gamit ang isang malaking bilang ng mga simpleng aparato.

      Mataas na pagiging maaasahan. Ang network ay maaaring gumana nang tama kahit na ang ilang mga neuron ay nabigo, dahil sa ang katunayan na ang mga kalkulasyon ay isinasagawa nang lokal at magkatulad.

    Algorithm para sa paglutas ng mga problema gamit ang isang multilayer perceptron(pinagmulan: Zaentsev I.V. Neural network: mga pangunahing modelo)

    Upang bumuo ng isang multilayer perceptron, kailangan mong piliin ang mga parameter nito. Kadalasan, ang pagpili ng mga halaga ng mga timbang at mga threshold ay nangangailangan ng pagsasanay, i.e. hakbang-hakbang na pagbabago mga weighting coefficient at mga antas ng threshold.

    Pangkalahatang algorithm ng solusyon:

    1. Tukuyin kung anong kahulugan ang inilalagay sa mga bahagi ng input vector x. Ang input vector ay dapat maglaman ng isang pormal na kondisyon ng problema, i.e. lahat ng impormasyong kailangan para makakuha ng sagot.
    2. Piliin ang output vector y sa paraang naglalaman ang mga bahagi nito ng kumpletong sagot sa gawain.
    3. Piliin ang uri ng nonlinearity sa mga neuron (activation function). Sa kasong ito, ipinapayong isaalang-alang ang mga detalye ng gawain, dahil Ang isang mahusay na pagpipilian ay magbabawas ng oras ng pagsasanay.
    4. Piliin ang bilang ng mga layer at neuron sa isang layer.
    5. Itakda ang hanay ng mga pagbabago sa mga input, output, timbang at antas ng threshold, na isinasaalang-alang ang hanay ng mga halaga ng napiling activation function.
    6. Magtalaga ng mga paunang halaga sa mga timbang at antas ng threshold at karagdagang mga parameter(halimbawa, ang steepness ng activation function kung ito ay inaayos sa panahon ng pagsasanay). Ang mga paunang halaga ay hindi dapat malaki upang ang mga neuron ay hindi maging puspos (sa pahalang na bahagi ng pag-andar ng pag-activate), kung hindi, ang pag-aaral ay magiging napakabagal. Ang mga paunang halaga ay hindi dapat masyadong maliit upang ang mga output ng karamihan sa mga neuron ay hindi katumbas ng zero, kung hindi, ang pag-aaral ay bumagal din.
    7. Magsagawa ng pagsasanay, i.e. piliin ang mga parameter ng network upang malutas ang problema sa pinakamahusay na posibleng paraan. Kapag nakumpleto na ang pagsasanay, handa na ang network na lutasin ang mga problema ng uri kung saan ito sinanay.
    8. Isumite ang mga kondisyon ng problema sa input ng network sa anyo ng isang vector x. Kalkulahin ang output vector y, na magbibigay ng pormal na solusyon sa problema.

    Mga problemang dapat lutasin

    Nalutas ang mga problema gamit ang mga neural network ().

      Pag-uuri ng mga imahe. Ang gawain ay upang ipahiwatig ang pagiging miyembro ng isang input na imahe (halimbawa, isang speech signal o isang sulat-kamay na character), na kinakatawan ng isang feature vector, sa isa o higit pang na-predefine na mga klase. Kabilang sa mga kilalang aplikasyon ang pagkilala ng titik, pagkilala sa pagsasalita, pag-uuri ng signal ng electrocardiogram, at pag-uuri ng selula ng dugo.

      Pag-cluster/pagkategorya. Kapag nilulutas ang isang problema sa clustering, na kilala rin bilang unsupervised image classification, walang set ng pagsasanay na may mga label ng klase. Ang clustering algorithm ay batay sa pagkakatulad ng imahe at naglalagay ng mga katulad na larawan sa isang cluster. May mga kilalang kaso ng paggamit ng clustering upang kunin ang kaalaman, i-compress ang data, at pag-aralan ang mga katangian ng data.

      Pagtatantya ng function. Ipagpalagay na mayroong sample ng pagsasanay ((x1,y1), (x2,y2)..., (xn,yn)) (mga pares ng data ng input-output) na nabuo ng hindi kilalang function (x) na nasira ng ingay. Ang problema sa pagtatantya ay ang paghahanap ng pagtatantya para sa hindi kilalang function (x). Ang pagtatantya ng function ay kinakailangan sa paglutas ng maraming problema sa engineering at siyentipikong pagmomolde.

      Pagtataya/Pagtataya. Hayaang maibigay ang n discrete sample (y(t1), y(t2)..., y(tn)) sa magkakasunod na sandali ng oras t1, t2,..., tn. Ang gawain ay hulaan ang halaga ng y(tn+1) sa ilang hinaharap na oras tn+1. Ang hula/pagtataya ay may malaking epekto sa paggawa ng desisyon sa negosyo, agham at teknolohiya. Ang paghula sa mga presyo ng stock market at pagtataya ng panahon ay karaniwang mga aplikasyon ng mga diskarte sa paghula/pagtataya.

      Pag-optimize. Maraming problema sa matematika, istatistika, engineering, agham, medisina, at ekonomiya ang maaaring ituring na mga problema sa pag-optimize. Ang gawain ng algorithm ng pag-optimize ay maghanap ng solusyon na nakakatugon sa sistema ng mga hadlang at nagpapalaki o nagpapaliit. target na function. Ang problema sa paglalakbay ng salesman, na kabilang sa klase ng NP-complete, ay isang klasikong halimbawa ng problema sa pag-optimize.

      Nilalaman addressable memory. Sa von Neumann na modelo ng computing, ang memorya ay naa-access lamang sa pamamagitan ng isang address, na hindi nakasalalay sa mga nilalaman ng memorya. Bukod dito, kung may nagawang error sa pagkalkula ng address, maaaring matagpuan ang ganap na magkakaibang impormasyon. Kaugnay na memorya, o content-addressable memory, ay naa-access sa pamamagitan ng pagtukoy ng isang ibinigay na nilalaman. Maaaring maalala ang mga nilalaman ng memorya kahit na sa pamamagitan ng bahagyang pag-input o mga sira na nilalaman. Ang associative memory ay lubhang kanais-nais kapag lumilikha ng mga database ng impormasyon ng multimedia.

      Kontrolin. Isaalang-alang natin dinamikong sistema, na tinukoy ng set (u(t), y(t)), kung saan ang u(t) ay ang input control action, at ang y(t) ay ang output ng system sa oras na t. Sa mga control system na may modelo ng sanggunian Ang layunin ng kontrol ay kalkulahin ang input action u(t) upang ang system ay sumusunod sa nais na trajectory na idinidikta ng reference model. Ang isang halimbawa ay ang pinakamainam na kontrol ng engine.

    Mga uri ng arkitektura

    Arkitektura ng neural network- paraan ng organisasyon at komunikasyon indibidwal na elemento neural network (neuron). Ang mga pagkakaiba sa arkitektura sa pagitan ng mga neuron mismo ay higit sa lahat ay nakasalalay sa paggamit ng iba't ibang activation (excitatory) function. Batay sa arkitektura ng mga koneksyon, ang mga neural network ay maaaring nahahati sa dalawang klase: feedforward network at paulit-ulit na network.

    Ang pag-uuri ng mga artipisyal na neural network ayon sa kanilang arkitektura ay ipinapakita sa figure sa ibaba.

    Katulad na pag-uuri, ngunit bahagyang pinalawak

    Network ng pamamahagi ng signal ng forward (pasulong na transmission network)- neural network na walang feedback (mga loop). Sa naturang network, ang pagpoproseso ng impormasyon ay unidirectional: ang signal ay ipinapadala mula sa layer hanggang layer sa direksyon mula sa input layer ng neural network hanggang sa output layer. Ang output signal (tugon sa network) ay ginagarantiyahan sa pamamagitan ng isang paunang natukoy na bilang ng mga hakbang (katumbas ng bilang ng mga layer). Ang mga feedforward network ay madaling ipatupad at mahusay na pinag-aralan. Upang malutas ang mga kumplikadong problema nangangailangan sila ng isang malaking bilang ng mga neuron.

    Talahanayan ng paghahambing multilayer perceptor At Mga network ng RBF

    Multilayer perceptron Mga network ng RBF
    Ang hangganan ng desisyon ay ang intersection ng hyperplanes Ang hangganan ng desisyon ay ang intersection ng mga hypersphere, na tumutukoy sa isang hangganan ng isang mas kumplikadong hugis
    Kumplikadong topology ng mga koneksyon sa pagitan ng mga neuron at mga layer Simpleng 2-layer na neural network
    Kumplikado at mabagal na nagtatagpo na algorithm sa pag-aaral Mabilis na pamamaraan ng pagsasanay: paglutas ng isang sistema ng mga equation + clustering
    Paggawa sa isang maliit na sample ng pagsasanay Ang isang malaking halaga ng data ng pagsasanay ay kinakailangan para sa isang katanggap-tanggap na resulta
    Universality ng aplikasyon: clustering, approximation, control, atbp. Karaniwang gumagana lang ang approximation at clustering

    Ang halaga ng derivative ay madaling ipinahayag sa pamamagitan ng mismong function. Ang mabilis na pagkalkula ng derivative ay nagpapabilis ng pag-aaral.

    Gaussian curve

    Ginagamit ito sa mga kaso kung saan ang tugon ng neuron ay dapat na maximum para sa ilang partikular na halaga ng NET.

    Mga module ng Python para sa mga neural network

    Simpleng halimbawa

    Bilang halimbawa, magbibigay ako ng isang simpleng neural network (simple perceptron), na pagkatapos ng pagsasanay ay makikilala ang mga lumilipad na bagay, hindi lahat, ngunit lamang seagull:), lahat ng iba pang mga input na imahe ay makikilala bilang UFO.

    # encoding=utf8 import random class NN: def __init__(self, threshold, size): """ Itakda ang mga paunang parameter. """ self.threshold = threshold self.size = size self.init_weight() def init_weight(self) : """ Simulan ang weights matrix gamit ang random na data. """ self.weights = [ para sa j sa xrange(self.size)] def check(self, sample): """ Basahin ang output signal para sa sample na larawan. Kung ang vsum > self ay maaari nating ipagpalagay na ang sample ay naglalaman ng isang imahe ng seagull """ vsum = 0 para sa i sa xrange(self.size): para sa j sa xrange(self.size): vsum += self. .weights[i][j] * sample[i][j] if vsum > self.threshold: return True else: return False def teach(self, sample): """ Pagsasanay ng neural network. """ para sa i sa xrange(self.size): para sa j sa xrange(self.size): self.weights[i][j] += sample[i][j] nn = NN(20, 6) # Sanayin ang neural network. tsample1 = [ , , , , , , ] nn.teach(tsample1) tsample2 = [ , , , , , , ] nn.teach(tsample2) tsample3 = [ , , , , , , ] nn.teach(tsample3) tsample4 = [ , , , , , , ] nn.teach(tsample4) # Suriin natin kung ano ang magagawa ng neural network. # Ipadala natin ang imahe ng isang seagull, na halos kapareho ng alam ng perceptron. wsample1 = [ , , , , , , ] print mo ang "seagull" kung nn.check(wsample1) else u"UFO" # Magpadala ng hindi kilalang larawan. wsample2 = [ , , , , , , ] print u"seagull" kung nn.check(wsample2) else u"UFO" # Ipapadala namin ang imahe ng isang seagull, na halos kapareho ng alam ng perceptron. wsample3 = [ , , , , , , ] i-print mo ang "seagull" kung nn.check(wsample3) kung hindi u"UFO"



    MGA KAUGNAY NA ARTIKULO