maskinindlæring bruges i sidste ende til at forudsige resultater givet et sæt funktioner. Derfor ses alt, hvad vi kan gøre for at generalisere ydeevnen for vores model, som en nettogevinst. Dropout er en teknik, der bruges til at forhindre, at en model overmonteres. Dropout fungerer ved tilfældigt at indstille de udgående kanter på skjulte enheder (neuroner, der udgør skjulte lag) til 0 ved hver opdatering af træningsfasen. Hvis du kigger på Keras-dokumentationen for dropout-laget, vil du se et link til et hvidt papir skrevet af Geoffrey Hinton og friends, som går ind i teorien bag dropout.
i procedureeksemplet bruger vi Keras til at opbygge et neuralt netværk med det formål at genkende håndskrevne cifre.
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 bruger Keras til at importere dataene til vores program. Dataene er allerede opdelt i Trænings-og testsættene.
(X_train, y_train), (X_test, y_test) = mnist.load_data()
lad os se på, hvad vi arbejder med.
plt.imshow(x_train, cmap = plt.cm.binary)
plt.show()
når vi er færdige med at træne model, skal den kunne genkende det foregående billede som en fem.
der er en lille forbehandling, som vi skal udføre på forhånd. Vi normaliserer billedpunkterne (funktioner), så de spænder fra 0 til 1. Dette vil gøre det muligt for modellen at konvergere mod en løsning, der meget hurtigere. Dernæst omdanner vi hver af måletiketterne for en given prøve til et array på 1s og 0s, hvor indekset for tallet 1 angiver det ciffer, som billedet repræsenterer. Vi gør dette, fordi vores model ellers ville fortolke cifferet 9 som en højere prioritet end tallet 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)
uden Frafald
før vi fodrer en 2-dimensionel matrice til et neuralt netværk, bruger vi et fladlag, der omdanner det til et 1-dimensionelt array ved at tilføje hver efterfølgende række til den, der gik forud for det. Vi skal bruge to skjulte lag bestående af 128 neuroner hver og et outputlag bestående af 10 neuroner, hver for et af de 10 mulige cifre. Aktiveringsfunktionen returnerer sandsynligheden for, at en prøve repræsenterer et givet ciffer.
da vi forsøger at forudsige klasser, bruger vi kategorisk crossentropi som vores tabsfunktion. Vi måler modelens ydeevne ved hjælp af nøjagtighed.
model.compile(
loss='categorical_crossentropy',
optimizer='adam',
metrics=
)
Vi sætter 10% af dataene til side til validering. Vi vil bruge dette til at sammenligne tendensen hos en model til overfit med og uden frafald. En batchstørrelse på 32 indebærer, at vi beregner gradienten og tager et skridt i retning af gradienten med en størrelse svarende til læringshastigheden efter at have passeret 32 prøver gennem det neurale netværk. Vi gør dette i alt 10 gange som angivet af antallet af epoker.
history = model.fit(
X_train,
y_train,
epochs=10,
batch_size=32,
validation_split=0.1,
verbose = 1,
shuffle=True
)
Vi kan plotte Trænings-og valideringsnøjagtighederne ved hver epoke ved hjælp af historikvariablen, der returneres af Fit-funktionen.
som du kan se, uden frafald, stopper valideringstabet efter den tredje epoke.
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
div>
frafald
der er en vis debat om, hvorvidt frafaldet skal placeres før eller efter aktiveringsfunktionen. Som tommelfingerregel skal du placere frafaldet efter aktiveringsfunktionen for alle andre aktiveringsfunktioner end relu. I forbifarten 0,5 er hver skjult enhed (neuron) indstillet til 0 med en sandsynlighed på 0,5. Med andre ord er der en 50% ændring, at udgangen af en given neuron vil blive tvunget til 0.
igen, da vi forsøger at forudsige klasser, bruger vi kategorisk crossentropi som vores tabsfunktion.
model_dropout.compile(
loss='categorical_crossentropy',
optimizer='adam',
metrics=
)
Ved at give valideringsdelingsparameteren, vil modellen adskille en brøkdel af træningsdataene og evaluere tabet og eventuelle modelmålinger på disse data i slutningen af hver epoke. Hvis forudsætningen bag frafald holder, skal vi se en bemærkelsesværdig forskel i valideringsnøjagtigheden sammenlignet med den foregående model. Shuffle-parameteren blander træningsdataene før hver epoke.
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, er valideringstabet betydeligt lavere end det, der opnås ved hjælp af den almindelige model.
som du kan se, konvergerede modellen meget hurtigere og opnåede en nøjagtighed på tæt på 98% på valideringssættet, mens den tidligere model plateaued omkring den tredje epoke.
nøjagtigheden opnået på testsættet er ikke meget anderledes end den, der opnås fra modellen uden frafald. Dette skyldes sandsynligvis det begrænsede antal prøver.
test_loss, test_acc = model_dropout.evaluate(X_test, y_test)
test_acc
div>
endelige tanker
frafald kan hjælpe en model med at generalisere ved tilfældigt at indstille output for en given neuron til 0. Ved indstilling af output til 0, omkostningsfunktionen bliver mere følsom over for nærliggende neuroner, der ændrer den måde, vægtene opdateres under processen med backpropagation.