Kuidas luua oma esimene närvivõrk, et ennustada Kerasega majade hindu

Üksikasjalik täielik algaja juhend oma esimese närvivõrgu ehitamiseks paarirealisel koodil nagu Deep Learning pro!

Oma esimese närvivõrgu kirjutamiseks saab kasutada vaid paari koodirida! Selles postituses uurime, kuidas kasutada paketi nimega Keras oma esimese närvivõrgu ehitamiseks, et ennustada, kas majade hinnad on mediaanväärtusest kõrgemad või alla selle. Eelkõige läbime täieliku süvaõppe projekti, alates:

  • Andmete uurimine ja töötlemine
  • Meie närvivõrgu ülesehitamine ja koolitamine
  • Kaotuse ja täpsuse visualiseerimine
  • Normaliseerimise lisamine meie närvivõrku

Ainult 20–30 minutiga olete kodeerinud oma närvivõrgu täpselt nii, nagu sügava õppimisega tegelejatel oleks!

Eeltingimused:

Selles postituses eeldatakse, et olete Jupyteri märkmiku seadistanud keskkonda, kuhu on installitud paketid keras, tensorflow, pandas, scikit-learning ja matplotlib. Kui te pole seda veel teinud, järgige allolevas õpetuses sisalduvaid juhiseid:

  • Alustamine Pythoni süvaõppe ja andmeteadusega

See on intuitiivse süvaõppe kodeeriv osa, 1. osa. Seetõttu eeldame, et teil on närvivõrkude ja nende toimimise kohta intuitiivne arusaam, sealhulgas mõned nigelad detailid, näiteks üleliigne paigaldamine ja käsitletavad strateegiad neid. Kui vajate värskenduskuuri, lugege palun neid intuitiivseid sissejuhatusi:

  • Intuitiivne sügav õppimine, 1.a osa: Sissejuhatus närvivõrkudesse
  • Intuitiivne süvaõpe 1.b osa: sissejuhatus närvivõrkudesse

Vajalikud ressursid:

Andmekogum, mida me täna kasutame, on kohandatud Zillow'i koduväärtuse ennustamise kaggle'i võistlusandmetest. Oleme vähendanud sisendfunktsioonide arvu ja muutnud ülesande ennustamaks, kas maja hind on mediaanväärtusest kõrgem või alla selle. Külastage allolevat linki, et alla laadida muudetud andmestik ja asetada see sülearvutiga samasse kataloogi. Allalaadimisikoon peaks olema paremas ülanurgas.

Laadige alla andmestik

Valikuliselt võite alla laadida ka märkustega märkmiku Jupyteri sülearvuti, millel on kogu selle postituse hõlmatud kood: Jupyteri märkmik.

Pange tähele, et selle sülearvuti Githubist allalaadimiseks peate minema avalehele ja kõigi failide allalaadimiseks alla laadima ZIP:

Ja nüüd alustame!

Andmete uurimine ja töötlemine

Enne mis tahes ML-algoritmi kodeerimist peame kõigepealt panema oma andmed vormingusse, mida see algoritm soovib. Eelkõige peame tegema järgmist:

  • Lugege CSV-failis (komaga eraldatud väärtused) ja teisendage need massiivideks. Massiivid on andmevorming, mida meie algoritm saab töödelda.
  • Jagage meie andmestik sisendfunktsioonidesse (mida me kutsume x-ks) ja sildi (mida me kutsume y-ks).
  • Skaalake andmeid (seda nimetatakse normaliseerimiseks) nii, et sisendfunktsioonidel on sarnane suurusjärk.
  • Jagage meie andmestik koolituskomplekti, valideerimise komplekti ja testikomplekti. Kui vajate värskendust selle kohta, miks me neid kolme andmekogumit vajame, lugege palun Intuitiivne süvaõpe 1b osa.

Alustame siis! Alates Pythoni süvaõppe alustamise ja andmeteaduste õpetusest oleksite pidanud pakendipangad oma keskkonda alla laadima. Peame oma sülearvutile ütlema, et kasutame seda paketti selle importimisel. Tippige järgmine kood ja vajutage klaviatuuril Alt-Enter:

importida pandasid pd-na

See tähendab lihtsalt, et kui ma tahan pakendis „pandas” viidata koodile, siis viitan sellele nimega pd. Seejärel lugesime CSV-faili, käivitades selle koodirea:

df = pd.read_csv ('housepricedata.csv')

See koodirida tähendab, et loeme csv-faili housepricedata.csv (mis peaks asuma teie sülearvutiga samas kataloogis) ja salvestame selle muutujasse „df”. Kui tahame teada saada, mis on df-is, tippige lihtsalt halli kasti df ja klõpsake nuppu Alt-Enter:

df

Teie sülearvuti peaks välja nägema umbes selline:

Siin saate andmeid pisut uurida. Esimeses kümnes veerus on meie sisendfunktsioonid:

  • Krundi pindala (ruutmeetrites)
  • Üldine kvaliteet (skaala 1 kuni 10)
  • Üldine seisund (skaala 1 kuni 10)
  • Keldri kogupindala (ruutmeetrites)
  • Vannitubade arv
  • Poolvannitubade arv
  • Magamistubade arv maapinnast
  • Tubade koguarv maapinnast
  • Kaminate arv
  • Garaaži pindala (ruutmeetrites)

Meie viimases veerus on funktsioon, mida tahaksime ennustada:

  • Kas maja hind on mediaanist kõrgem või mitte? (1 jah ja 0 ei)

Nüüd, kui oleme näinud, kuidas meie andmed välja näevad, tahame need muuta massiivideks, et meie masin saaks neid töödelda:

andmestik = df.väärtused

Meie andmeraami massiivi teisendamiseks salvestame lihtsalt df väärtused (avades df.väärtused) muutujasse „andmekogum”. Selle muutuja 'andmestik' siseruumide kuvamiseks tippige lihtsalt oma andmearvuti halli kasti 'andmestik' ja käivitage lahter (Alt-Enter):

andmestik

Nagu näete, salvestatakse see kõik nüüd massiivi:

Meie andmeraami teisendamine massiiviks

Jagasime oma andmestiku nüüd sisendfunktsioonideks (X) ja funktsiooniks, mida soovime ennustada (Y). Selle jagamise jaoks määrame massiivi esimesed kümme veergu muutujale nimega X ja massiivi viimane veerg muutujale nimega Y. Esimese määramise kood on järgmine:

X = andmestik [:, 0:10]

See võib tunduda pisut imelik, kuid lubage mul selgitada, mis on nurksulgude sees. Kõik enne koma viitavad massiivi ridadele ja kõik pärast koma viitavad massiivide veergudele.

Kuna me ridu ei jaota, paneme koma ette ':'. See tähendab, et võetakse kõik andmekogumid read ja pannakse see X-i.

Tahame välja tõmmata esimesed 10 veergu ja nii tuleb koma järel olev arv 0:10 võtta veerud 0–9 ja panna see X-i (me ei sisalda 10. veergu). Meie veerud algavad indeksist 0, seega on esimesed 10 veergu tõesti veerud 0–9.

Seejärel määrame massiivi viimase veeru Y-le:

Y = andmestik [:, 10]

Ok, nüüd jagasime oma andmestiku sisendfunktsioonideks (X) ja siltideks, mida me ennustada tahame (Y).

Meie töötlemise järgmine samm on veenduda, et sisendfunktsioonide ulatus on sarnane. Praegu on selliseid funktsioone nagu partii pindala tuhandeid, üldise kvaliteedi hinne on vahemikus 1 kuni 10 ja kaminate arv on tavaliselt 0, 1 või 2.

See raskendab närvivõrgu initsialiseerimist, mis põhjustab mõningaid praktilisi probleeme. Üks viis andmete mõõtmete suurendamiseks on kasutada olemasolevat paketti scikit-learning (mille oleme installinud postitusse Alustamine).

Esmalt peame importima koodi, mida soovime kasutada:

sklearn impordi eeltöötlus

See tähendab, et tahan kasutada koodi sklearni paketi eeltöötluses. Seejärel kasutame funktsiooni min-max skaleerija, mis skaleerib andmestikku nii, et kõik sisendfunktsioonid jäävad vahemikku 0–1 (kaasa arvatud):

min_max_scaler = eeltöötlus.MinMaxScaler ()
X_scale = min_max_scaler.fit_transform (X)

Pange tähele, et valisime 0 ja 1 tahtlikult oma närvivõrgu treenimiseks. Me ei vaata selle taga olevat teooriat läbi. Nüüd on meie skaleeritud andmestik salvestatud massiivi „X_scale”. Kui soovite näha, kuidas X-mõõtkava välja näeb, käivitage lihtsalt lahter:

X_skaala

Teie Jupyteri märkmik peaks nüüd natukene selline välja nägema:

Nüüd oleme andmete töötlemise viimase sammu juures, st meie andmestiku jagamine koolituskomplektiks, valideerimiskomplektiks ja testikomplektiks.

Kasutame koodi scikit-learning nimega 'train_test_split', mis nagu nimigi ütleb, jagab meie andmestiku treeningkomplektiks ja testkomplektiks. Esmalt impordime vajaliku koodi:

saidist sklearn.model_selection imporditakse rong_test_split

Seejärel jagage oma andmestik nii:

X_õpe, X_val_and_test, Y_train, Y_val_and_test = train_test_split (X_scale, Y, test_size = 0,3)

See ütleb scikit-oppile, et teie val_and_testi suurus on 30% kogu andmestikust. Kood salvestab jagatud andmed neljaks esimeseks muutujaks võrdusmärgist vasakul, nagu muutujate nimed viitavad.

Kahjuks aitab see funktsioon ainult jagada meie andmekogumid kaheks. Kuna me soovime eraldi valideerimiskomplekti ja testikomplekti, saame sama funktsiooni kasutada uuesti jagamiseks val_and_test:

X_val, X_test, Y_val, Y_test = train_test_split (X_val_and_test, Y_val_and_test, test_size = 0,5)

Ülaltoodud kood jagab val_and_test suuruse võrdselt valideerimis- ja testikomplektiga.

Kokkuvõtlikult võib öelda, et meil on nüüd andmestike jaoks kokku kuus muutujat, mida kasutame:

  • X_train (10 sisestusfunktsiooni, 70% kogu andmestikust)
  • X_val (10 sisestusfunktsiooni, 15% kogu andmestikust)
  • X_test (10 sisestusfunktsiooni, 15% kogu andmestikust)
  • Y_train (1 silt, 70% kogu andmestikust)
  • Y_val (1 silt, 15% kogu andmestikust)
  • Y_test (1 silt, 15% kogu andmestikust)

Kui soovite näha, kuidas massiivide kujundid igaühe jaoks on (st. Millised mõõtmed need on), siis lihtsalt käivitage

print (X_train.shape, X_val.shape, X_test.shape, Y_train.shape, Y_val.shape, Y_test.shape)

Nii peaks teie Jupyteri märkmik välja nägema:

Nagu näete, on treeningkomplektis 1022 andmepunkti, samas kui valideerimis- ja testikomplektis on 219 andmepunkti. X muutujatel on 10 sisestusfunktsiooni, samas kui Y muutujatel on ainult üks omadus ennustamiseks.

Ja nüüd on meie andmed lõpuks valmis! Phew!

Kokkuvõte: andmete töötlemisel oleme:

  • Lugege CSV-failis (komaga eraldatud väärtused) ja teisendage need massiivideks.
  • Jagage meie andmestik sisendfunktsioonide ja sildi vahel.
  • Skaalake andmeid nii, et sisendfunktsioonid on sarnase suurusjärguga.
  • Jagage meie andmestik koolituskomplekti, valideerimise komplekti ja testikomplekti.

Meie esimese närvivõrgu ehitamine ja koolitamine

Intuitiivse süvaõppe 1. osas a ütlesime, et masinõpe koosneb kahest etapist. Esimene samm on malli (arhitektuuri) määramine ja teine ​​samm - leida andmetest parimad numbrid selle malli täitmiseks. Meie kood järgib ka neid kahte sammu.

Esimene samm: arhitektuuri seadistamine

Esimene asi, mida peame tegema, on arhitektuuri seadistamine. Mõelgem kõigepealt, millist närvivõrgu arhitektuuri me tahame. Oletame, et me tahame seda närvivõrku:

Neuraalvõrgu arhitektuur, mida me kasutame oma probleemi jaoks

Sõnades tahame, et meil oleks järgmised kihid:

  • Varjatud kiht 1: 32 neuroni, ReLU aktiveerimine
  • Varjatud kiht 2: 32 neuroni, ReLU aktiveerimine
  • Väljundkiht: 1 neuron, Sigmoidi aktiveerimine

Nüüd peame seda arhitektuuri kirjeldama Kerasele. Kasutame järjestikmudelit, mis tähendab, et peame lihtsalt kirjeldama ülaltoodud kihte järjestikku.

Esiteks, impordime vajaliku koodi Kerast:

alates keras.models import Sequential
saidilt keras.layers impordib Dense

Seejärel täpsustame, et meie Kerase järjestikuses mudelis:

mudel = järjestikune ([
    Tihe (32, aktiveerimine = 'relu', input_shape = (10,)),
    Tihe (32, aktiveerimine = 'relu'),
    Tihe (1, aktiveerimine = 'sigmoid'),
])

Ja just nagu ülaltoodud koodilõik määratles meie arhitektuuri! Ülaltoodud koodi saab tõlgendada nii:

mudel = järjestikune ([...])

See tähendab, et salvestame mudeli muutujasse „mudel” ja kirjeldame seda järjestikku (kiht kihi kaupa) nurksulgude vahel.

Tihe (32, aktiveerimine = 'relu', input_shape = (10,)),

Meie esimene kiht on tihe, 32 neuroniga kiht, ReLU aktiveerimine ja sisendi kuju on 10, kuna meil on 10 sisendfunktsiooni. Pange tähele, et „tihe” viitab täielikult ühendatud kihile, mida me ka kasutame.

Tihe (32, aktiveerimine = 'relu'),

Meie teine ​​kiht on ka tihe kiht 32 neuroniga, ReLU aktiveerimine. Pange tähele, et me ei pea sisendi kuju kirjeldama, kuna Keras võib järeldada meie esimese kihi väljundist.

Tihe (1, aktiveerimine = 'sigmoid'),

Meie kolmas kiht on tihe kiht, millel on 1 neuron, sigmoidne aktiveerimine.

Ja just nagu me oleme oma mudeli arhitektuuri (malli) koodi kirjutanud!

Teine samm: parimate numbrite täitmine

Nüüd, kui oleme oma arhitektuuri täpsustanud, peame leidma selle jaoks parimad numbrid. Enne koolituse alustamist peame mudeli seadistama

  • Teades, millist algoritmi soovite optimeerimiseks kasutada
  • Teatakse, millist kadude funktsiooni kasutada
  • Rääkides sellest, milliseid muid mõõdikuid soovite lisaks kadude funktsioonile jälgida

Mudeli nende sätetega konfigureerimine eeldab, et kutsume funktsiooni model.compile, näiteks järgmiselt:

model.compile (optimeerija = 'sgd',
              kaotus = 'binaarne_krossentropia',
              mõõdikud = ['täpsus'])

Pärast Model.compile'i panime sulgudesse järgmised sätted:

optimeerija = 'sgd'

'Sgd' viitab stohhastilisele gradiendi laskumisele (siin tähendab see minikompartii gradiendi laskumist), mida oleme näinud intuitiivse süvaõppe osas 1b.

kaotus = 'binaarne_krossentroopia'

Kadude funktsiooni väljunditele, mille väärtus on 1 või 0, nimetatakse binaarseks rist-entroopiaks.

mõõdikud = ['täpsus']

Lõpuks tahame jälgida täpsust lisaks kadude funktsioonile. Nüüd, kui oleme selle kambri käivitanud, oleme valmis treenima!

Andmete väljaõpe on üsna lihtne ja nõuab, et kirjutaksime ühe koodirea:

hist = model.fit (X_train, Y_train,
          partii suurus = 32, ajajärgud = 100,
          valideerimise andmed = (X_val, Y_val))

Funktsiooni nimetatakse sobivaks, kuna me kohandame parameetrid andmetele. Peame täpsustama, millistel andmetel treenime, milleks on X_train ja Y_train. Seejärel täpsustame oma mini-partii suuruse ja kui kaua me tahame seda treenida (ajajärgud). Lõpuks täpsustame, millised on meie valideerimisandmed, nii et mudel annab meile teada, kuidas meil igas punktis valideerimisandmetega läheb. See funktsioon väljastab ajaloo, mille salvestame muutuja hist all. Kasutame seda muutujat veidi hiljem, kui jõuame visualiseerimiseni.

Nüüd jookse kärge ja vaata, kuidas see treenib! Teie Jupyteri märkmik peaks välja nägema järgmine:

Nüüd näete, et modell treenib! Numbreid vaadates peaksite nägema kadude vähenemist ja täpsuse suurenemist aja jooksul. Sel hetkel saate katsetada hüperparameetreid ja närvivõrgu arhitektuuri. Käitage lahtrid uuesti, et näha, kuidas teie treening on muutunud, kui olete hüperparameetreid kohandanud.

Kui olete oma lõpliku mudeliga rahul, saame seda testikomplekti alusel hinnata. Testkomplekti täpsuse leidmiseks käivitame selle koodilõigu:

model.evaluate (X_test, Y_test) [1]

Põhjus, miks meil on pärast funktsiooni model.evaluate indeks 1, on see, et funktsioon tagastab esimese elemendina kaotuse ja teise elemendina täpsuse. Ainult täpsuse saamiseks väljuge lihtsalt teisest elemendist (mida indekseeritakse 1-ga, kuna esimene element alustab indekseerimist 0-st).

Andmekogumi jaotuse juhuslikkuse ja raskuste lähtestamise tõttu erinevad numbrid ja graafikud iga kord, kui me oma sülearvutit käitame. Sellegipoolest peaksite saama täpsuse kõikjal vahemikus 80% kuni 95%, kui olete järginud ülalpool määratletud arhitektuuri!

Hindamine testkomplekti alusel

Ja seal see on, olete oma esimese närvivõrgu kodeerinud ja selle välja koolitanud! Palju õnne!

Kokkuvõte: meie esimese närvivõrgu kodeerimine nõudis vaid mõnda koodirida:

  • Täpsustame arhitektuuri Kerase järjestusmudeliga.
  • Täpsustame mõned oma seaded (optimeerija, kadude funktsioon, jälgitavad mõõdikud) saidil model.compile
  • Treenime oma mudeli (leiame oma arhitektuurile parimad parameetrid) koolitusandmetega saidil model.fit
  • Hindame oma mudelit testkomplekti abil mudeliga.evaluate

Kaotuse ja täpsuse visualiseerimine

Intuitiivse süvaõppe 1.b osas rääkisime ülekomplekteerimisest ja mõnest seadistamise tehnikast. Kuidas me teame, kas meie mudel sobib praegu liiga hästi?

Mida võiksime teha, on joonistada treeningukaotus ja väärtuskaotus möödunud ajastute arvu järgi. Mõne toreda graafiku kuvamiseks kasutame paketti matplotlib. Nagu tavaliselt, peame importima koodi, mida soovime kasutada:

import matplotlib.pyplot plt

Seejärel soovime visualiseerida treeningukaotuse ja valideerimise kaotuse. Selleks käivitage see koodilõik:

plt.plot (ajaloo ajalugu ['kaotus'])
plt.plot (ajaloo ajalugu ['val_loss'])
plt.title ('mudeli kaotus')
plt.ylabel ('kaotus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'üleval paremal')
plt.show ()

Selgitame ülaltoodud koodilõigu iga rida. Kaks esimest rida ütlevad, et tahame joonistada kahjumit ja val_lossit. Kolmas rida täpsustab selle graafiku pealkirja “Model Loss”. Neljas ja viies rida räägivad meile, mida y ja x telg vastavalt tähistama peaks. Kuues rida sisaldab meie graafi kohta legendi ja legend asub paremas ülanurgas. Ja seitsmes rida käsib Jupyteri märkmikul graafikut kuvada.

Teie Jupyteri märkmik peaks välja nägema umbes selline:

Mudeli kaotamise graafik, mida peaksite oma Jupyteri märkmikus nägema

Saame sama teha ka treeningutäpsuse ja valideerimise täpsuse joonistamiseks alloleva koodiga:

plt.plot (ajaloo ajalugu ['acc'])
plt.plot (ajaloo ajalugu ['val_acc'])
plt.title ('mudeli täpsus')
plt.ylabel ('täpsus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'parem alumine')
plt.show ()

Peaksite saama graafiku, mis näeb välja natuke selline:

Treeningu ja valideerimise komplekti mudeli täpsuse graafik

Kuna meie treeningkomplekti mudeli täiustused näevad mõneti kokku valideerimiskomplekti täiustustega, siis ei tundu, et ülekomplekteerimine oleks meie mudelis tohutu probleem.

Kokkuvõte: kasutame matplotlibi, et visualiseerida aja jooksul väljaõppe ja valideerimise kaotus / täpsus, et näha, kas meie mudelis on liiga palju seadmeid.

Normaliseerimise lisamine meie närvivõrku

Meie närvivõrgule seadustamise tutvustamiseks formuleeruge selline närvivõrk, mis sobib meie treeningkomplektiga halvasti. Me kutsume seda mudelit 2.

model_2 = järjestikune ([
    Tihe (1000, aktiveerimine = 'relu', input_shape = (10,)),
    Tihe (1000, aktiveerimine = 'relu'),
    Tihe (1000, aktiveerimine = 'relu'),
    Tihe (1000, aktiveerimine = 'relu'),
    Tihe (1, aktiveerimine = 'sigmoid'),
])
model_2.compile (optimeerija = 'adam',
              kaotus = 'binaarne_krossentropia',
              mõõdikud = ['täpsus'])
hist_2 = model_2.fit (X_train, Y_train,
          partii suurus = 32, ajajärgud = 100,
          valideerimise andmed = (X_val, Y_val))

Oleme siin teinud palju suurema mudeli ja me oleme kasutanud Adamsi optimeerijat. Adam on üks levinumaid optimeerijaid, mida me kasutame, mis lisab stochastilisele gradiendi laskumisele mõningaid nippe, nii et see saavutab madalama kaotuse funktsiooni kiiremini. Kui käivitame selle koodi ja joonistame hist_2 kahjumigraafikud, kasutades allolevat koodi (pange tähele, et kood on sama, välja arvatud see, et me kasutame „hist” asemel „hist_2”):

plt.plot (hist_2.history ['kaotus'])
plt.plot (hist_2.history ['val_loss'])
plt.title ('mudeli kaotus')
plt.ylabel ('kaotus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'üleval paremal')
plt.show ()

Saame sellise krundi:

Liigse mudeli kaotuskõverad

See on selge märk liigsest sobitumisest. Treeningukaotus väheneb, kuid valideerimiskadu on treeningukaotusest palju suurem ja suureneb (möödunud ajastust 20). Kui joonestame täpsuse, kasutades järgmist koodi:

plt.plot (hist_2.history ['acc'])
plt.plot (hist_2.history ['val_acc'])
plt.title ('mudeli täpsus')
plt.ylabel ('täpsus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'parem alumine')
plt.show ()

Näeme ka selgemat lahknevust rongi ja valideerimise täpsuse vahel:

Meie ületäitmismudeli väljaõppe ja valideerimise täpsus

Proovime nüüd mõnda meie strateegiat liigse sobitumise vähendamiseks (peale meie arhitektuuri muutmise oma esimese mudeli juurde). Pidage alates intuitiivse süvaõppe 1.b osast meeles, et me tutvustasime kolme strateegiat liigse sobitamise vähendamiseks.

Nendest kolmest hõlmame siin L2 seadustamist ja väljalangemist. Põhjus, miks me siia varajast peatumist ei lisa, on see, et pärast kahe esimese strateegia kasutamist pole valideerimise kaotus ülaltoodud U-kuju ja seega ei ole varajane peatamine sama tõhus.

Kõigepealt impordime koodi, mida vajame L2 seadustamiseks ja väljalangemiseks:

alates keras.layers impordib väljalangevuse
alates keras impordi regulaatorid

Seejärel täpsustame oma kolmanda mudeli järgmiselt:

model_3 = Järjestikune ([
    Tihe (1000, aktiveerimine = 'relu', kernel_regularizer = regulators.l2 (0,01), input_shape = (10,)),
    Väljalangevus (0,3),
    Tihe (1000, aktiveerimine = 'relu', kernel_regularizer = regulators.l2 (0,01)),
    Väljalangevus (0,3),
    Tihe (1000, aktiveerimine = 'relu', kernel_regularizer = regulators.l2 (0,01)),
    Väljalangevus (0,3),
    Tihe (1000, aktiveerimine = 'relu', kernel_regularizer = regulators.l2 (0,01)),
    Väljalangevus (0,3),
    Tihe (1, aktiveerimine = 'sigmoid', kernel_regularizer = regulators.l2 (0,01)),
])

Kas saate märgata erinevusi mudeli 3 ja mudeli 2 vahel? On kaks peamist erinevust:

Erinevus 1: L2-te regulatsiooni lisamiseks pange tähele, et oleme igasse tihedasse kihti lisanud natuke lisakoodi:

kernel_regularizer = regulaatorid.l2 (0,01)

See käsib Kerasel lisada nende parameetrite ruutväärtused meie üldisesse kadumisfunktsiooni ja kaaluda need kadumisfunktsioonis 0,01-ga.

Erinevus 2: väljalangevuse lisamiseks lisasime uue kihi, nagu see:

Väljalangevus (0,3),

See tähendab, et eelmise kihi neuronitel on treenimise ajal väljalangemise tõenäosus 0,3. Kompileerime selle ja käivitage see samade parameetritega nagu meie mudel 2 (ülimalt sobiv):

model_3.compile (optimeerija = 'adam',
              kaotus = 'binaarne_krossentropia',
              mõõdikud = ['täpsus'])
hist_3 = model_3.fit (X_train, Y_train,
          partii suurus = 32, ajajärgud = 100,
          valideerimise andmed = (X_val, Y_val))

Ja nüüd joonistagem kadude ja täpsuse graafikud. Võite märgata, et kaotus on alguses palju suurem ja seda seetõttu, et oleme muutnud oma kahjumifunktsiooni. Joonistamiseks selliselt, et aken oleks kadude jaoks suumitud vahemikku 0–1,2, lisame joonistamisel täiendava koodirea (plt.ylim):

plt.plot (hist_3.history ['kaotus'])
plt.plot (hist_3.history ['val_loss'])
plt.title ('mudeli kaotus')
plt.ylabel ('kaotus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'üleval paremal')
plt.ylim (ülemine = 1,2, alumine = 0)
plt.show ()

Saame kahjumigraafiku, mis näeb välja järgmine:

Näete, et valideerimise kaotus langeb palju paremini kokku meie treeningukaotusega. Joonestame täpsuse sarnase koodilõigu abil:

plt.plot (hist_3.history ['acc'])
plt.plot (hist_3.history ['val_acc'])
plt.title ('mudeli täpsus')
plt.ylabel ('täpsus')
plt.xlabel ('ajastu')
plt.legend (['Rong', 'Val'], loc = 'parem alumine')
plt.show ()

Ja saame sellise krundi:

Võrreldes mudeli 2 mudeliga oleme märkimisväärselt vähendanud ületalitlust! Ja nii rakendame oma seadistamise tehnikaid, et vähendada treeningkomplekti ületalitlust.

Kokkuvõte: ületäitumisega tegelemiseks saame oma mudelisse kodeerida järgmised strateegiad, millest igaühes on umbes üks koodirea:

  • L2 seadustamine
  • Välja kukkuma

Kui kujutame ette koolituse / valideerimise kaotust ja täpsust, näeme, et need täiendused on aidanud toime tulla ületalitlusega!

Konsolideeritud kokkuvõte:

Selles postituses oleme Pythoni koodi kirjutanud:

  • Andmete uurimine ja töötlemine
  • Ehitage ja treenige meie närvivõrku
  • Visualiseeri kaotus ja täpsus
  • Lisage regulatsioon meie närvivõrku

Oleme palju läbi elanud, kuid me pole liiga palju koodiridu kirjutanud! Meie närvivõrgu ehitamine ja koolitamine on võtnud ainult umbes 4 kuni 5 rida koodi ja erinevate mudelarhitektuuridega katsetamine on lihtsalt eri kihtide vahetamise või erinevate hüperparameetrite muutmise lihtne küsimus. Keras on tõepoolest teinud meie närvivõrkude ehitamise palju lihtsamaks ja jätkame selle kasutamist arvutipõhise visiooni ja loomuliku keele töötlemise keerukamate rakenduste jaoks.

Mis saab edasi: järgmises kodeerimiskaaslase 2. osas uurime, kuidas pildituvastuse tegemiseks kodeerida meie enda konvolutsioonneuraalvõrgud (CNN-id)!

Esmalt lugege kindlasti CNN-ide intuitiivset mõistmist siit: Intuitiivne sügav õppimine, 2. osa: CNN-id arvutinägemise jaoks

Autori kohta:

Tere, ma olen Joosep! Lõpetasin hiljuti Stanfordi ülikooli, kus töötasin koos Andrew Ngiga Stanfordi masinõppe rühmas. Soovin muuta sügava õppimise kontseptsioonid kõigile võimalikult arusaadavaks ja võimalikult hõlpsasti mõistetavaks, mis on ajendanud minu väljaannet: Intuitiivne sügav õppimine.