Aux prises avec le surapprentissage dans l'apprentissage automatique - les nuls

Étant donné l'architecture du réseau neuronal, vous pouvez imaginer à quel point l'algorithme peut apprendre presque n'importe quoi des données, surtout si vous avez ajouté trop de couches. En fait, l'algorithme fonctionne si bien que ses prédictions sont souvent affectées par une variance estimée élevée appelée overfitting. Le surapprentissage amène le réseau neuronal à apprendre chaque détail des exemples d'apprentissage, ce qui permet de les répliquer dans la phase de prédiction. Mais en dehors de l'ensemble d'entraînement, il ne sera jamais correctement prédire quelque chose de différent.

Comprendre le problème de suralimentation

Lorsque vous utilisez un réseau de neurones pour un vrai problème, vous devez prendre certaines mesures de précaution d'une manière beaucoup plus stricte que vous avec d'autres algorithmes. Les réseaux de neurones sont plus fragiles et plus enclins aux erreurs pertinentes que les autres solutions d'apprentissage automatique.

Tout d'abord, vous divisez soigneusement vos données en ensembles de formation, de validation et de test. Avant que l'algorithme n'apprenne à partir des données, vous devez évaluer la qualité de vos paramètres: l'architecture (le nombre de couches et de nœuds qui s'y trouvent); fonctions d'activation; paramètre d'apprentissage; et nombre d'itérations. En particulier, l'architecture offre de grandes opportunités pour créer de puissants modèles prédictifs à haut risque de sur-apprentissage. Le paramètre d'apprentissage contrôle la rapidité avec laquelle un réseau apprend à partir des données, mais il peut ne pas suffire à empêcher le surajustement des données d'apprentissage.

Vous avez deux solutions possibles à ce problème:

La première solution est la régularisation, comme dans la régression linéaire et logistique. Vous pouvez additionner tous les coefficients de connexion, au carré ou en valeur absolue, pour pénaliser les modèles avec trop de coefficients avec des valeurs élevées (obtenues par régularisation L2) ou avec des valeurs différentes de zéro (obtenues par régularisation L1).
La deuxième solution est également efficace car elle contrôle quand le surapprentissage se produit. Il s'appelle early-stop et fonctionne en vérifiant la fonction de coût de l'ensemble de validation lorsque l'algorithme apprend à partir de l'ensemble d'apprentissage.

Vous ne réalisez peut-être pas le moment où votre modèle commence à être surcoupé. La fonction de coût calculée à l'aide du jeu d'apprentissage ne cesse de s'améliorer au fur et à mesure de l'optimisation. Cependant, dès que vous commencez à enregistrer du bruit à partir des données et arrêtez l'apprentissage des règles générales, vous pouvez vérifier la fonction de coût sur un échantillon hors échantillon (l'échantillon de validation). À un certain point, vous remarquerez qu'il cesse de s'améliorer et commence à empirer, ce qui signifie que votre modèle a atteint sa limite d'apprentissage.

Ouvrir la boîte noire des réseaux de neurones

La meilleure façon d'apprendre à construire un réseau de neurones est d'en construire un. Python offre une multitude d'implémentations possibles pour les réseaux de neurones et l'apprentissage en profondeur. Python a des librairies telles que Theano, qui permet des calculs complexes à un niveau abstrait, et des paquets plus pratiques, tels que Lasagne, qui vous permet de construire des réseaux de neurones, bien qu'il nécessite encore quelques abstractions. Pour cette raison, vous avez besoin de wrappers, comme nolearn, qui est compatible avec scikit-learn, ou Keras, qui peut également encapsuler la librairie TensorFlow publiée par Google qui a le potentiel de remplacer Theano comme une bibliothèque logicielle pour le calcul neuronal.

R fournit des bibliothèques moins compliquées et plus accessibles, telles que nnet, AMORE et neuralnet. Ces brefs exemples dans R montrent comment former à la fois un réseau de classification (sur l'ensemble de données Iris) et un réseau de régression (sur l'ensemble de données de Boston). À partir de la classification, le code suivant charge l'ensemble de données et le divise en ensembles d'apprentissage et de formation:

bibliothèque (neuralnet)

target <- modèle. matrice (~ Espèces & # x00A0; - 1, données = iris)

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

ensemble. seed (101)

index <- échantillon (1: nrow (iris), 100)

train_predictors <- iris [index, 1: 4]

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

Parce que les réseaux de neurones dépendent de la descente du gradient, vous devez standardiser ou normaliser les entrées. La normalisation est meilleure pour que le minimum soit zéro et le maximum est un pour chaque caractéristique. Naturellement, vous apprenez comment effectuer la conversion numérique à l'aide du jeu d'apprentissage uniquement afin d'éviter toute possibilité d'utilisation des informations issues du test hors échantillon.

min_vector <- appliquer (train_predictors, 2, min)

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

appliquer (train_predictors, 2, min)

train_scaled <- cbind (échelle (train_predictors,

min_vector, range_vector),

cible [index,])

test_scaled <- cbind (échelle (test_predictors,

min_vector, range_vector),

cible [-index,]) < summary (train_scaled)

Lorsque l'ensemble d'apprentissage est prêt, vous pouvez apprendre au modèle à deviner trois variables binaires, chacune représentant une classe. La sortie est une valeur pour chaque classe proportionnelle à sa probabilité d'être la vraie classe. Vous choisissez une prédiction en prenant la valeur la plus élevée. Vous pouvez également visualiser le réseau en utilisant le tracé interne et ainsi voir l'architecture du réseau neuronal et les poids assignés.

réglé. graine (102)

nn_iris <- neuralnet (setosa + versicolor + virginica ~

Sepal.) Longueur + Sepal Largeur

+ Pétale Longueur + Pétale Largeur,

data = train_scaled, hidden = c (2),

linear sortie = F)

plot (nn_iris)

prédictions <- calculer (nn_iris, test_scaled [1: 4])

y_predicted <- appliquer (prédictions $ net. result, 1, qui.max)

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

confusion_matrix <- table (y_true, y_predicted)

précision <- sum (diag (confusion_matrix)) /

sum (confusion_matrix)

print (confusion_matrix)

print (coller ("Précision:", précision))

Vous pouvez tracer un réseau neuronal entraîné.

L'exemple suivant montre comment prévoir les valeurs d'une maison à Boston, en utilisant l'ensemble de données de Boston. La procédure est la même que dans la classification précédente, mais ici vous avez une seule unité de sortie. Le code trace également les résultats prédits de l'ensemble de test par rapport aux valeurs réelles pour vérifier le bon ajustement du modèle.

no_examples <- nrow (Boston)

caractéristiques <- colnames (Boston)

définies. seed (101)

index <- échantillon (1: no_examples, 400)

train <- boston [index,]

test <- boston [-index,]

min_vector <- appliquer (former, 2, min)

range_vector <- appliquer (train, 2, max) - appliquer (train, 2, min)

scaled_train <- échelle (train, min_vector, range_vector)

scale_test <- scale (test, min_vector, range_vector)

formule = coller ("medv ~", coller (caractéristiques [1: 13],

réduire = & apos; + & apos;))