Utilisation des Réseaux de Neurones

Au cours de cette démo pratique, vous allez utiliser les réseaux de neurones de PLearn pour faire diverses expériences.

Fin (ou pas) de la démo précédente

Il vous est bien sûr conseillé de finir la démo 6 afin de vous familiariser avec PLearn, mais si vous n'êtes pas très avancé, vous pouvez la laisser pour plus tard (les exercices ci-dessous peuvent être effectués sans problème même si elle n'est pas finie).

Installation des fichiers de la démo

Téléchargez le fichier demo_7.tar.gz et décompressez-le dans un répertoire de travail par tar zxvf demo_7.tar.gz

Les "Deux Lunes"

Le problème de classification des deux lunes est un exemple jouet souvent utilisé pour testé de nouveaux algorithmes (notamment en semi-supervisé, mais ce n'est pas le sujet aujourd'hui).

Visualisez le jeu de données avec pyplot (le fichier d'entraînement est double_moon_train.amat).

Vous allez commencer par entraîner un réseau de neurones sans couche cachée, avec une sortie à deux éléments (la probabilité de chaque classe), la fonction de coût NLL (log-vraisemblance négative), et une fonction de transfert de sortie de type softmax: il s'agit en fait d'un modèle équivalent à la régression logistique. Utilisez pyplot et les scripts nnet.plearn et gradient_optimizer.plearn pour visualiser la surface de décision ainsi apprise. On vous donne ici (pour vous rafraîchir la mémoire) un exemple de ligne de commande qui effectue cette tâche :
pyplot 2d_classif double_moon_train.amat nnet.plearn::optimizer=gradient_optimizer.plearn::nhidden=0::noutputs=2::out_func=softmax::hidden_func=linear::cost_func=NLL::batch_size=0::nstages=1000::start_lr=1e-1

Que se passe-t-il si vous augmentez le nombre de neurones cachés ? Pourquoi ?

Afin de s'affranchir des limitations d'un modèle linéaire, essayez d'autres fonctions de transfert sur la couche cachée (comme sigmoid ou tanh, qui sont les plus populaires). Comment évolue la surface de décision ?

Vous allez maintenant transposer vos observations visuelles dans un cadre plus formel d'apprentissage. Le script tester.plearn décrit un objet de type PTester, qui permet d'effectuer des expériences pour évaluer des algorithmes. Jetez un oeil à ce script, puis tentez des expériences du style :
plearn tester.plearn train=double_moon_train.amat valid=double_moon_valid.amat test=double_moon_test.amat test_func=class_error learner=nnet.plearn::...
en remplaçant "..." par les options choisies pour le réseau de neurones, comme ci-dessus. Notez la présence dans le répertoire test-X (avec X un tag indiquant la date et l'heure de l'expérience) des éléments suivants :

global_stats.pmat contient les statistiques d'erreur de classification sur les trois ensembles test1, test2 et test3, qui sont respectivment les ensembles d'entraînement, de validation et de test (ignorez la première ligne de cette matrice)
split_stats.pmat contient ici les mêmes données, car il n'y a qu'un "split" des données (il y en aurait plus si par exemple on avait fait de la validation croisée)
Split0/final_learner.psave contient le réseau de neurones après apprentissage, que l'on peut recharger par la suite si on en a besoin

Après avoir lancé une commande comme celle ci-dessus, un fichier results_double_moon_train.amat.amat doit être généré: il doit contenir les mêmes statistiques d'erreur de classification que global_stats.pmat. Lancez plusieurs expériences en variant les paramètres, et comparez les erreurs dans results_double_moon_train.amat.amat. Éditez results_double_moon_train.amat.vmat (qui voit les mêmes données, mais peut les trier) et rajoutez la colonne numéro 2 dans l'option sort_columns, de manière à trier par ordre d'erreur de validation croissante. Le modèle qui minimise votre erreur de validation minimise-t-elle aussi l'erreur de test ? (remarque : il y a 100 exemples d'entraînement, 100 exemples de validation et 1000 exemples de test).

Afin que le script pyplot fonctionne, il faut deux sorties (une par classe). Mais la classification binaire se fait souvent plutôt avec une seule sortie (avec la sigmoide en fonction de transfert), en optimisant l'entropie croisée (cross_entropy ou - mieux - stable_cross_entropy). Il faut aussi dans PLearn (au moins pour la version actuellement installée) utiliser la fonction de coût binary_class_error plutôt que class_error. Vérifiez que vous obtenez bien des résultats comparables avec cette nouvelle architecture de réseau.

Vous pouvez jouer avec d'autres options, comme le taux d'apprentissage, le nombre de neurones cachés, le nombre d'époques, le mode "batch" (batch_size=0) ou "stochastique" (batch_size=1), l'algorithme d'optimisation (il y a aussi le gradient conjugué si vous utilisez conjugate_gradient.plearn. Pouvez-vous arriver à 0% d'erreur sur l'ensemble d'entraînement ? Est-il possible de "sur-apprendre" ?

Régression

Les réseaux de neurones peuvent être utilisés en régression : on utilise alors généralement le coût "Mean Squared Error" (mse dans un script PLearn). Afin de visualiser facilement les données, nous allons faire de la régression 1D. Visualisez l'ensemble d'entraînement par :
pyplot plot_2d sinus_train.vmat

Utilisez le mode 1d_regression de pyplot pour visualiser l'apprentissage. Visuellement, parvenez-vous à "sur-apprendre" ? Confirmez-le en mesurant les statistiques avec le script de test tester.plearn.

Classification multi-classes

Utilisez tester.plearn pour obtenir un réseau de neurones qui fonctionne bien sur les données de MNIST (reconnaissance de caractères, fichiers mnist_*.amat). Le meilleur modèle sur l'ensemble de validation vous permet-il de sélectionner un modèle qui généralise effectivement bien ? (bonne erreur en test).