Réseaux de neurones : des perceptrons au deep learning

Le 10 mars 2016, lors de la deuxième partie d'une série de cinq matches à Séoul, une machine appelée AlphaGo a posé une pierre noire sur la cinquième ligne du plateau. Le coup était si étrange que les commentateurs humains ont supposé qu'il s'agissait d'une erreur. Un professionnel a déclaré à voix haute qu'un débutant se serait fait réprimander pour l'avoir joué. Lee Sedol — champion du monde à 18 reprises au jeu de go — s'est levé et a quitté la salle pour se recomposer.

Ce n'était pas une erreur. Cinquante coups plus tard, cette pierre — désormais célèbre sous le nom de « coup 37 » — était le pivot sur lequel toute la partie a tourné. AlphaGo a gagné. Lee Sedol, considéré comme l'un des plus grands joueurs vivants, a perdu la série 4-1. Et voici la partie qui compte : aucun humain n'a enseigné ce coup à AlphaGo. Il n'était dans aucun manuel. La machine l'avait découvert par elle-même, en jouant des millions de parties contre elle-même et en ajustant des milliards de petits nombres internes jusqu'à ce qu'émerge un schéma que personne n'avait jamais vu.

Le go a plus de positions de plateau possibles qu'il n'y a d'atomes dans l'univers observable. On ne peut pas le résoudre par force brute. On ne peut pas y écrire des règles. La seule façon de le jouer à un niveau surhumain est de l'apprendre — et ce qui faisait l'apprentissage était un réseau de neurones : un empilement d'unités mathématiques simples qui, avec assez de données et d'ajustement, peuvent trouver une structure qu'aucun humain ne peut totalement articuler.

Cette même machinerie — les mêmes sommes pondérées, la même boucle d'entraînement, les mêmes ajustements de gradient — est ce qui alimente le modèle de langage à qui vous parlez, le système qui signale les transactions par carte frauduleuses, et les modèles que les fonds quantitatifs pointent désormais vers les marchés financiers. Cette leçon porte sur ce qui se passe réellement à l'intérieur de cette boîte.

Chaque réseau de neurones — d'un simple filtre anti-spam à GPT en passant par AlphaGo — descend d'une seule idée : le perceptron, inventé par Frank Rosenblatt en 1958. C'est un modèle mathématique vaguement inspiré d'un neurone biologique. Un vrai neurone reçoit des signaux électriques par ses dendrites, les accumule dans le corps cellulaire, et n'émet un signal le long de son axone que si l'entrée combinée franchit un seuil. Le perceptron fait la même chose, simplement avec des nombres au lieu de tension électrique.

Un perceptron prend un vecteur d'entrées x, multiplie chaque entrée par un poids w appris, additionne les produits, ajoute un terme de biais b qui décale le seuil, et fait passer le résultat par une fonction d'activation. Si le résultat franchit la barre, le neurone « s'active » ; sinon il reste silencieux. Le tout est une expression compacte : sortie = f(w·x + b).

Pensez aux poids comme à des boutons de volume. Chaque entrée arrive avec un certain niveau, et le poids décide à quel point cette entrée compte pour ce neurone en particulier. Un neurone apprenant à repérer un trade frauduleux pourrait monter le poids sur « taille de la transaction relative à l'historique du compte » et baisser le poids sur « heure de la journée ». Apprendre, à la base, n'est rien de plus glamour que de tourner ces boutons vers les bons réglages.

Un seul perceptron a une limite dure : il ne peut séparer des données qu'avec une ligne droite (ou, en dimensions supérieures, un hyperplan plat). Il peut répondre « ce point est-il au-dessus ou en dessous de la ligne ? » mais pas « ce point est-il à l'intérieur de la région courbée ? ». L'exemple historique est le problème XOR — un schéma qu'un seul perceptron ne peut prouvablement pas apprendre, une limitation qui a contribué à geler le financement de l'IA pendant des années dans les années 1970. L'échappatoire est presque absurdement simple avec le recul : empiler de nombreux perceptrons en couches et insérer une activation non linéaire entre elles. Faites cela, et le réseau résultant peut plier, replier et sculpter l'espace en des formes arbitrairement complexes.

Un neurone est un bouton. Un réseau utile en compte des milliers, organisés en couches qui font passer l'information vers l'avant comme une chaîne humaine de seaux.

• Couche d'entrée — où vos variables brutes entrent : les pixels d'une image, les mots d'une phrase, ou pour un modèle de trading, des choses comme le prix, le volume, la volatilité et le déséquilibre du carnet d'ordres.
• Couches cachées — les couches intermédiaires, où se fait le vrai travail. Chaque couche prend les sorties de la précédente et les recombine en nouvelles variables plus abstraites.
• Couche de sortie — la réponse finale : une probabilité, une prévision de prix, une étiquette de classe.

Le mot « profond » dans deep learning signifie simplement de nombreuses couches cachées. Et la profondeur vous achète quelque chose de précis : une hiérarchie de variables. Dans un réseau d'images, la première couche détecte les contours, la suivante assemble les contours en formes, la suivante assemble les formes en objets. Personne n'a programmé « détecteur de contour » ou « détecteur d'œil » — ces concepts émergent de l'entraînement. Le réseau invente son propre vocabulaire intermédiaire.

Il y a un beau résultat théorique ici, le théorème d'approximation universelle : un réseau avec même une seule couche cachée, avec suffisamment de neurones, peut approximer n'importe quelle fonction continue avec une précision arbitraire. En d'autres termes, le bon réseau peut en principe représenter n'importe quel schéma qui existe dans vos données. Le piège — et c'en est un gros — est que « en principe » fait tout le travail. Le théorème promet qu'un tel réseau existe ; il ne dit rien sur le fait de savoir si vous pouvez le trouver, si vous avez assez de données pour le déterminer, ou si le schéma que vous poursuivez est même réel. Dans des domaines à faible signal comme la finance, cet écart entre « représentable » et « apprenable » est exactement là où la plupart des modèles vont mourir.

Voici un fait qui surprend les gens : sans fonctions d'activation, la profondeur ne vaut rien. Si chaque couche était une simple somme pondérée, alors empiler dix couches serait mathématiquement identique à une seule couche — une chaîne d'opérations linéaires s'effondre en une seule opération linéaire. Vous auriez dépensé une fortune en calcul pour construire une ligne droite glorifiée. Les fonctions d'activation sont le pli non linéaire inséré entre les couches qui permet au réseau de se plier, et se plier est ce qui le rend puissant.

Les activations que tout praticien devrait connaître :

• Sigmoïde — σ(x) = 1/(1+e⁻ˣ). Écrase toute entrée dans (0, 1), ce qui se lit naturellement comme une probabilité. Excellente pour une sortie binaire, mais un mauvais choix à l'intérieur des couches cachées : pour de grandes entrées positives ou négatives, la courbe s'aplatit, son gradient tend vers presque zéro, et l'apprentissage s'arrête net — le problème du gradient qui s'évanouit.
• Tanh — sorties dans (−1, 1) et centrée sur zéro, ce qui aide l'optimisation. Sature encore aux extrêmes, mais moins durement que la sigmoïde.
• ReLU — f(x) = max(0, x). Le choix par défaut moderne pour les couches cachées. Elle est risiblement simple, bon marché à calculer, et maintient un gradient sain pour toutes les entrées positives. Son défaut est le « ReLU mourant » : un neurone poussé à toujours produire zéro peut devenir définitivement inerte.
• Leaky ReLU — f(x) = max(0,01x, x). Laisse passer un petit filet de gradient pour les négatifs, ce qui empêche les neurones de mourir.
• GELU — une cousine lisse et probabiliste de ReLU, qui est la norme à l'intérieur des transformers comme BERT et GPT.

Jusqu'ici nous avons un réseau plein de poids. Mais d'où viennent les bonnes valeurs de poids ? Personne ne les tape — il y en a des millions. Elles sont découvertes par une boucle de rétroaction qui est, à la base, un essai-erreur organisé avec le calcul différentiel qui tient la comptabilité.

La première étape est la passe avant : introduisez un exemple, laissez-le circuler à travers les couches, et lisez une prédiction. La deuxième étape consiste à mesurer à quel point cette prédiction était fausse en utilisant une fonction de perte (loss). Pour prédire un nombre (un prix), l'erreur quadratique moyenne fait la moyenne de l'écart au carré entre prédiction et vérité. Pour la classification, l'entropie croisée mesure à quel point les probabilités prédites sont loin de la bonne réponse. Une perte élevée signifie « très faux » ; l'objectif entier de l'entraînement est de faire baisser ce nombre.

La troisième étape est la partie astucieuse : la rétropropagation (backpropagation). En utilisant la règle de dérivation en chaîne du calcul différentiel, l'algorithme remonte de la perte à travers chaque couche et calcule, pour chaque poids individuel, un gradient — la réponse à « si je pousse ce poids-là légèrement vers le haut, l'erreur augmente-t-elle ou diminue-t-elle, et de combien ? » C'est l'astuce qui a dégelé l'hiver de l'IA. La backprop, popularisée dans les années 1980, a rendu possible d'attribuer la responsabilité à travers des millions de poids efficacement plutôt qu'en devinant.

La quatrième étape est la descente de gradient : poussez chaque poids d'un petit pas dans la direction qui réduit la perte, en utilisant la règle w = w − α × ∂L/∂w. Imaginez que vous êtes debout sur une colline brumeuse essayant d'atteindre le fond de la vallée ; vous ne pouvez pas voir le fond, mais vous pouvez sentir de quel côté c'est en descente sous vos pieds, alors vous faites un pas dans cette direction et vous répétez. Le taux d'apprentissage α est la longueur de votre pas, et c'est sans doute le cadran le plus important de tout le système. Trop grand et vous dépassez la vallée en bondissant et rebondissez pour toujours ; trop petit et vous avancez centimètre par centimètre pour l'éternité ou vous vous retrouvez coincé à mi-chemin dans un fossé.

Deux affinements que vous rencontrerez immédiatement. Les mini-lots (mini-batches) : au lieu de mettre à jour après chaque exemple individuel (bruyant) ou seulement après l'ensemble complet des données (lent), vous mettez à jour après un petit lot — typiquement 32 à 256 exemples — ce qui est stable, adapté aux GPU, et le point idéal en pratique. Et Adam : un optimiseur plus intelligent qui donne à chaque poids sa propre longueur de pas adaptative et ajoute de la dynamique (momentum) pour lisser les gradients bruyants. Adam est le choix par défaut sensé pour démarrer presque n'importe quel projet — bien qu'en finance, avec son faible rapport signal/bruit, vous devrez encore régler à la main le taux d'apprentissage, la décroissance des poids, et le point d'arrêt.

Voici le mode de défaillance qui a détruit plus de modèles financiers que tout autre. Un réseau de neurones est un ajusteur de fonction si flexible que, si on lui en donne la chance, il va mémoriser vos données d'entraînement purement et simplement — y compris tout le bruit aléatoire, les anomalies isolées, et les coïncidences qui ne se reproduiront jamais. Il obtient de superbes scores sur les données qu'il a vues et échoue à plat dès qu'il rencontre quoi que ce soit de nouveau. C'est le surapprentissage, et sur les marchés — où le vrai signal est faible et le bruit assourdissant — c'est le résultat par défaut, pas l'exception. Les outils qui le combattent s'appellent la régularisation.

Le dropout est le plus populaire. À chaque étape d'entraînement, chaque neurone a une probabilité p (souvent 0,2-0,5) d'être temporairement désactivé. Forcé de fonctionner même quand des coéquipiers aléatoires continuent de disparaître, le réseau apprend à répartir ses connaissances sur de nombreux neurones plutôt que de tout miser sur quelques-uns fragiles — un effet d'ensemble intégré dans un seul modèle. Au moment de la prédiction, tous les neurones se rallument, mis à l'échelle de façon appropriée.

Les pénalités L1 et L2 ajoutent une taxe sur les grands poids à la perte. La L2 (weight decay) décourage tout poids unique de devenir trop grand, répartissant l'influence de façon uniforme. La L1 est plus tranchante : elle pousse activement les poids inutiles jusqu'à exactement zéro, effectuant une sélection automatique de variables. Dans un jeu de données financier où la plupart de vos cent variables sont du bruit, la L1 peut discrètement trouver la poignée qui porte réellement du signal.

La normalisation par lot (batch normalization) réajuste les sorties de chaque couche à une moyenne et une variance stables, ce qui stabilise l'entraînement et permet d'utiliser des taux d'apprentissage plus élevés. L'arrêt précoce (early stopping) est la garde la plus simple et la plus fiable de toutes : surveillez l'erreur sur un ensemble de validation retenu, et à l'instant où elle commence à remonter alors que l'erreur d'entraînement continue de baisser, arrêtez — ce croisement est le moment exact où le réseau passe de l'apprentissage de schémas à la mémorisation du bruit.

Les réseaux feedforward classiques traitent chaque entrée comme un sac de nombres non structuré. Mais beaucoup de données réelles ont une structure — une image a une disposition spatiale, une série de prix a un ordre temporel — et deux architectures spécialisées exploitent directement cette structure.

Les réseaux de neurones convolutifs (CNN) ont été construits pour les images. Plutôt que de connecter chaque pixel à chaque neurone, un CNN fait glisser de petits filtres sur l'entrée, à la recherche de motifs locaux — un contour ici, une texture là — en réutilisant le même filtre partout. Les couches précoces attrapent les contours ; les couches plus profondes les assemblent en formes et objets. En finance, des chercheurs ont pointé des CNN vers :

• Les images de graphiques en chandeliers — reformulant la lecture de graphique comme une tâche de reconnaissance visuelle de motifs.
• Les cartes thermiques du carnet d'ordres — repérant les déséquilibres offre/demande dans les instantanés de profondeur de marché.
• Les convolutions 1D sur des séquences de prix brutes — apprenant de courts motifs temporels de la même manière qu'un CNN d'image apprend des motifs spatiaux.

Les réseaux de neurones récurrents (RNN) sont construits pour les séquences. Ils traitent un pas de temps à la fois tout en portant un état caché — une mémoire courante — d'un pas au suivant. En théorie, cela les rend idéaux pour les séries temporelles. En pratique, les RNN classiques sont handicapés par le problème du gradient qui s'évanouit sur de longues séquences : le signal d'il y a de nombreux pas se réduit vers zéro sur le chemin du retour, si bien que le réseau oublie simplement le passé distant.

Les réseaux LSTM (Long Short-Term Memory) corrigent cela avec un petit ensemble de portes apprenables — oubli, entrée et sortie — qui décident à chaque pas ce qu'il faut effacer de la mémoire, ce qu'il faut y écrire, et ce qu'il faut en lire. Ce système de portes permet à un LSTM de conserver des informations pertinentes sur des centaines de pas, ce qui explique pourquoi il est devenu un cheval de bataille pour modéliser les séries temporelles financières, où un événement d'hier fait encore bouger le prix d'aujourd'hui.

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

Sur une plateforme comme GaiaEx, où des flux WebSocket diffusent en continu des données de prix et de carnet d'ordres, un LSTM peut ingérer cette séquence naturellement. Cela dit, le domaine a largement évolué : les transformers — l'architecture derrière les modèles de langage modernes — égalent ou surpassent désormais les LSTM sur de nombreuses tâches de séquence en utilisant l'« attention » pour regarder tous les pas de temps à la fois plutôt qu'en les parcourant un par un.

Les réseaux de neurones sont des détecteurs de motifs spectaculaires. Mais une éducation honnête consiste à nommer où ils se cassent — et en trading, ils se cassent de façon coûteuse.

• Ils trouvent des motifs même quand aucun n'existe. Donnez du bruit à un réseau profond et il l'ajustera avec confiance. Les marchés sont largement du bruit, donc c'est à vous de prouver qu'un motif est réel et persistant — pas simplement présent dans les données de l'année dernière.
• Ce sont des boîtes noires. Un modèle peut être précis et pourtant incapable de vous dire pourquoi. Quand il perd soudainement de l'argent, il n'y a souvent aucune explication claire ni de correction évidente. Pour du capital qui porte un risque, « je ne sais pas pourquoi il a fait ça » est un sérieux passif.
• Ils sont voraces et fragiles. Le deep learning brille avec des millions d'exemples propres. L'histoire financière est courte, non stationnaire et bruyante — le régime sur lequel votre modèle a été entraîné peut simplement cesser d'exister, un problème appelé dérive de distribution.
• Ils ne battent pas des modèles plus simples gratuitement. Sur les données tabulaires basées sur des variables, courantes en finance, les arbres à gradient boosté comme XGBoost surpassent fréquemment les réseaux de neurones tout en étant plus rapides à entraîner et plus faciles à interpréter. La complexité est un coût, pas une vertu.
• Ils peuvent être attaqués. De minuscules perturbations délibérées d'une entrée peuvent faire basculer la sortie d'un réseau — un exemple adversarial — ce qui compte partout où un adversaire peut façonner ce que voit votre modèle.

Entraîner des réseaux de neurones est lourd en arithmétique — massivement des multiplications matricielles — et le matériel sur lequel vous exécutez cela change votre vitesse d'itération de « du jour au lendemain » à « le temps d'un café ».

Les GPU sont la norme. Leurs milliers de cœurs exécutent tous la même opération sur des données différentes en même temps, ce qui correspond exactement à la forme des mathématiques des réseaux de neurones. Un modèle qui rampe pendant 8 heures sur un CPU peut finir en 15 minutes sur un GPU moderne. NVIDIA domine : les cartes grand public (une carte de classe RTX) suffisent pour apprendre, tandis que les cartes de centre de données (A100, H100) et les instances cloud gèrent l'entraînement à l'échelle production. Les TPU, les puces personnalisées de Google pour le calcul de tenseurs, excellent sur de très grands modèles via Google Cloud, mais les GPU restent le défaut pratique pour la plupart des praticiens grâce à un support logiciel plus large.

Vous n'avez besoin d'acheter rien pour commencer. Google Colab distribue du temps GPU gratuit qui suffit largement pour apprendre et prototyper ; louez des GPU cloud à la demande à mesure que vos modèles grandissent ; achetez du matériel dédié seulement une fois que vous entraînez quotidiennement et que la facture cloud le justifie.

Un chemin d'apprentissage sensé à partir d'ici :

• Commencez avec un réseau feedforward simple sur quelques variables construites — rapide à entraîner, facile à déboguer, et une référence honnête.
• Essayez un CNN 1D sur des séquences de prix brutes et comparez-le directement à cette référence.
• Construisez un LSTM qui consomme des séquences de données en chandeliers depuis l'API de GaiaEx.
• Étudiez l'attention et les transformers — de plus en plus l'architecture de choix pour les séquences.
• Par-dessus tout, opposez toujours votre modèle profond à une référence de gradient boosting comme XGBoost. Si le réseau de neurones ne peut pas battre le modèle plus simple hors échantillon sur vos données financières tabulaires, expédiez le modèle plus simple et passez à autre chose.

La même boucle qui a trouvé le coup 37 — prédire, mesurer l'erreur, ajuster les poids, répéter — est la boucle qui tourne à l'intérieur de chaque système de cette liste. Comprenez cette boucle et vous comprenez le deep learning ; le reste est de l'architecture et de l'ingénierie construites par-dessus.