maskininlärning används slutligen för att förutsäga resultat med en uppsättning funktioner. Därför ses allt vi kan göra för att generalisera prestandan hos vår modell som en nettovinst. Dropout är en teknik som används för att förhindra att en modell överfittas. Dropout fungerar genom att slumpmässigt ställa in de utgående kanterna på dolda enheter (neuroner som utgör dolda lager) till 0 vid varje uppdatering av träningsfasen. Om du tittar på keras-dokumentationen för dropout-lagret ser du en länk till ett vitt papper skrivet av Geoffrey Hinton and friends, som går in i teorin bakom dropout.
i det pågående exemplet använder vi Keras för att bygga ett neuralt nätverk med målet att känna igen handskrivna siffror.
from keras.datasets import mnist
from matplotlib import pyplot as plt
plt.style.use('dark_background')
from keras.models import Sequential
from keras.layers import Dense, Flatten, Activation, Dropout
from keras.utils import normalize, to_categorical
Vi använder Keras för att importera data till vårt program. Uppgifterna är redan uppdelade i tränings-och testuppsättningarna.
(X_train, y_train), (X_test, y_test) = mnist.load_data()
Låt oss ta en titt för att se vad vi arbetar med.
plt.imshow(x_train, cmap = plt.cm.binary)
plt.show()
När vi har tränat ut modellen ska den kunna känna igen föregående bild som en fem.
det finns en liten förbehandling som vi måste utföra i förväg. Vi normaliserar pixlarna (funktionerna) så att de sträcker sig från 0 till 1. Detta gör det möjligt för modellen att konvergera mot en lösning som mycket snabbare. Därefter omvandlar vi var och en av måletiketterna för ett givet prov till en matris av 1s och 0s där indexet för siffran 1 indikerar siffran som bilden representerar. Vi gör detta för annars skulle vår modell tolka siffran 9 som högre prioritet än siffran 3.
X_train = normalize(X_train, axis=1)
X_test = normalize(X_test, axis=1)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
utan bortfall
innan vi matar in en 2-dimensionell matris i ett neuralt nätverk använder vi ett plattskikt som omvandlar det till en 1-dimensionell matris genom att lägga till varje efterföljande rad till den som föregick den. Vi kommer att använda två dolda lager bestående av 128 neuroner vardera och ett utgångslager bestående av 10 neuroner, var och en för en av de 10 möjliga siffrorna. Softmax-aktiveringsfunktionen returnerar sannolikheten för att ett prov representerar en given siffra.
eftersom vi försöker förutsäga klasser använder vi kategorisk korsentropi som vår förlustfunktion. Vi kommer att mäta modellens prestanda med noggrannhet.
model.compile(
loss='categorical_crossentropy',
optimizer='adam',
metrics=
)
vi ställer 10% av data åt sidan för validering. Vi kommer att använda detta för att jämföra tendensen hos en modell att övermontera med och utan bortfall. En batchstorlek på 32 innebär att vi kommer att beräkna lutningen och ta ett steg i gradientens riktning med en storlek som är lika med inlärningshastigheten, efter att ha passerat 32 prover genom det neurala nätverket. Vi gör detta totalt 10 gånger som anges av antalet epoker.
history = model.fit(
X_train,
y_train,
epochs=10,
batch_size=32,
validation_split=0.1,
verbose = 1,
shuffle=True
)
Vi kan plotta tränings-och valideringsnoggrannheterna vid varje epok med hjälp av historikvariabeln som returneras av Fit-funktionen.
som du kan se, utan bortfall, upphör valideringsförlusten att minska efter den tredje epoken.
As you can see, without dropout, the validation accuracy tends to plateau around the third epoch.
Using this simple model, we still managed to obtain an accuracy of over 97%.
test_loss, test_acc = model.evaluate(X_test, y_test)
test_acc
dropout
det finns en viss debatt om huruvida bortfallet ska placeras före eller efter aktiveringsfunktionen. Som tumregel placerar du bortfallet efter aktiveringsfunktionen för alla andra aktiveringsfunktioner än relu. I förbigående 0,5 är varje dold enhet (neuron) inställd på 0 med en sannolikhet på 0,5. Med andra ord är det en 50% förändring att utsignalen från en given neuron kommer att tvingas till 0.
återigen, eftersom vi försöker förutsäga klasser, använder vi kategorisk korsentropi som vår förlustfunktion.
model_dropout.compile(
loss='categorical_crossentropy',
optimizer='adam',
metrics=
)
genom att tillhandahålla validations split-parametern kommer modellen att skilja en bråkdel av träningsdata och utvärdera förlusten och eventuella modellmätningar på dessa data i slutet av varje epok. Om förutsättningen bakom dropout håller, bör vi se en märkbar skillnad i valideringsnoggrannheten jämfört med föregående modell. Shuffle-parametern blandar träningsdata före varje epok.
history_dropout = model_dropout.fit(
X_train,
y_train,
epochs=10,
batch_size=32,
validation_split=0.1,
verbose = 1,
shuffle=True
)
som du kan se är valideringsförlusten betydligt lägre än den som erhållits med den vanliga modellen.
som du kan se konvergerade modellen mycket snabbare och fick en noggrannhet på nära 98% på valideringsuppsättningen, medan den tidigare modellen platåde runt den tredje epoken.
noggrannheten som erhålls på testuppsättningen är inte mycket annorlunda än den som erhållits från modellen utan bortfall. Detta beror sannolikt på det begränsade antalet prover.
test_loss, test_acc = model_dropout.evaluate(X_test, y_test)
test_acc
slutliga tankar
dropout kan hjälpa en modell att generalisera genom att slumpmässigt ställa in utgången för en given neuron till 0. Vid inställning av utgången till 0 blir kostnadsfunktionen känsligare för närliggande neuroner som förändrar hur vikterna kommer att uppdateras under processen med backpropagation.