Vous êtes sur la page 1sur 4

IMA208 - TP CNN: Introduction aux réseaux convolutionnels 1

Introduction

Le but de ce TP est de proposer une introduction aux CNN. À la fin du TP vous serez
capables de mieux comprendre les concepts de base des CNN. Vous allez manipuler des réseau.
Vous verrez comment un réseau est entraîné de manière supervisée. Cet entraînement se fera sur
un réseau de taille modeste. Vous pourrez analyser la qualité des résultats obtenus.

Ensuite, vous utiliserez un réseau de grande taille (VGG16) pour effectuer des tâches différente
de celle pour laquelle il a été entraîné. Vous générerez des images de type "deep dream". Le but
de cette partie est de vous familiariser avec l’utilisation détournée de réseau de grande taille.

Dans ce TP nous n’abordons pas des questions fondamentales telles que le choix de l’archi-
tecture du réseau, le choix de la méthode d’apprentissage. Le but, est de vous donner les outils
pour que vous puissiez par la suite comprendre les articles de recherche qui utilisent les CNN et
avoir une idée précise de leur applicabilité pour la tâche que vous souhaitez accomplir.

Mise en place informatique

Le TP utilise python (anaconda3) et le module de réseaux de neurones tensorflow. Il est


développé par Google et a l’avantage d’être grandement optimisé pour beaucoup d’architectures.
Son autre avantage est que l’utilisation ou non de la GPU est transparente et ne demande pas
de changer le programme pour passer d’une architecture à l’autre.

Pour gagner du temps et de l’espace disque, vous allez utiliser mon installation de tensor-
flow 1 . Pour cela, si vous possédez déjà un répertoire ".conda" il faut changer son nom et créer un
lien symbolique vers mon ".conda". Exécutez les commandes suivantes dans une nouvelle fenêtre
de terminal (la première seulement si vous avez déjà un ".conda" 2 ) :

mv .conda .conda_bak (voir avertissement)


ln -s ~ladjal/.conda .conda
mkdir TP_CNN
cd TP_CNN
cp -r ~ladjal/TP_CNN/exercices .

Ce qui précède ne doit être fait qu’une seule fois. Appelez l’encadrant au moindre problème
d’ordre informatique.

Ensuite, pour lancer l’environment de travail depuis un terminal

export PATH=/cal/softs/anaconda/anaconda3/bin:$PATH
cd TP_CNN/exercices
source activate tf_env
spyder
1. Les instructions sont valables si vous êtes sur des machines de la DSI
2. Dans ce cas pour revenir à votre installation originale il faut faire : cd ; rm .conda ; mv .conda_bak .conda
IMA208 - TP CNN: Introduction aux réseaux convolutionnels 2

Ce TP est centré sur l’analyse de programmes déjà écrits. Vous travaillerez sous spyder
essentiellement en sélectionnant une zone de programme et par clique-droit -> exécuter la cellule.
Cela permet une souplesse d’utilisation et de comprendre le code à mesure que l’on progresse
dans le TP.

1 MNIST : Architecture, apprentissage, visualisation

MNIST est une base de données d’imagettes de chiffres manuscrits. Elle contient beaucoup
d’exemples annotés, le but est de construire un CNN capable des les reconnaitre.

Cette partie nous regardons le programme mnist_deep.py qui se trouve dans le répertoire
mnist. Ouvrez-le dans spyder sans l’exécuter. Ce programme commence par inclure (import)
des modules dont le plus important est tensorflow qui sera dénommé tf. Cela signifie que toute
fonction dont le nom commence par tf. vient du module tensorflow. Exécutez cette partie pour
avoir tensorflow disponible.

Dans tensorflow il y a des variables, des constantes et des operations. Une variable (ou une
constante) est un tableau de nombres qui peuvent varier (pas pour les constantes). Une opération
produit un résultat qui est un tableau de nombres. Une opération combine des opérations ou des
varaiables/constantes (et produira le résultat). Tout cela produit un graph de calcul.

Typiquement, on définit l’architecture du réseau au début du programme (le graphe).

Des variables spéciales appelées placeholder servent à communiquer des valeurs concrètes
pour les insérer dans le graphe de calcul (typiquement des données (images, signaux))

Aucun calcul n’est effectué à moins d’utiliser sess.run ou v.eval. où sess est une session
tensorflow et v une variable tensorflow. Ces deux méthodes prennent en entrée un dictionnaire
qui définit les valeurs concrètes des placeholder (ceux qui sont nécessaires aux calculs demandés 3 .)

Un grand intérêt de tensorflow (comme d ?autres systèmes de réseaux de neurones) est qu’il
est capable de calculer des gradients. Ainsi, si on déclare qu’un noeud du graph est la fonction de
coût, il suffit de calculer son gradient par rapport aux variables filtres pour faire évoluer ceux-ci
vers des valeurs permettant au réseau d ?effectuer la tâche à laquelle il est destiné.

Vous allez exécuter la suite du fichier en vous arrêtant avant la boucle d’apprentissage. Il est
important de lire les lignes que vous exécutez pour comprendre le fonctionnement. N’hésitez pas
à utiliser la commande python help, par exemple help(tf.nn.conv2d).

1. Que renvoie la fonction conv2d ?


2. Que fait la fonction bias_variable ? Et la fonction weight_variable ?
3. Combien ce réseau a-t-il de paramètre ? (il s’agit du nombre total de valeurs se trouvant
dans des tf.Variable.
4. Dessinez l’architecture du réseau.
3. d’ailleurs, tensorflow ne fait que le minimum de calculs, si vous demandez le résultat d ?une variable qui
se trouve au début du graphe de calcul, il ne calculera que les variables dont elle dépend
IMA208 - TP CNN: Introduction aux réseaux convolutionnels 3

1.1 Apprentissage

Maintenant vous allez exécuter la boucle d’apprentissage. Avant de la lancer, explorez la


variable mnist (charger les données).
1. Combien d’exemple d’entrainement a-t-elle ?
2. Telle qu’écrite combien d’époques la procédure d’apprentissage va-t-elle effectuer ? (la
taille du mini-batch est de 50 exemple) Pouvez-vous donner un ordre de grandeur du
temps que va prendre l’apprentissage ? (vous avez un CPU capable de l’ordre de 101 0
opérations par seconde)
3. Lancez la boucle d’apprentissage, cela va prendre un peu de temps, vous pouvez en profiter
pour lire la suite du programme... et surveiller les pourcentages de réussite affichés pendant
la progression. Ces pourcentages sont-ils significatif ? Pourquoi ?
4. À la fin de l’apprentissage, sauvegardez votre réseau par la fonction fournie. Ainsi vous
pourrez le retrouver plus tard. Quel taille fait le fichier ? Cela est-il compatible avec la
taille que vous aviez calculé durant la construction de réseau ?
Après avoir sauvegardé votre réseau, vous pouvez le tester sur les données de test.

1.2 Evaluation et visualisation

Évaluez la réussite de votre réseau sur les données de test. Choisissez une image particulière
et affichez les différentes réponses des filtres par la fonction fournie.

Exercice Trouver le taux de réussite top-3, c’est-à dire le pourcentage d’images de test pour
lesquels la bonne classe est renvoyée parmi les trois premières réponses du CNN (la variable
probs continent les probabilités de chaque classe d’après le réseau).

2 Deep Dreem

Le but de cette partie est de manipuler un réseau déjà entrainé (et de grande taille) pour
créer des images "hallucinées". La base de la méthode utilisée est de partir d’une image aléatoire
et de la faire évoluer par montée de gradient pour augmenter un certain loss. Le loss sera la
réponse à une couche de réseau.

On regardera le programme deep_dreem.py. La première partie part d’une image de bruit


blanc et la seconde (deep dream proprement dit) part d’une image (par exemple montagne.jpg)
et y rajoute de détails hallucinés. L’idée est que les hallucinations s’intègrent aux objets qui se
trouvent dans l’image.

Vous lancerez les différentes parties de ce programme et répondrez aux questions suivantes
1. Écrire la loss qui optimisée par la ligne
render_naive(layer[:,:,:,channel])

2. que pouvez-vous dire du paramètre de vitesse d’apprentissage (learning rate).


3. Faire varier layer et channel et dire ce que vous remarquez sur les différentes images
construites.
IMA208 - TP CNN: Introduction aux réseaux convolutionnels 4

4. À quoi sert la variable conv_only ? (on pourra regarder le fichier lecture_vgg.py)


5. Décrire synthétiquement comment fonctionne render_dream.
6. Faire varier ses paramètres et commenter les résultats. (Si les calculs sont trop long changez
de paramètres, vous avez un exemple obtenu dans le répertoire de travail)

3 Exemples adverses

Dans cette partie on utilise le programme trompe_vgg16.py. Il illustre une propriété très
étrange des classifieurs basés sur des CNN.

1. Après exécution du programme, que fait-il ?


2. Quelle loss utilise-t-il ? A-t-il un learning rate ? Que se passe-t-il si vous en utilisez un ?
Quelle la norme typique du gradient ?

Exercice : Reprendre votre programme mnist. Après avoir rechargé le réseau mnist entrainé,
trompez votre réseau de la même manière pour transformer une chiffre bien classifé en un chiffre
mal classifié.