
Les réseaux de neurones utilisent principalement la mémoire de deux façons :
Quand ils stockent les poids du modèle (c'est une utilisation mémoire fixe).
Quand ils sont entraînés (c'est dynamique). Cela se produit de deux façons :
Pendant le forward pass, lors du calcul et du stockage des activations de toutes les couches.
Pendant le backward pass, lors du calcul des gradients à chaque couche.
Cette seconde catégorie, l'utilisation mémoire dynamique, nous empêche souvent d'entraîner des modèles plus grands avec des batch sizes plus élevés.

C'est parce que l'utilisation mémoire évolue proportionnellement à la taille du batch.
Cela dit, il existe une technique assez incroyable qui permet d'augmenter la batch size tout en maintenant l'utilisation mémoire globale.
Elle s'appelle le Gradient checkpointing, et d'après mon expérience, c'est une technique largement sous-estimée pour réduire la surcharge mémoire des réseaux de neurones.
Voyons ça plus en détail.
Comment fonctionne le gradient checkpointing ?
Le gradient checkpointing repose sur deux observations clés sur le fonctionnement typique des réseaux de neurones :
Les activations d'une couche spécifique peuvent être calculées uniquement à partir des activations de la couche précédente. Par exemple, dans l'image ci-dessous, les activations de la "Couche B" peuvent être calculées uniquement à partir des activations de la "Couche A" :

Forward pass
La mise à jour des poids d'une couche dépend uniquement de deux choses :
Les activations de cette couche.
Les gradients calculés dans la couche suivante (à droite), ou plutôt les gradients en cours (running gradients).

Backward pass
Le gradient checkpointing exploite ces deux observations pour optimiser l'utilisation mémoire.
Voici comment ça fonctionne :
Étape 1) Diviser le réseau en segments avant le forward pass :

Étape 2) Pendant le forward pass, ne stocker que les activations de la première couche de chaque segment. Le reste est supprimé une fois qu'il a servi à calculer les activations de la couche suivante.

Étape 3) Vient ensuite la rétropropagation (backpropagation). Pour mettre à jour les poids d'une couche, on a besoin de ses activations. On recalcule donc ces activations à partir de la première couche de ce segment.
Par exemple, comme le montre l'image ci-dessous, pour mettre à jour les poids des couches rouges, on recalcule leurs activations à partir des activations de la couche cyan, déjà disponibles en mémoire.

Voilà !
C'est ainsi que fonctionne le gradient checkpointing.
Pour résumer, l'idée est qu'on n'a pas besoin de stocker toutes les activations intermédiaires en mémoire.
À la place, en stocker quelques-unes et recalculer le reste uniquement quand c'est nécessaire permet de réduire significativement les besoins en mémoire.
Et cette idée est assez intuitive.
En fait, cela permet aussi d'entraîner le réseau sur des batches de données plus grands.
D'après ce que j'ai pu observer, le gradient checkpointing (GCP) permet généralement de réduire l'utilisation mémoire d'au moins 50 à 60 %, ce qui est énorme.

Bien sûr, comme certaines activations sont calculées deux fois, cela se fait au prix d'un temps d'exécution accru, généralement entre 15 et 25 %.
Il y a donc toujours un compromis entre mémoire et temps d'exécution.

Cela dit, un autre avantage est que ça permet d'utiliser une batch size plus grande, ce qui peut légèrement (mais pas totalement) compenser cette augmentation du temps d'exécution.
Malgré tout, le gradient checkpointing reste une technique extrêmement puissante pour entraîner des modèles plus grands. Je l'ai trouvée vraiment utile à plusieurs reprises, sans avoir à recourir à des techniques plus lourdes comme le distributed training, par exemple.
Heureusement, le gradient checkpointing est aussi implémenté par de nombreux frameworks de deep learning open source comme PyTorch, entre autres.
Le gradient checkpointing avec PyTorch
Pour l'utiliser, on commence par importer les bibliothèques et fonctions nécessaires :

Ensuite, on définit notre réseau de neurones :

Comme montré ci-dessus, dans la méthode forward, on utilise la méthode checkpoint_sequential pour appliquer le gradient checkpointing et diviser le réseau en deux segments.
Ensuite, on peut entraîner le réseau normalement, comme d'habitude.
Plutôt simple, non ?
Envie d'aller plus loin ? DataXp t'attend : formations et parcours pour progresser en data science, machine learning et IA.
👉 À toi de jouer : quelles sont tes techniques préférées pour optimiser l'entraînement d'un réseau de neurones ?

