Worstelen met Overfitting in Machine Learning - dummies

leert. Gezien de architectuur van het neurale netwerk, kunt u zich voorstellen hoe gemakkelijk het algoritme bijna alles van gegevens kan leren, vooral als u te veel lagen hebt toegevoegd. Het algoritme doet het zelfs zo goed dat de voorspellingen vaak worden beïnvloed door een hoge schattingsvariantie die overfitting wordt genoemd. Overfitting zorgt ervoor dat het neurale netwerk elk detail van de trainingsvoorbeelden leert, waardoor het mogelijk is om ze te repliceren in de voorspellingsfase. Maar afgezien van de trainingsset, zal het nooit iets anders correct voorspellen.

Begrijpen van het probleem van overfixen

Wanneer u een neuraal netwerk gebruikt voor een echt probleem, moet u op een veel striktere manier enkele voorzorgsmaatregelen nemen dan met andere algoritmen. Neurale netwerken zijn kwetsbaarder en meer vatbaar voor relevante fouten dan andere machine-leeroplossingen.

Eerst verdeelt u uw gegevens voorzichtig in trainings-, validatie- en testsets. Voordat het algoritme leert van gegevens, moet u de goedheid van uw parameters evalueren: architectuur (het aantal lagen en knooppunten daarin); activeringsfuncties; leerparameter; en aantal iteraties. In het bijzonder biedt de architectuur grote kansen om krachtige voorspellende modellen te maken met een hoog risico van overfitting. De leerparameter bepaalt hoe snel een netwerk leert van gegevens, maar het is misschien niet voldoende om te voorkomen dat de trainingsgegevens te veel worden aangepast.

U hebt twee mogelijke oplossingen voor dit probleem:

• De eerste oplossing is regularisatie, zoals bij lineaire en logistische regressie. U kunt alle verbindingscoëfficiënten optellen, in het kwadraat of in absolute waarde, om modellen met te veel coëfficiënten met hoge waarden te bestraffen (bereikt door L2-regularisatie) of met waarden die verschillen van nul (behaald door L1-regularisatie).
• De tweede oplossing is ook effectief omdat deze bepaalt wanneer overfitting plaatsvindt. Het heeft early-stop genoemd en werkt door de kostenfunctie van de validatieset te controleren, zoals het algoritme van de trainingsset leert.

Je realiseert je misschien niet wanneer je model overfittert. De kostenfunctie die wordt berekend met behulp van de trainingsset blijft verbeteren naarmate de optimalisatie vordert. Zodra u echter begint met het opnemen van ruis uit de gegevens en stopt met het leren van algemene regels, kunt u de kostenfunctie controleren op een out-of-sample (het validatiemonster). Op een gegeven moment zult u merken dat het niet meer verbetert en begint te verslechteren, wat betekent dat uw model de leerlimiet heeft bereikt.

De zwarte doos met neurale netwerken openen

De beste manier om te leren hoe een neuraal netwerk te bouwen, is er een te bouwen. Python biedt een schat aan mogelijke implementaties voor neurale netwerken en deep learning. Python heeft bibliotheken zoals Theano, die complexe berekeningen op een abstract niveau mogelijk maakt, en meer praktische pakketten, zoals Lasagne, waarmee je neurale netwerken kunt bouwen, hoewel het nog steeds enkele abstracties vereist. Om deze reden hebt u wrappers nodig, zoals nolearn, die compatibel is met scikit-learn, of Keras, die ook de door Google vrijgegeven TensorFlow-bibliotheek kan omwikkelen die het potentieel heeft om Theano te vervangen als een softwarebibliotheek voor neurale berekening.

R biedt bibliotheken die minder ingewikkeld en toegankelijker zijn, zoals nnet, AMORE en neuralnet. Deze korte voorbeelden in R laten zien hoe een classificatienetwerk (op de Iris-gegevensset) en een regressienetwerk (op de Boston-gegevensset) moet worden getraind. Uitgaande van classificatie laadt de volgende code de dataset en splitst deze in training en testsets:

library (neuralnet)

target <- model. matrix (~ Species & # x00A0; - 1, data = iris)

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

ingesteld. seed (101)

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

train_predictors <- iris [index, 1: 4]

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

Omdat neurale netwerken afhankelijk zijn van de afdaling van gradiënten, moet u de ingangen standaardiseren of normaliseren. Normaliseren is beter, zodat het minimum nul is en het maximum één voor elke functie. Uiteraard leert u alleen hoe u de numerieke conversie met behulp van de trainingsset kunt uitvoeren om te voorkomen dat u informatie uit de test buiten het sample gebruikt.

min_vector <- toepassen (train_predictors, 2, min)

range_vector <- toepassen (train_predictors, 2, max) -

toepassen (train_predictors, 2, min)

train_scaled <- cbind (scale (train_predictors,

min_vector, range_vector),

target [index,])

test_scaled <- cbind (schaal (test_predictors,

min_vector, range_vector),

target [-index,]) < samenvatting (train_scaled)

Wanneer de trainingsset gereed is, kunt u het model trainen om drie binaire variabelen te raden, waarbij elke groep een klasse vertegenwoordigt. De uitvoer is een waarde voor elke klasse evenredig met de waarschijnlijkheid dat deze de echte klasse is. U kiest een voorspelling door de hoogste waarde te nemen. U kunt het netwerk ook visualiseren door de interne plot te gebruiken en zo de architectuur van het neurale netwerk en de toegewezen gewichten te zien.

in te stellen. zaad (102)

nn_iris <- neuraalnet (setosa + versicolor + virginica ~

Sepal., lengte + sikkel, breedte

+ kroonblad. Lengte + bloemblad Breedte,

gegevens = treingeschaald, verborgen = c (2),

lineaire uitvoer = F)

grafiek (nn_iris)

voorspellingen <- berekenen (nn_iris, test_scaled [1: 4])

y_predicted <- apply (voorspellingen $ net. resultaat, 1, welke. max)

y_true <- apply (test_scaled [5: 7], 1, which. max)

confusion_matrix <- table (y_true, y_predicted)

nauwkeurigheid <- sum (diag (confusion_matrix)) /

sum (confusion_matrix)

print (confusion_matrix)

print (paste ("Accuracy:", accuracy))

U kunt een getraind neuraal netwerk uitzetten.

In het volgende voorbeeld ziet u hoe u huiswaarden in Boston kunt voorspellen met behulp van de gegevensset van Boston. De procedure is hetzelfde als in de vorige classificatie, maar hier heeft u een enkele uitvoereenheid. De code geeft ook de voorspelde resultaten van de testset weer tegen de werkelijke waarden om de goede pasvorm van het model te verifiëren.

no_examples <- nrow (Boston)

kenmerken <- colnames (Boston)

ingesteld. seed (101)

index <- monster (1: geen_voorbeelden, 400)

trein <- boston [index,]

test <- boston [-index,]

min_vector <- toepassen (trein, 2, min)

range_vector <- toepassen (trein, 2, max) - toepassen (trein, 2, min)

scaled_train <- schaal (trein, min_vector, range_vector)

scaled_test <- schaal (test, min_vector, reeks_vector)

formula = paste ("medv ~", paste (kenmerken [1: 13],

inkorten = & apos; + & apos;))

nn_boston <- neuralnet (formule, data = scaled_train,

hidden = c (5, 3), linear. output = T)

voorspellingen <- compute (nn_boston, scaled_test [1: 13])

predicted_values ​​<- (voorspellingen $ net. resultaat *

bereik_vector [14]) + min_vector [14]

RMSE <- sqrt (gemiddelde ((test [14] - voorspelde_waarden) ^ 2))

afdrukken (plakken ("RMSE:", RMSE))

plot (test [14], voorspelde_waarden, cex = 1. 5)

abline (0, 1, lwd = 1)