Les cours de fastai – Deep Learning for Coders, sont parmi les plus intéressants (les meilleurs à notre avis) disponibles gratuitement sur le Web. L’approche pédagogique qui consiste à apprendre le DL en codant est très efficiente.

Les cours de fastai concernent le Machine Learning et le Deep Learning. Cet article est un ensemble de notes sur la leçon #1 : What’s your pet. Le code, sur (Google Colaboratory Platform) GCP est disponible ici et sur Github ici.

Magic

Le code commence par des Magic commands.

%reload_extReload an IPython extension by its module name.

autoreload reloads modules automatically before entering the execution of code typed at the IPython prompt.

C’est rarement utile. Mais on ne sait jamais. 

Quant à Reload %autoreload 2, « it Reloads all modules (except those excluded by %aimport) every time before executing the Python code typed ».

Import fastai

Les librairies fastai sont importées (au dessus de PyTorch).

fastai.vision est la librairie qui s’occupe de la vision (traitement d’images) et fastai.metrics est une bibliothèque de métriques (par exemple RMSE, recall, …)

Données

Le jeu de données sur lequel est appliqué ici un réseau de neurones est The Oxford-IIIT Pet Dataset, un fichier de photos de chiens répartis en 25 catégories et chats répartis en 12 catégories. Chaque catégorie a environ 200 images. Le but de l’application est de deviner à quelle catégorie (parmi les 37) appartient l’animal dont on a la photo.

Obtention des données

fastai utilise les contantes suivantes :

pour initialiser path (en décompressant le fichier de données)

untar_data(url:str, fname:Union[pathlib.Path, str]=None, dest:Union[pathlib.Path, str]=None, data=True, force_download=False) -> pathlib.Path Download url to fname if it doesn’t exist, and un-tgz to folder dest.

Ce qui donne :

On initialise ensuite 2 variables :

note : c’est Python 3 qui permet d’utiliser cette syntaxe novatrice.

Consultation des données

Pour voir les noms des 5 premiers fichiers (images) :

Comme on peut le voir, l’étiquette (la catégorie) est indiquée par le nom du fichier.

expression régulière

Pour calculer la catégorie de l’image dont on connait le nom du fichier, on utilise une expression régulière (pat). Celle-ci dit, prendre ce qui est entre un / et un _ suivi de chiffres et .jpg.

Databunch

fastai utilise la notion de databunch. Le data bunch contient les images (training, validation, test) ainsi que les labels.

Le databunch est créé à partir d’images, stockées dans path_img, dont le nom est fnames, dont les catégories sont calculées grâce à l’expression régulière pat. On applique la transformation get_transforms() aux images et on les retaille en carrés de 224px.

Les images sont ensuite normalisées (moyenne, écart-type) pour qu’elles correspondent à Imagenet.

Create from list of fnames in path with re expression pat

https://docs.fast.ai/vision.data.html#ImageDataBunch.from_name_re

Add normalize transform using stats (defaults to DataBunch.batch_stats)
In the fast.ai library we have imagenet_statscifar_stats and mnist_stats so we can add normalization easily with any of these datasets. Let’s see an example with our dataset of choice: MNIST.

https://docs.fast.ai/vision.data.html#ImageDataBunch.from_name_re

note : il faut que les images aient la même taille (d’où le size=224)

consultation

Affichage de quelques images :

Classes et nombre de classes :

Apprentissage

fastai propose le concept de learner et plus particulièrement ici celui de cnn_learner qui crée un réseau de neurones à convolutions.

En l’occurence, les données sont ici : data et le modèle, l’architecture : resnet34. fastai propose aussi un resnet50. La metrics est ici une information qu’on affiche, le error_rate.

Lorsqu’on exécute cette instruction, le poids du réseau sont téléchargés. Ces poids ont été calculés sur ImageNet un ensemble de 14 197 122 images réparties en 1000 catégories.

Si on affiche le modèle :

on obtient :

fit

Une fois l’architecture décrite, on commence l’apprentissage :

Le paramètre (4) indique le nombre de fois qu’on parcourt l’ensemble du dataset.

Le taux d’erreur, après 4 epochs, est 6% (en 2012, les meilleurs résultats étaient de 43% d’erreur). Le progrès est phénoménal !

On sauvegarde le modèle :

Résultats

On commence par obtenir une interprétation des résultats (interp). losses nous informe sur les pertes et idxs sur les numéros des images concernées.

On peut visualiser les images les plus mal classées (erreurs importantes) :

La matrice de confusion croise les erreurs.

Amélioration (fine tuning)

unfreeze

Lorsqu’on unfreeze notre modèle on impose que l’apprentissage se fasse sur la totalité du modèle (et pas seulement sur les dernières couches du modèle).

Puis on fait tourner le modèle sur un cycle.

L’erreur :

est pire qu’avant ! donc on oublie ce modèle et on repart avec le précédent.

et on applique le learning rate finder :

On affiche la courbe

On peut ensuite demander un apprentissage qui unfreeze le modèle et l’entraîne avec un learning rate compris dans l’intervalle 1e-6,1e-4 réparti linéairement entre les couches

Les résultats sont alors :

Encore mieux

On peut faire mieux en utilisant Resnet50. Dans ce cas, l’erreur n’est plus que de 4% !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *