keras : deep learning en R

Vous le savez désormais, le machine learning est un sous‑domaine de l’informatique. Le deep learning est, lui, un sous‑domaine du machine learning : un ensemble d’algorithmes inspirés par la structure et le fonctionnement du cerveau, que l’on regroupe sous le terme de réseaux de neurones artificiels (ANN). Le deep learning est aujourd’hui l’une des tendances majeures en machine learning et excelle sur de nombreux problèmes comme la robotique, la reconnaissance d’images et l’intelligence artificielle (IA).

Le tutoriel du jour vous propose une brève introduction au deep learning en R avec Keras via le package keras :

# Charger le package keras
library(keras)

# Installer TensorFlow
install_tensorflow()

Charger les données

Maintenant que l’installation est claire et votre environnement prêt, vous pouvez charger vos données ! Trois grandes options s’offrent à vous : utiliser un jeu de données intégré au package keras, charger votre propre jeu (par exemple depuis des fichiers CSV) ou générer des données factices.

Quelle que soit votre situation, vous verrez que la prise en main est rapide. Cette section passe en revue ces trois options et explique comment charger (ou créer) les données nécessaires pour démarrer !

# Lire les données MNIST
mnist <- dataset_mnist()

# Lire les données CIFAR10
cifar10 <- dataset_cifar10()

# Lire les données IMDB
imdb <- dataset_imdb()

Exploration des données

Pour ce tutoriel, vous continuez avec le célèbre jeu iris importé via read.csv().

Un peu de contexte biologique si nécessaire : toutes les fleurs possèdent sépales et pétales. Le sépale entoure les pétales, est généralement vert et foliacé ; les pétales sont des « feuilles » colorées. Pour l’iris, c’est un peu différent, comme sur l’image suivante :

Vous avez peut‑être remarqué que le data frame iris n’avait pas de noms de colonnes après l’import. Ce n’est pas crucial pour la suite : même si read.csv() renvoie un data.frame, la fonction fit() attend une matrice ou un tableau (array).

À retenir concernant ces structures : - Les matrices et les arrays n’ont pas de noms de colonnes ; - Les matrices sont des objets 2D d’un seul type ; - Les arrays sont des objets multi‑dimensionnels d’un seul type.

Astuce : besoin d’un rappel sur les structures de données en R ? Voyez cette vidéo.

Le data frame, lui, est une liste nommée particulière dont tous les éléments ont la même longueur. C’est un objet multi‑dimensionnel pouvant contenir plusieurs types. Vous l’avez constaté en inspectant iris. Sachant que vous devez tendre vers un objet 2D/multi‑dimensionnel d’un seul type, prévoyez un peu de prétraitement avant de construire votre réseau.

Pour l’exploration, des noms de colonnes restent pratiques et facilitent la compréhension : ajoutons‑en via names(). Vous pouvez alors l’explorer. Par exemple, visualisez la corrélation entre la longueur et la largeur des pétales avec plot().

Notez l’usage de unclass() pour convertir les noms des espèces (« setosa, versicolor, virginica ») en 1, 2 et 3.

Examinez le résultat du graphique :

Le graphique suggère une corrélation positive entre Petal.Length et Petal.Width selon les espèces. Testez‑le avec cor(), qui calcule la corrélation globale entre tous les attributs du jeu de données :

Vous pouvez aussi utiliser le package corrplot avec cor() pour visualiser les corrélations entre attributs : calculez la matrice de corrélation globale, stockez‑la dans M, puis passez‑la à corrplot().

N’oubliez pas de préciser l’argument method pour définir le rendu souhaité.

Expérimentez avec la méthode de visualisation dans l’extrait ci‑dessous :

Servez‑vous de la console R pour approfondir l’exploration.

Pour des graphiques avec ggvis (grammaire graphique interactive), consultez le tutoriel Machine Learning in R For Beginners ou suivez le cours ggvis de DataCamp.

Prétraitement des données

Avant de construire votre modèle, assurez‑vous que vos données sont propres, normalisées (si nécessaire) et séparées en ensembles d’entraînement et de test. Comme le jeu provient de l’UCI Repository, il est déjà plutôt propre, mais vérifions tout de même sa qualité.

À première vue (head()), rien d’étrange, n’est‑ce pas ? Utilisons summary() et str() pour résumer ce que vous avez observé lors du contrôle d’import :

La normalisation est‑elle nécessaire ?

x_train <- imdb$train$x
y_train <- imdb$train$y
x_test <- imdb$test$x
y_test <- imdb$test$y

Construire le modèle

Commencez par initialiser un modèle séquentiel avec keras_model_sequential(). Vous pouvez ensuite empiler vos couches.

Au préalable, rappelez‑vous la question : peut‑on prédire l’espèce d’un iris ? Vous avez préparé des données numériques et one‑hot encodé la cible : la fleur est versicolor, setosa ou virginica, ce qui est représenté par des 0/1.

Un perceptron multicouche fonctionne bien sur ce type de problème. Il s’agit d’un réseau souvent entièrement connecté. Vous allez donc construire une pile de couches denses relativement simple. Côté fonctions d’activation, pour se familiariser avec Keras, utilisez relu dans la couche cachée, ce qui est une bonne pratique générale.

Dans la couche de sortie, utilisez softmax pour obtenir des probabilités normalisées entre 0 et 1 :

La couche de sortie crée 3 valeurs (une par classe : versicolor, virginica, setosa). La première couche a un input_shape de 4, car iris.training comporte 4 colonnes.

Vous pouvez inspecter le modèle avec :

• summary() pour un récapitulatif ;
• get_config() pour la configuration du modèle ;
• get_layer() pour la configuration d’une couche ;
• l’attribut layers pour la liste à plat des couches ;
• l’attribut inputs pour les tenseurs d’entrée ;
• et outputs pour les tenseurs de sortie.

Compiler et entraîner le modèle

Une fois l’architecture définie, compilez et entraînez le modèle. Pour la compilation, utilisez l’optimiseur adam et la fonction de perte categorical_crossentropy. Suivez aussi la métrique 'accuracy' pendant l’entraînement via l’argument metrics.

L’optimiseur et la perte sont requis pour compiler le modèle.

Parmi les algorithmes d’optimisation populaires : descente de gradient stochastique (SGD), Adam, RMSprop. Selon l’algorithme, vous ajusterez certains paramètres (taux d’apprentissage, momentum…). Le choix de la perte dépend de la tâche : pour une régression, on utilise souvent l’erreur quadratique moyenne (MSE).

Ici, vous utilisez categorical_crossentropy pour une classification multiclasse (versicolor/virginica/setosa). Pour une classification binaire, vous utiliseriez binary_crossentropy.

Ensuite, entraînez le modèle : 200 époques (parcours complets du jeu d’entraînement iris.training/iris.trainLabels) avec des lots (batches) de 5 échantillons.

Astuce : vous pouvez aussi fixer verbose=1 dans fit() pour afficher une barre de progression.

Vous entraînez le modèle sur un nombre d’époques donné (un passage complet sur l’ensemble d’entraînement), avec un batch_size définissant le nombre d’échantillons propagés simultanément. Cela améliore l’efficacité en limitant la charge mémoire.

Visualiser l’historique d’entraînement

Vous pouvez visualiser l’entraînement en stockant le retour de fit() dans une variable, puis en la passant à plot(), comme ci‑dessous.

Étudiez le graphique en détail.

À première vue, c’est un peu confus. De quoi s’agit‑il ?

loss et acc décrivent respectivement la perte et la précision sur l’entraînement ; val_loss et val_acc les mêmes métriques sur la validation.

Pour faciliter l’interprétation, séparez ces deux tracés : un pour la perte, l’autre pour la précision. Utilisez l’opérateur $ pour accéder pas à pas aux séries à tracer.

Exemple dans la boîte DataCamp ci‑dessous :

Ici, vous tracez la perte sur entraînement et test. Faites de même pour la précision :

À garder en tête :

• Si la précision sur l’entraînement continue de monter mais que celle de validation baisse, vous sur‑adaptez (overfitting) : le modèle mémorise au lieu d’apprendre.
• Si la précision sur les deux ensembles augmente encore sur les dernières époques, le modèle n’a pas encore sur‑appris.

Prédire les labels de nouvelles données

Votre modèle est créé, compilé et entraîné. Utilisez‑le pour prédire les classes du jeu de test iris.test avec predict(), puis affichez la matrice de confusion pour comparer prédictions et vrais labels via table().

Que pensez‑vous des résultats ? À première vue, le modèle se trompe‑t‑il souvent ?

Évaluer votre modèle

Même si la matrice de confusion donne un aperçu des performances, évaluez formellement le modèle avec evaluate() : passez les données de test iris.test, les labels iris.testLabels et un batch_size. Stockez le résultat dans score, comme ci‑dessous :

En imprimant score, vous obtenez la valeur de perte et la valeur de la métrique (ici 'accuracy').

Ajuster finement votre modèle

Le réglage fin est une étape fréquente, surtout au début, car toutes les tâches de classification/régression ne sont pas aussi simples que notre exemple. Deux décisions clés reviennent souvent : le nombre de couches et le nombre d’unités cachées par couche.

Au début, c’est un vrai parcours d’exploration.

Outre le nombre d’époques et la taille de batch, vous pouvez : ajouter des couches, augmenter le nombre d’unités cachées et passer des paramètres d’optimisation personnalisés à compile().