Denne artikkelen ble publisert som en del av Data Science Blogathon
Oversikt
- Deep learning er en undergruppe av maskinlæring som omhandler forskjellige nevrale nettverk med lag.
- Det er forskjellige dype nevrale nettverk som fungerer best på mange forskjellige applikasjoner i den virkelige verden, og forskning og utvikling pågår fortsatt.
- Den omfattende veiledningen vil introdusere ulike metoder vi bør ta vare på og bruke mens vi jobber og bygger nevrale nettverksmodeller for å få bedre resultater.
Introduksjon
Maskinlæringsalgoritmer er ikke i stand til å trene på enorme datasett, bildedatasett, tekstdata. Nevrale nettverk som er hjertet av dyp læring, gir en nøyaktighet i mange av disse brukstilfellene. Det som virkelig fascinerer med et nevralt nettverk er det arbeid og evne til å lære komplekse ting.
Men mesteparten av tiden gir nettverksmodellen vi bygger kanskje ikke tilfredsstillende resultater eller tar oss kanskje ikke til topplasseringer på ledertavlen i datavitenskapskonkurranser. Som et resultat ser vi alltid etter en måte å forbedre ytelsen til nevrale nettverk.
I denne artikkelen skal vi forstå problemet med nevrale nettverk i forskjellige situasjoner og en løsning som fungerer best for å få bedre resultater. Jeg vil be deg om å prøve å implementere alle metodene når vi skal studere.
Innholdsfortegnelse
- Problem med forsvinnende gradientnedstigning
- Definere nevral nettverksarkitektur
- Hvorfor er vektinitialisering viktig?
- Kontroller overtilpasning av nevrale nettverk
- Reduser kompleksiteten
- Dropout-lag
- Tidlig stopp
- normalisering
- Overvåk gradientene dine (gradientklipping)
- Hyperparameterinnstilling av nevralt nettverk
Forsvinnende gradientproblem for ytelsesoptimalisering av nevrale nettverk
Gradient Descent er en iterativ optimaliseringsalgoritme for å finne det lokale minimum for en inngangsfunksjon. Det er også kjent som den bratteste nedstigningen. Hvorfor er det kjent som gradient? En gradient er ikke annet enn en derivativ. det er et derivat av tap med hensyn til vekter. Gradientnedstigning utfører to trinn iterativt. Den første er å beregne gradientens gjennomsnittlige helning og den andre er å flytte et skritt motsatt i retning av skråningen.
Nevrale nettverk er ikke en ny teknologi; de ble også brukt på 1980-tallet, men i den perioden var det ikke mulig å utvikle et dypt nevralt nettverk fordi aktiveringsfunksjonen vi brukte er sigmoideumfunksjonen. Det som er et problem med Sigmoid-funksjonen er at den gir et problem med forsvinnende gradientnedstigning. Sigmoid-funksjonen er en funksjon som normaliserer enhver verdi i området 0 til 1. Og når du finner dens deriverte, er området alltid mellom 0 og 0.25, som kan observeres av grafen nedenfor. vi finner dens deriverte slik at vi kan bruke gradientnedstigning for å oppdatere vekter og formel er.
W_new = W_old – learning_rate * avledet av tap med vekt
Derfor synker verdien av en derivert, så når vi oppdaterer vektene skjedde det veldig sakte fordi den deriverte er for liten, og etter hvert som vi øker lag avtar den kontinuerlig, og etter 2 lag med nevrale nettverk gir oppdatering av vekter ingen mening fordi den nye vekten er lik den gamle vekten. Og denne situasjonen er kjent som Vanishing Gradient Problem. Med enkle ord refererer forsvinningsgradient til det faktum at i tilbakepropageringsgradienter vanligvis avtar eksponentielt som en funksjon av avstanden fra det siste laget. Derfor, før 1986, var folk ikke i stand til å implementere dype nevrale nettverk. For å løse dette problemet bruker vi den nylig publiserte aktiveringsfunksjonen som Relu.
Hvordan løser Relu problemet med Vanishing Gradient Descent?
ReLU står for en Rectified lineær enhet som har en gradient på 1 når input er større enn null; ellers er den null. På kort tid har ReLU blitt standard og mest favoritt aktiveringsfunksjon for de fleste som gjør trening av et nevralt nettverk enklere og bidrar til å oppnå bedre ytelse.
g(z) = maks(0, z)
Hva kan vi utlede fra ReLu? ReLU-funksjonen metter ikke, og den har en større og konstant gradient sammenlignet med sigmoid- og tanh-aktiveringsfunksjonene. Funksjonen er lineær for verdier større enn null, og den er ikke-lineær for negative verdier.
når vi multipliserer en haug med relative derivater sammen i tilbakepropagering, så har den den fine egenskapen å være enten 1 eller 0. Derfor er det ingen forsvinnende eller avtagende gradientnedstigning.
Definere nevral nettverksarkitektur for Neurale nettverk ytelsesoptimalisering
Det er noen vanlige ting vi vet når vi bygger et nevralt nettverk, men det er nødvendig å huske at slike parametere fungerer med en annen problemformulering
I) Tapsfunksjon
- Med problemsetningen for binær klassifisering bruker vi binær kryssentropi som en tapsfunksjon
- I flerklasseklassifiseringsproblemet bruker vi sparsom kategorisk kryssentropi
- I regresjon bruker vi gjennomsnittlig kvadratfeil
ii) Optimalisatorer å velge
Den beste ytelsesoptimereren som for tiden brukes i mange brukstilfeller er Adam. Bortsett fra det, er det mange flotte optimizere som RMSProp, Adagrad, Adadelta, etc.
iii) Aktiveringsfunksjon
- I nevrale nettverksarkitekturer med skjulte lag er relu den mest foretrukne aktiveringsfunksjonen.
- I siste lag som arbeider med binær klassifisering, bruk sigmoid
- I siste lag som arbeider med Multiclass-klassifisering, bruk softmax
- I regresjonsproblemer bruker lineær
Det er en annen aktiveringsfunksjon som tanh som også noen ganger fungerer effektivt.
Riktig vektinitialisering for Neurale nettverk ytelsesoptimalisering
Vektinitialisering omfatter å sette opp vektvektoren for alle nevronene for første gang rett før nevrale nettverkstrening starter. Et nettverk med feil initialisering av vekt gjør læringsprosessen kompleks og tidkrevende; Derfor er det viktig å oppnå raskere konvergens og gjennomførbar læringsvekt. Det er forskjellige måter folk bruker for vektinitialisering, og la oss se hvilken metode som skaper et problem og hvilken som skal brukes i forskjellige scenarier.
i) Initialisere vekter med null
Det er mulig å initialisere vekter med null, men det er en dårlig idé å gjøre det fordi initialisering av vekter med null ikke skaper noen følelse av å bygge et nevralt nettverk hvis nevronene er døde i starttilstanden. Det gjør at modellen fungerer tilsvarende en lineær modell.
ii) Tilfeldig initialisering
For å initialisere vektene tilfeldig, kan du bruke 2 statistiske metoder som standard normalfordeling eller enhetlig fordeling. Ved tilfeldig initialisering er vekten større enn 0, og nevronene er ikke døde. med den tilfeldige initialiseringen vil du observere eksponentielt avtagende tap, men deretter invertert, og vi kan støte på problemet med forsvinnende gradientnedstigning eller eksploderende gradientnedstigning.
vi har sett at initialisering av vekter med null eller tilfeldig initialisering ikke er bra. la oss diskutere noen standardmetoder som viser seg å være best for vektinitialisering.
iii) Xavier-initialisering
Dyplæringsmodeller finner det vanskelig å konvergere når vekter initialiseres med normalfordeling. Dette er fordi variansen av vekter ikke er ivaretatt, noe som fører til store eller svært små aktiveringsverdier og resulterer i eksploderende gradientproblemer. For å overvinne dette problemet ble Xavier-initialisering introdusert som holder variansen til alle lag lik.
Dette er en innebygd metode i Keras for å initialisere vekter implementert av en dataforsker ved navn Gloret Xavier. Den bruker noen spesifikke statistiske metoder for å definere vekter for nevroner. Xavier-initieringsmetoden beregnes som et tilfeldig tall med en jevn sannsynlighetsfordeling (U) mellom området -(1/sqrt(n)) og 1/sqrt(n), hvor n er antall innganger til en node. I Xavier initialiseringsskjevheter initialiseres med null og vekter initialiseres som.
vekt = U [-(1/sqrt(n)), 1/sqrt(n)]
Som en tommelfingerregel fungerer Xavier-initialisering best med sigmoid- eller tanh-aktiveringsfunksjonen. Hvis du vil utlede den fullstendige formelen og forstå Xaviers initialisering i detalj, vennligst se Andys blogg her..
iv) He Initialisering.
Kaiming Initialization eller He Initialization er vektinitialiseringsmetoden for nevrale nettverk som tar hensyn til ikke-lineariteten til aktiveringsfunksjoner, for eksempel ReLU-aktivering.
Hvis du jobber med relu-aktivering, vil He-initialisatoren gi bedre resultater som bringer variansen av utganger til omtrent én. Det er det samme som Xavier, forskjellen er relatert til ikke-linearitetene til Relu, som er ikke-differensierbar ved x=0. Så med relu er det bedre å initialisere vektene med He-initialisering som definerer varians ved å bruke formelen nedenfor.
v^2 = 2/N
Det vil si en nullsentrert gaussisk med et standardavvik av kvadratroten av 2/N (varians vist i ligningen ovenfor). Forvrengninger initialiseres ved 0. Dette er HE initialisering. For mer om Kaiming(He) initialisering, se denne blogg.
Kontroll Overtilpasning av nevralt nettverk for Prestasjonsoptimalisering
Overfitting skjer når modellen har en tendens til å lære støy eller hypnotisere treningsdataene og presterer bra på treningsdata, men gir dårligst ytelse på testdata (nye data), og dette kalles overfitting. Nevrale nettverk gjennomgår også overtilpasning når du prøver å implementere et dypt nettverk på små data eller uten å bruke noen form for regularisering og bruke et stort antall epoker. Det finnes forskjellige metoder for å kontrollere overtilpasning i nevrale nettverk.
i) Redusere kompleksitet/øke data
Den enkle måten å redusere overtilpasning på er å øke inngangsdataene slik at nevrale nettverkstrening er på mer høydimensjonale data. Så mye som du øker dataene, vil det slutte å lære støy. Hvis det ikke er mulig å øke dataene, prøv å redusere kompleksiteten til nevrale nettverksarkitektur ved å redusere antall skjulte lag, redusere antall noder, redusere et visst antall epoker.
ii) Dropout-lag
Frafall er et interessant og nytt fenomen for å redusere overtilpasning i nevrale nettverk. Jeg håper du kjenner beslutningstreet. Problemet med beslutningstreet er at det overpasser dataene, og løsningen på dette kom med en tilfeldig skog. I en tilfeldig skogalgoritme bygde vi forskjellige beslutningstrær og hvert beslutningstre får prøvedataene i stedet for komplette data, noe som hindrer modellen i å overpasse på en slik måte at all støyen ikke har blitt lært av hver modell. Med enkle ord presterer vi regularisering ved randomisering i en tilfeldig skog og hindre overmontering.
Den samme metoden brukes av frafall i nevrale nettverk. I hver epoke inaktiverer frafall et visst antall av nevronene som trengs for å delta i treningen. Nevronene velges på tilfeldig basis. Vi erklærer en rate med frafall mens vi bruker beskriver sannsynligheten for at nevroner ikke velges i treningssettet. 0.2 til 0.5 rateverdier brukes for det meste og gir bedre resultater.
iii) Regularisering (L1 og L2)
L1- og L2-regularisering er også kraftige maskinlærings-regulariseringsteknikker du kan bruke for å straffe nevrale nettverkstrening og redusere overtilpasning.
I det nevrale nettverket bruker vi hovedsakelig lasso(L1)-regularisering. I L1- og L2-regularisering legger vi til en regulariseringsparameter som prøver å minimere vekter. Og på grunn av denne korreksjonen i vekter, bryter noen tilkoblinger i nettverket, og først, der modellen prøvde å fange alle tilkoblingene, nå på grunn av å legge til en regulariseringsparameter, vil den prøve å jevne ut tapet.
Ligningen SGD er
new_weight = old_weight – LR * gradient
Etter å ha brukt L1-regularisering blir ligningen
new_weight = old_weight(1 – LR * alfa) – LR * gradient
Hvis du ser på begge ligningene så er de like, bare ett ekstra ledd introduseres. Hvis verdien av alfa er høy, vil verdien av vektene reduseres. Og overmontering skjer kun når vekter oppnår en høy verdi, og ved å bruke dette er vi i stand til å håndtere verdien av vekter og redusere overtilpasning.
Mens du implementerer dette i det nevrale nettverket, er det en parameter som kalles kjerneinitialiserer. vi bruker dette til å definere hvilken type regularisering som skal brukes.
model = Sequential() model.add(Dense(128, input_dim=2, activation="relu", kernel_regularizer='l2')) model.add(Dense(1, input_dim=2, activation="sigmoid", kernel_regularizer= 'l2')) model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
iv) Tidlig stopp
Tidlig stopp er en metode der vi bruker en begrensning på å trene nevrale nettverk. Det forhindrer strengt trening av dype nevrale nettverk ved å stoppe treningen på et bestemt tidspunkt og avslutte koden. Ta en titt på grafen nedenfor for å forstå tidlig stopp. Når en modell overpasser data, er tapsgrafen du oppnådde noe sånt som grafen nedenfor.
Vi kan observere at treningsfeilen minker, men hva med testfeilen, den avtar først og etter 750 til 800 epoker begynner den gradvis å øke, noe som betyr at det nevrale nettverket overtilpasser dataene. Her hjelper tidlige stoppkriterier oss til å forbedre modellen. Det tidlige stoppingen gjør er fra det punktet hvor testfeilen begynner å øke, den vil stoppe treningen før punktet hvor feilen var minimum og grafen vil ikke bevege seg fremover.
For å implementere tidlig stopp praktisk talt hvit, trener vi nevrale nettverk, det er en metode som heter tilbakeringing som kan brukes og vi kan overføre Early stopping funksjonen til den som vil overvåke valideringstapet kontinuerlig og vil stoppe treningen der det ser ut til å øke.
historie = model.fit(x_train, y_train, validation_data = (x_test, y_test),epoker = 200, tilbakeringinger = EarlyStopping(monitor="val_loss"))
Etter å ha brukt tidlig stopp vil du få en jevn grense og kontroll over tilpasning. Som jeg har plottet og observer under grafen, stopper den etter 100 epoker betyr at testtapet er minimum, det vil stoppe der, det vil si tidlig stopp.
- For mer om tidlig stopp, se Wikipedia Artikkel
- Mer om overtilpasning i nevrale nettverk, se denne blogg.
Hvorfor er normalisering viktig i nevrale nettverk?
Normalisering er en teknikk som brukes i dataforbehandlingstrinnet for å bringe verdien av den numeriske kolonnen i en vanlig skala-lignende mellom 0 til 1 eller -1 til 1. Normalisering av verdiene gjør det enkelt for de fleste maskinlæringsalgoritmer å kjøre raskere og oppnå bedre ytelse.
Det er blitt sagt at når du først sender dataene til et nevralt nettverk, bør du normalisere dem. Når data ikke er normalisert er det ikke slik at det nevrale nettverket ikke vil konvergere, men det vil bremse prosessen og trenger et stort antall epoker for å konvergere. Med enkle ord, nøyaktigheten og konvergensen du kan få med normaliserte data i 200 epoker kan ikke oppnå dem selv i 2000 epoker. La oss bevise dette praktisk talt hvorfor normalisering av verdier betyr noe å jobbe med nevrale nettverk.
Vi vil bruke Pima Indians Diabetes datasett tilgjengelig på Kaggle. Datasettet er enkelt og populært der vi må forutsi om en person har diabetes eller ikke bruker noen funksjoner som insulinnivå, BMI, alder, mange forskjellige funksjoner. datasettet ser ut som eksempelbildet nedenfor.
Vi vil sammenligne ytelsen til det nevrale nettverket når uten normalisering data sendes og med normalisering sendes data. Nedenfor er arkitekturen til det nevrale nettverket der data etter deling i tog og test går over til modellering uten normalisering.
model = Sequential() model.add(Dense(10,input_dim=2, activation="relu")) model.add(Dense(10, activation="relu")) model.add(Dense(1, activation=" sigmoid")) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy']) history = model.fit(x_train, y_train, validation_data=(x_test, y_test), verbose=1) importer matplotlib.pyplot som plt plt.plot(history.history['val_accuracy'])
Du kan se i grafen ovenfor at modellen ikke er i stand til å konvergere selv etter slutten av epoker, og den varierer mellom 72 og 27. Når vi sender dataene etter normalisering, er resultatene våre bedre sammenlignet med tilfellet ovenfor.
fra sklearn.preprocessing import StandardScaler scaler = StandardScaler() X = scaler.fit_transform(X) fra sklearn.model_selection import train_test_split X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,random_state
Send nå data til den samme modellen opprettet ovenfor og observer resultatene.
Overvåk gradientene dine (Gradient klipping)
Gradient Clipping betyr å tvinge en gradientverdi til et spesifikt minimum eller maksimum når gradienten overskred et forventet område. Det er kjent som Gradient Clipping. Dette er en måte å forhindre at en gradient eksploderer og går ut av kontroll i dyp arkitektur - spesielt i RNN og CNN. Med enkle ord hver gang Gradient-nedstigningsalgoritmen prøver å ta et langt skritt, forhindrer gradientklippingen den fra å redusere trinnstørrelsen slik at det er mindre sannsynlig at den går utenfor regionen. Keras Optimizer har to parametere, eller det er to måter å gjøre det på.
i) Klipp etter norm ~ Hvis L2-normen eller gradienttensoren er mer enn en spesifikk verdi, normaliserer vi gradienttensoren med ligningen nedenfor. Det er vi deler den gamle gradienten med sin modul inn i klippnormparametere.
gradient = gradient * clipnorm / ||gradient||
ii) Klipp etter verdi ~ Hvis verdien ved en hvilken som helst indeks i gradienttensor er større enn en spesifikk verdi eller mindre enn null eller den samme negative verdien, normaliserer vi gradienten ved å bruke ligningen nedenfor.
gradient = klipp(gradient, -klippverdi, klippverdi)
Det anbefales å bruke klipping etter norm, da retningen på gradienten ikke endres etter skalering. Det betyr at når vi bruker clip-by-verdi, har retningen til den bratteste gradienten store sjanser for å endre seg; det er ikke tilfellet med clip-by-norm; dermed forblir optimaliseringen stabil.
vi kan ganske enkelt implementere dette ved å bruke Keras mens vi initialiserer I optimizer under modellkompilering.
model.compile(optimizer=Adam(learning_rate=0.1, clipnorm=1))
Du kan også prøve klipp etter verdi og sammenligne resultatene. For å lese mer om gradientklipping, besøk denne blogg.
Hyperparameterinnstilling av Deep Neural Network
Det er et bibliotek kalt Keras-Tuner som du kan bruke til å velge riktig sett med parametere for å justere et nevralt nettverk og forbedre ytelsen. Vi vil praktisk talt lære hyperparameterinnstilling med Keras-tuner på noen datasett. vi bruker den samme Pima Indian Diabetes datasett av Kaggle som vi brukte ovenfor. Vi vil utføre hyperparameterinnstilling for å velge riktig optimizer, antall noder i et lag, antall lag.
Hvordan velge riktig optimizer med Keras-tuner?
Trinn 1) Først må du installere Keras-tuneren ved å bruke pip-kommandoen.
pip install -U keras-tuner
Trinn 2) Etter installasjon, lar det lastede datasettet og dele datasettet i tog og testsett for bygningsmodell.
importer pandaer som pd df = pd.read_csv('diabetes.csv') fra sklearn.preprocessing import StandardScaler fra sklearn.model_selection import train_test_split X = df.iloc[:,:-1].values y = df.iloc[:, -1].values scaler = StandardScaler() X = scaler.fit_transform(X) X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1)
Trinn 3) Bygge modellarkitektur for Hyperparameter Tuning
Nå skal vi bygge en funksjon som vil bygge en modellarkitektur med ulike sett med parametere vi ønsker å trene modellen på og velge det beste settet med parametere fra det.
importere tensorflow fra tensorflow importere keras fra keras import Sequential from keras.layers import Dense,Dropout import kerastuner som kt def build_model(hp): model = Sequential() model.add(Dense(32,activation='relu',input_dim=8 )) model.add(Dense(1,activation='sigmoid')) optimizer = hp.Choice('optimizer', values = ['adam','sgd','rmsprop','adadelta']) model.compile (optimizer=optimizer, tap='binary_crossentropy',metrics=['accuracy']) returmodell
Vi tuner modellen på toppen av optimizeren. Etter å ha kalt en byggemodellfunksjon, vil den returnere et kompilert modellobjekt.
Trinn 4) Lag Tuner-objekt
Nå skal vi lage et tunerobjekt der vi må bestå en modellfunksjon, mål og maksimale forsøk. Målet her er å forbedre valideringsnøyaktigheten, og maks spor betyr hvor mange ganger vi ønsker å iterere over parametere for å velge riktig parameter.
tuner = kt.RandomSearch(build_model, objective='val_accuracy', max_trials=5)
Nå som du kaller en søkefunksjon, vil den begynne å kjøre epoker og vise resultatene av hver passform ved å bruke en annen optimalisering hver gang. For å se den beste hyperparameteren, bruk den beste hyperparameterfunksjonen og tilgang til nullindeksverdier.
tuner.search(X_train,y_train,epochs=5,validation_data=(X_test,y_test)) tuner.get_best_hyperparameters()[0].values
Du vil få utdata i ulike forsøk som vist nedenfor, og ved å bruke funksjonen få den beste hyperparameteren kan du se den beste parametertilpasningen for modellen.
model = tuner.get_best_models(antall_models=1)[0] model.summary()
Det gir RMSProp, den beste optimalisereren å bruke som gir 82 prosent nøyaktighet på et valideringssett. Det er slik vi bruker grunnleggende tre til fire trinn for å velge riktig sett med parametere. la oss gjøre mer.
Hvordan finne antall noder i et lag?
Alle trinn er de samme som vi har studert ovenfor, så vi vil direkte implementere bygge en modellfunksjon der vi vil bruke hyperparameter heltallsfunksjon for å definere et område. Og vi vil lage et tunerobjekt og kalle søkefunksjonen som starter iterasjon og viser resultatet ved å trene en modell på en tilfeldig verdi i området.
def build_model(hp): model = Sequential() units = hp.Int('units',min_value = 8,max_value = 128) model.add(Dense(units=units, activation='relu',input_dim=8)) model.add(Dense(1,activation='sigmoid')) model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy']) return modell tuner = kt.RandomSearch(build_model, objektiv ='val_accuracy', max_trials=5, directory='mydir', project_name='num_neurons') tuner.search(X_train,y_train,epochs=5,validation_data=(X_test,y_test))
Det gir 72 som riktig antall nevroner som skal brukes i et lag. Nå kan du bruke få den beste hyperparameter-funksjonen for å sjekke best passform.
Hvordan velge et antall lag?
Det er litt forskjell på å lage en funksjon for å velge lag enn de to ovennevnte funksjonene fordi for å velge lag må vi kjøre en sløyfe slik at når den fortsetter å øke lag én, være en i nettverksarkitektur, trene den og vise resultater .
def build_model(hp): model = Sequential() model.add(Dense(72,activation='relu',input_dim=8)) for i in range(hp.Int('num_layers',min_value=1,max_value=10 )): model.add(Dense(72,activation='relu')) model.add(Dense(1,activation='sigmoid')) model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics =['accuracy']) return model tuner = kt.RandomSearch(build_model, objective='val_accuracy', max_trials=3, directory='mydir', project_name='num_layers')
Vi får 6 som det beste antallet skjulte lag i nevrale nettverksarkitekturer.
Kombinere alt sammen
Nå vil du endelig tenke på hyperparameterinnstilling; vi må gjøre dette separat, så må si at det ikke er tilfelle. Nå skal vi gjøre hyperparameterinnstilling i en enkelt funksjon for å velge antall nevroner i et lag, et antall lag, aktiveringsfunksjon, optimerer og til og med frafallshastigheten vi skal bruke.
def build_model(hp): modell = Sekvensiell() teller = 0 for i in range(hp.Int('antall_layers',min_value=1,max_value=10)): if counter == 0: model.add(Dense(hp) .Int('units' + str(i), min_value=8, max_value=128,step=8),activation= hp.Choice('activation' + str(i), values=['relu','tanh' ,'sigmoid']),input_dim=8)) model.add(Dropout(hp.Choice('dropout' + str(i), verdier=[0.1,0.2,0.3,0.4,0.5,0.6]))) annet : model.add(Dense(hp.Int('units' + str(i), min_value=8, max_value=128,step=8),activation= hp.Choice('activation' + str(i), values= ['relu','tanh','sigmoid']))) model.add(Dropout(hp.Choice('dropout' + str(i), verdier=[0.1,0.2,0.3,0.4,0.5,0.6] ))) teller+=1 model.add(Dense(1,activation='sigmoid')) model.compile(optimizer=hp.Choice('optimizer',values=['rmsprop','adam','sgd', 'nadam','adadelta']), loss='binary_crossentropy', metrics=['accuracy']) returmodell
Det gir ganske anstendige resultater, og hyperparameteren den genererer for modellen overpasser ikke lenger, og resultatene er flotte. Og nå hvis du plotter nøyaktighets- og tapsgrafen til modellen, vil du få et jevnt plott.
plt.figure(0) plt.plot(history.history['accuracy'], label="Training accuracy") plt.plot(history.history['val_accuracy'], label="val accuracy") plt.title( "Nøyaktighet") plt.xlabel("epoker") plt.ylabel("nøyaktighet") plt.legend() plt.figure(1) plt.plot(history.history['tap'], label="treningstap" ) plt.plot(history.history['val_loss'], label="val loss") plt.title("Tap") plt.xlabel("epoker") plt.ylabel("Tap") plt.legend() plt.show()
Keras-tuner er et flott bibliotek du bør spille rundt det og bruke for å velge det riktige settet med hyperparametre for din nevrale nettverksmodell for å kontrollere overtilpasning.
Slutt notater
I denne artikkelen diskuterte vi forskjellige tilnærminger og metoder for å forbedre ytelsen til nevrale nettverk. Vi så på utfordringene nevrale nettverk står overfor i forskjellige scenarier og løsningen vi bør bruke for å overvinne dem. vi lærte teknikker som regularisering, tidlig stopp som kan bidra til å konvergere raskere. Til slutt kom vi over hyperparametertuning, som er en avgjørende metode for å forbedre den generelle nettverksarkitekturen og ytelsen, og vi har utført hyperparametertuning fra bunnen av på forskjellige måter.
- For mer om å forbedre ytelsen til nevrale nettverk, se offisiell artikkel fra Robert, Harris og Patrice her..
- Praktisk for å forbedre ytelsen til dyplæringsmodeller, link
Hvis du har noen tvil eller tilbakemeldinger, del dem gjerne i kommentarfeltet nedenfor.
Om forfatteren
Jeg tar en bachelor i informatikk. Jeg er en datavitenskap -entusiast og elsker å lære, jobbe i datateknologier.
Kontakt meg videre Linkedin
Sjekk mine andre artikler her. og på Blogspot
Takk for at du gir deg tid!
Media vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn.
- "
- 100
- 7
- 9
- adgang
- Logg inn
- algoritme
- algoritmer
- Alle
- Alpha
- analytics
- søknader
- arkitektur
- rundt
- Artikkel
- artikler
- BEST
- Bit
- Blogg
- bygge
- Bygning
- Bunch
- ring
- hvilken
- saker
- Catch
- sjansene
- endring
- klassifisering
- kode
- Kolonne
- kommentarer
- Felles
- Konkurranser
- Beregn
- informatikk
- Tilkoblinger
- Opprette
- dato
- datavitenskap
- død
- håndtering
- beslutningstre
- dyp læring
- dype nevrale nettverk
- dype nevrale nettverk
- Derivater
- detalj
- Utvikling
- Diabetes
- avstand
- Tidlig
- etc
- Egenskaper
- Endelig
- Først
- første gang
- passer
- Forward
- Gratis
- funksjon
- Giving
- god
- flott
- veilede
- Håndtering
- her.
- Høy
- historie
- Hvordan
- HP
- HTTPS
- stort
- Tanken
- bilde
- Øke
- indeks
- IT
- hard
- stor
- LÆRE
- lært
- læring
- Nivå
- Bibliotek
- lokal
- Lang
- så
- elsker
- maskinlæring
- Saker
- Media
- modell
- flytte
- nettverk
- nettverk
- neural
- nevrale nettverket
- nevrale nettverk
- NeurIPS
- noder
- Bråk
- offisiell
- rekkefølge
- Annen
- Papir
- Ansatte
- ytelse
- Populær
- hindre
- eiendom
- område
- redusere
- regresjon
- forskning
- forskning og utvikling
- Resultater
- ROBERT
- Kjør
- rennende
- skalering
- Vitenskap
- Søk
- valgt
- forstand
- sett
- innstilling
- SGD
- Del
- Kort
- Enkelt
- Størrelse
- liten
- So
- LØSE
- splittet
- kvadrat
- Begynn
- Tilstand
- Uttalelse
- Studer
- Technologies
- Teknologi
- tensorflow
- test
- Grafen
- tenker
- tid
- topp
- Kurs
- Oppdater
- us
- verdi
- Hva er
- Wikipedia
- ord
- Arbeid
- virker
- X
- null