Deep Learning
Comprendre les réseaux de neurones assez bien pour les déboguer à 2 h du matin.
Le deep learning est enseigné à l’envers à peu près partout. Les cours passent huit semaines sur des schémas d’architecture et vingt minutes sur la boucle d’entraînement ; puis les diplômés découvrent que l’architecture est la partie qu’on copie et que la boucle est celle qui gâche le mois. La vérité est peu romantique : la plupart des bugs de réseaux de neurones sont des erreurs de shape, des broadcasts silencieux, un mode évaluation oublié, ou un learning rate faux d’un facteur dix. Votre modèle n’échoue pas par une exception : il échoue en convergeant vers quelque chose de plausible et de faux. Ce parcours est organisé autour de ça. Vous commencez par les tensors et l’autograd, et vous implémentez la backpropagation à la main exactement une fois — non pour la réinventer, mais pour qu’un gradient cesse d’être magique et devienne une arithmétique que vous pourriez vérifier sur papier. Vous couvrez ensuite les architectures qui ont mérité leur place : les convolutions et le biais inductif qui les fait marcher sur les images, puis la route de la récurrence à l’attention, car on ne comprend pas pourquoi les Transformers ont gagné sans comprendre ce qu’ils ont remplacé. La dernière phase est celle où vivent réellement les professionnels : faire converger l’entraînement, régulariser honnêtement, et fine-tuner un modèle pré-entraîné plutôt que de brûler une fortune à entraîner depuis zéro. Presque personne n’entraîne depuis zéro. Presque tout le monde devrait arrêter de prétendre le contraire.
Ce que vous allez apprendre
Prérequis
- Python à l’aise ; savoir déboguer le code d’un autre
- Fondamentaux du machine learning : validation, surapprentissage, métriques
- Bases d’algèbre linéaire — la multiplication matricielle doit être une routine
- Accès à un GPU, même loué, pour les dernières phases
Débouchés
- Ingénieur deep learning
- Ingénieur de recherche
- Ingénieur vision / NLP
- Applied scientist
Phases
Phase 1 — Tensors et gradients
Rendre les gradients ennuyeux. Une fois la backprop devenue de l’arithmétique, le reste du domaine s’ouvre.
Durée estimée · 10-12 semainesLe tensor, la shape et le bug silencieux
Quatre-vingt-dix pour cent du temps où vous serez bloqué la première année, ce seront des erreurs de shape — et les plus cruelles ne lèvent aucune exception : le broadcasting transforme discrètement un (32, 1) face à un (32,) en un (32, 32), votre loss devient une moyenne sur du n’importe quoi, et l’entraînement se déroule tranquillement jusqu’à un modèle inutile. Vous apprendrez à annoter les shapes en écrivant, à vous méfier de toute opération à laquelle vous n’avez pas réfléchi, et à traiter le device et le dtype de chaque tensor comme des faits à vérifier plutôt qu’à supposer.
Sujets couverts
Ce que vous allez construire
- Écrire dix opérations de tensors dont vous prédisez les shapes sur papier d’abord ; consigner chaque erreur de prédiction
- Fabriquer un bug de broadcasting volontaire qui s’entraîne sans erreur, puis écrire l’assertion qui l’attrape
- Profiler la mémoire GPU sur un pas d’entraînement et expliquer d’où vient chaque allocation
La backpropagation, à la main, une fois
Vous devriez implémenter un petit réseau et sa passe arrière depuis zéro exactement une fois dans votre vie, puis plus jamais. L’enjeu n’est pas le code, qui sera moins bon que la librairie. L’enjeu, c’est qu’après ça, un gradient qui s’évanouit cesse d’être une phrase qu’on répète pour devenir une chaîne de multiplications que vous voyez rétrécir. Ceux qui sautent l’étape finissent par copier des rustines sur des forums ; ceux qui la font raisonnent sur une architecture inédite en une après-midi.
Sujets couverts
Ce que vous allez construire
- Implémenter un réseau à deux couches avec passes avant et arrière manuelles en NumPy, et vérifier chaque gradient numériquement
- Reproduire ce réseau NumPy dans un framework et confirmer que les loss coïncident à quatre décimales à seed identique
- Casser volontairement l’initialisation (tout à zéro, puis beaucoup trop grande) et documenter précisément l’allure de chaque échec sur la courbe de loss
Phase 2 — Les architectures qui ont mérité leur place
Comprendre ce que chaque architecture suppose de sa donnée — cette hypothèse, c’est tout le design.
Durée estimée · 12-16 semainesLes convolutions et le biais qui les fait marcher
Un réseau convolutif n’a rien de magique : c’est une croyance codée en dur selon laquelle les pixels voisins sont liés et qu’un chat reste un chat où qu’il se trouve dans le cadre. C’est cette croyance qui permet à un CNN d’exiger bien moins de données qu’un réseau entièrement connecté sur les mêmes images. Apprenez à voir l’architecture comme un ensemble d’hypothèses encodées et vous prédirez où un modèle échouera : un CNN ignore que le haut d’une image est le ciel, ce qui est précisément pourquoi il classera une photo à l’envers avec assurance.
Sujets couverts
Ce que vous allez construire
- Entraîner un petit CNN et un réseau entièrement connecté à nombre de paramètres égal sur les mêmes images ; rapporter l’écart et l’expliquer en termes de biais inductif
- Visualiser le champ réceptif d’un neurone choisi et confirmer qu’il correspond à votre calcul
- Oublier volontairement le mode eval, mesurer la chute d’accuracy due à la batch norm, et noter le symptôme pour le reconnaître plus tard
De la récurrence à l’attention
Vous ne construirez pas de RNN professionnellement, et vous devez quand même les comprendre, car le Transformer est la réponse à une question que la récurrence posait mal. Traiter séquentiellement, c’est exiger qu’une dépendance longue survive à des centaines de multiplications ; elle n’y survit pas. L’attention abandonne totalement la récurrence et laisse chaque position regarder toutes les autres en une étape — d’où la parallélisation, d’où le passage à l’échelle, et d’où le coût mémoire quadratique. Comprenez cet échange et tout le paysage moderne devient lisible au lieu d’être une liste de noms.
Sujets couverts
Ce que vous allez construire
- Implémenter l’attention à une tête depuis zéro et vérifier la sortie contre celle d’un framework sur des entrées identiques
- Entraîner un RNN et un petit Transformer sur la même tâche séquentielle, puis tracer l’accuracy en fonction de la longueur pour montrer où la récurrence s’effondre
- Extraire et visualiser les poids d’attention sur une phrase, et dire honnêtement laquelle de vos interprétations la donnée soutient réellement
Phase 3 — Entraînement et fine-tuning
Faire converger l’entraînement volontairement, puis cesser d’entraîner depuis zéro pour adapter.
Durée estimée · 12-16 semainesLa boucle d’entraînement, c’est le métier
Avant de toucher à un vrai jeu de données, surapprenez un seul batch jusqu’à une loss quasi nulle. Si vous n’y arrivez pas, votre boucle est cassée et aucune architecture ne vous sauvera : le label est décalé, la loss est fausse, ou le gradient n’atteint pas vos poids. Ce seul test attrape plus de bugs que n’importe quelle relecture de code. Ensuite, le learning rate est l’hyperparamètre qui compte, et le reste tient largement du folklore répété par des gens qui n’ont jamais fait l’ablation.
Sujets couverts
Ce que vous allez construire
- Surapprendre un batch unique jusqu’à une loss quasi nulle sur trois tâches différentes ; documenter ce qui était cassé les fois où ça a échoué
- Lancer un learning-rate range test et produire la courbe qui justifie la valeur retenue
- Écrire un script d’entraînement qui reprend correctement depuis un checkpoint en milieu d’epoch et le prouver en tuant le process
Régulariser et fine-tuner ce qui existe déjà
Plus de données bat une meilleure architecture, et l’augmentation est la donnée la moins chère que vous obtiendrez — mais seulement l’augmentation qui préserve le label, raison pour laquelle retourner la photo d’un panneau routier peut détruire discrètement votre modèle. Acceptez ensuite l’économie du domaine : vous n’entraînerez pas un modèle de fondation, vous en adapterez un. Le fine-tuning est une discipline à part entière, avec son échec propre — l’oubli catastrophique, où votre modèle devient excellent sur vos cinq mille exemples et oublie tout ce qui faisait qu’il valait la peine de partir de lui.
Sujets couverts
Ce que vous allez construire
- Fine-tuner un modèle pré-entraîné sur un domaine à vous et battre un modèle from-scratch entraîné dix fois plus longtemps
- Trouver une augmentation qui abîme votre tâche, prouver le dégât par des chiffres, et expliquer pourquoi le label n’y a pas survécu
- Mesurer l’oubli catastrophique : évaluer votre modèle fine-tuné sur la tâche d’origine avant et après, et rapporter la perte
Questions
Ai-je vraiment besoin d’un GPU, ou puis-je apprendre sur un portable ?
La phase un tourne confortablement sur un portable, et c’est très bien ainsi : une machine lente vous oblige à réfléchir avant de lancer, une habitude qui vaut de l’or. À partir de la phase deux, il vous faut de l’accélération, mais vous n’avez presque certainement pas besoin de la posséder. Le calcul loué à l’heure est le défaut raisonnable, et la discipline qu’il impose est une fonctionnalité : quand le compteur tourne, on cesse de lancer des jobs à l’espoir et on se met à lire les courbes de loss. Déboguez toujours sur un tout petit sous-ensemble en local, et n’envoyez un job sur GPU qu’après qu’il se soit correctement entraîné sur dix exemples chez vous.
Vaut-il encore la peine d’apprendre les RNN alors que les Transformers ont gagné ?
Consacrez-leur des jours, pas des mois, et dans une visée diagnostique plutôt que pratique. Le Transformer est une réponse, et une réponse dont on ne sait pas remonter à la question est une anecdote. La récurrence vous fait sentir dans vos tripes ce que coûte une dépendance longue portée, pourquoi les gradients meurent sur de nombreux pas, et pourquoi les LSTM ont greffé des portes pour maintenir un signal en vie. Une fois cela ressenti, l’attention cesse d’être un bloc arbitraire dans un schéma et devient un geste évident. Sautez-les et vous saurez utiliser un Transformer sans savoir raisonner dessus — précisément l’écart qui se voit en entretien et en production.
Mon modèle s’entraîne, la loss descend, mais les résultats sont mauvais. Par où commencer ?
Dans l’ordre, sans rien sauter : regardez de vos propres yeux les entrées réelles que reçoit votre modèle, après chaque transformation — la plupart du temps le bug est visible là et nulle part ailleurs. Vérifiez ensuite que vos labels sont bien alignés sur ces entrées ; un décalage d’un cran dans un data loader s’entraîne parfaitement et ne prédit rien. Essayez ensuite de surapprendre un seul batch : si la loss refuse d’approcher zéro, le problème est mécanique, pas statistique, et aucun réglage ne le corrigera. Ce n’est qu’après ces trois étapes qu’on envisage l’architecture — et à ce stade, en général, ce n’est plus nécessaire. Cet ordre est sans gloire, et c’est lui qui sépare ceux qui livrent des modèles de ceux qui les bricolent six semaines.
Parcours liés
Envie de suivre ce parcours avec un coach et une cohorte ?
Découvrir la 212AY Academy →