Kämpar med överfitting i maskinlärande - dummies

Med tanke på den neurala nätverksarkitekturen kan du föreställa dig hur lätt algoritmen kan lära sig nästan allt från data, speciellt om du lägger till för många lager. I själva verket gör algoritmen så bra att dess förutsägelser ofta påverkas av en hög uppskattningsvariant som kallas övermontering. Överfitting gör att det neurala nätverket lär sig varje detalj i träningsexemplen, vilket gör det möjligt att replikera dem i prediktionsfasen. Men förutom träningsuppsättningen kommer det aldrig någonsin att förutsäga något annat.

Förstå överfittingproblemet

När du använder ett neuralt nätverk för ett verkligt problem måste du vidta några försiktighetsåtgärder på ett mycket strängare sätt än vad du gör med andra algoritmer. Neurala nätverk är frailer och mer benägna att relevanta fel än andra maskininlärningslösningar.

Först delar du noggrant dina data i träning, validering och testuppsättningar. Innan algoritmen lär sig från data måste du utvärdera godheten hos dina parametrar: arkitektur (antalet lager och noder i dem); aktiveringsfunktioner; lärande parameter; och antal iterationer. I synnerhet erbjuder arkitekturen stora möjligheter att skapa kraftfulla prediktiva modeller med hög risk för övermontering. Inlärningsparametern styr hur snabbt ett nätverk lär sig från data, men det kan inte räcka för att förhindra övervakning av träningsdata.

Du har två möjliga lösningar på detta problem:

Den första lösningen är regularisering, som i linjär och logistisk regression. Du kan summera alla kopplingskoefficienter, kvadrerade eller i absolutvärde, för att straffa modeller med för många koefficienter med höga värden (uppnås genom L2-regularisering) eller med värden som skiljer sig från noll (uppnås genom L1-regularisering).
Den andra lösningen är också effektiv eftersom den kontrollerar när överfitting sker. Den heter early-stop och fungerar genom att kontrollera kostnadsfunktionen på valideringsuppsättningen som algoritmen lär sig från träningsuppsättningen.

Du kanske inte inser när din modell börjar överföras. Kostnadsfunktionen som beräknas med träningsuppsättningen fortsätter att förbättras när optimeringen fortskrider. Men så fort du börjar spela in ljud från data och sluta lära sig allmänna regler, kan du kontrollera kostnadsfunktionen på ett externt prov (valideringsprovet). Vid något tillfälle kommer du märka att det slutar förbättra och börjar förvärras, vilket innebär att din modell har nått sin inlärningsgräns.

Öppna den svarta rutan i neurala nätverk

Det bästa sättet att lära sig att bygga ett neuralt nätverk är att bygga en. Python erbjuder en mängd möjliga implementeringar för neurala nätverk och djupt lärande. Python har bibliotek som Theano, vilket möjliggör komplexa beräkningar på abstrakt nivå och mer praktiska paket, som Lasagne, som låter dig bygga neurala nätverk, men det kräver fortfarande några abstraktioner. Av denna anledning behöver du wrappers, som nolearn, som är kompatibel med scikit-learn, eller Keras, som också kan sätta in TensorFlow-biblioteket som släpptes av Google, som har potential att ersätta Theano som ett mjukvarubibliotek för neural beräkning.

R ger bibliotek som är mindre komplicerade och mer tillgängliga, till exempel nnet, AMORE och neuralnet. Dessa korta exempel i R visar hur man tränar både ett klassificeringsnätverk (på Iris dataset) och ett regressionsnätverk (på Boston-dataset). Från och med klassificeringen laddar följande kod datauppsättningen och delar upp den i tränings- och testuppsättningar:

bibliotek (neuralnet)

mål <- modell. matris (~ Species, # 1, data = iris)

colnames (target) <- c ("setosa", "versicolor", "virginica")

frö (101)

index <- prov (1: nrow (iris), 100)

train_predictors <- iris [index, 1: 4]

test_predictors <- iris [-index, 1: 4]

Eftersom neurala nätverk bygger på gradient nedstigning, måste du standardisera eller normalisera ingångarna. Normalisering är bättre så att läget är noll och maximalt är en för varje funktion. Naturligtvis lär du dig hur man gör den numeriska omvandlingen endast med träningsuppsättningen för att undvika chanser att använda information från testet utanför provet.

min_vektor <- tillämpa (train_predictors, 2, min)

range_vector <- tillämpa (train_predictors, 2, max) -

tillämpa (train_predictors, 2, min)

train_scaled <- cbind

test_scaled <- cbind (skala (test_predictors,

min_vector, range_vector),

mål [-index,]) < sammanfattning (train_scaled)

När träningssatsen är klar kan du träna modellen för att gissa tre binära variabler, var och en representerar en klass. Utgången är ett värde för varje klass proportionellt mot sannolikheten för att vara den verkliga klassen. Du väljer en förutsägelse genom att ta det högsta värdet. Du kan också visualisera nätverket genom att använda det inre diagrammet och därmed se den neurala nätverksarkitekturen och de tilldelade vikterna.

set. frö (102)

nn_iris <- neuralnet (setosa + versicolor + virginica ~

Sepal. Längd + Sepal. Bredd

+ Petal. Längd + Petal. Bredd,

data = train_scaled, hidden = c (Nn_iris, test_scaled [1: 4])

y_predicted <- apply resultat, 1, vilken. max)

y_true <- tillämpa (test_scaled [5: 7], 1, vilken. max)

confusion_matrix <- table (y_true, y_predicted)

noggrannhet <- summa diag (confusion_matrix)) /

summa (confusion_matrix)

skriv ut (confusion_matrix)

print (klistra in ("Noggrannhet:", noggrannhet))

Du kan rita ett utbildat neuralt nätverk.

Följande exempel visar hur man kan förutsäga husvärden i Boston, med hjälp av Boston-datasatsen. Förfarandet är detsamma som i föregående klassificering, men här har du en enda utmatningsenhet. Koden visar också testsatsens förutsägda resultat mot de verkliga värdena för att verifiera modellens bra passform.

no_examples <- nrow (Boston)

funktioner <- colnames (Boston)

set. frö (101)

index <- prov (1: no_examples, 400)