Schéma montrant qu'un réseau de neurones utilise la mémoire pour stocker les poids et pour les calculs forward et backward

Les réseaux de neurones utilisent principalement la mémoire de deux façons :

  1. Quand ils stockent les poids du modèle (c'est une utilisation mémoire fixe).

  2. Quand ils sont entraînés (c'est dynamique). Cela se produit de deux façons :

    1. Pendant le forward pass, lors du calcul et du stockage des activations de toutes les couches.

    2. 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.

Illustration comparant une grande batch size, non viable en mémoire, à une batch size petite ou intermédiaire, viable

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 :

  1. 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" :

Schéma d'un réseau de neurones montrant que les activations de la Couche B dépendent uniquement des activations de la Couche A

Forward pass

  1. La mise à jour des poids d'une couche dépend uniquement de deux choses :

    1. Les activations de cette couche.

    2. Les gradients calculés dans la couche suivante (à droite), ou plutôt les gradients en cours (running gradients).

Schéma montrant que la mise à jour de la Couche A dépend de ses activations et des gradients calculés dans la Couche B

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 :

Schéma illustrant la division d'un réseau de neurones en deux segments avant le forward pass, étape clé du gradient checkpointing

É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.

Schéma montrant comment seules les activations de la première couche de chaque segment sont stockées, le reste étant supprimé

É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.

Schéma illustrant le recalcul des activations d'un segment à partir de la couche précédente, uniquement si besoin

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.

Graphique en barres comparant l'utilisation mémoire d'un réseau de neurones sans et avec gradient checkpointing (GCP)

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.

Illustration du compromis entre RAM économisée et temps d'exécution accru avec le gradient checkpointing

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 :

Code Python : import de la fonction checkpoint_sequential depuis torch.utils.checkpoint pour le gradient checkpointing

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

Extrait de code Python définissant un réseau SimpleNet et appliquant checkpoint_sequential dans la méthode forward

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 ?


Commentaires

Avatar

ou participer

À lire ensuite

Des shots dans la même veine, à lire entre deux tâches.

Voir tous les shots
caret-right