Deep Learning : définition, architectures et fonctionnement

Le deep learning entraîne des réseaux de neurones composés de nombreuses couches. Les premières couches détectent des motifs simples, les suivantes les combinent en motifs plus complexes : pour une photo, des contours, puis des textures, puis des formes, puis des objets entiers. Le réseau construit lui-même cette hiérarchie de représentations à partir des données brutes, là où le machine learning classique s'appuie sur des variables préparées à la main.

Les idées sont anciennes. Le perceptron date de la fin des années 1950, et l'algorithme de rétropropagation qui permet d'entraîner des réseaux multicouches est popularisé en 1986. À la fin des années 1980, Yann LeCun applique les réseaux convolutifs à la lecture de chiffres manuscrits. Mais faute de données et de puissance de calcul, ces réseaux restent longtemps marginaux. Le basculement a lieu en 2012 : le réseau AlexNet, entraîné sur des GPU, remporte le concours de reconnaissance d'images ImageNet avec une avance considérable. Geoffrey Hinton, Yann LeCun et Yoshua Bengio reçoivent le prix Turing 2018 pour leurs travaux fondateurs.

Le deep learning est une sous-famille du machine learning, lui-même branche de l'intelligence artificielle, et c'est sur lui que reposent tous les modèles de l'IA générative. Il partage avec le machine learning classique le principe d'apprentissage à partir d'exemples ; il s'en distingue par la nature du modèle, sa capacité à traiter des données non structurées et ses besoins en données et en calcul.

À retenir : un modèle de deep learning apprend à la fois les caractéristiques pertinentes et la décision. C'est ce qui le rend si performant sur l'image, le son et le texte, et si gourmand en données.

Une architecture désigne la façon dont les couches sont organisées et connectées. Chacune exploite une structure particulière des données.

Les réseaux convolutifs (CNN)

Les CNN appliquent de petits filtres qui glissent sur l'image et détectent des motifs locaux, quelle que soit leur position. Ils ont longtemps dominé la vision par ordinateur : classification, détection d'objets, segmentation. Notre article Réseaux convolutifs (CNN) : comment ça marche ? détaille leur fonctionnement.

Les réseaux récurrents (RNN)

Les RNN traitent les séquences élément par élément en conservant une mémoire de ce qu'ils ont déjà vu. Leurs variantes LSTM, proposées en 1997, et GRU ont longtemps servi à la traduction, à la reconnaissance vocale et aux séries temporelles. Leur traitement séquentiel limite toutefois la parallélisation et la prise en compte de longues dépendances (voir notre article sur les RNN).

Les Transformers

Publiée en 2017, l'architecture Transformer remplace la récurrence par un mécanisme d'attention qui met en relation tous les éléments d'une séquence en parallèle. Elle s'entraîne efficacement sur GPU et passe très bien à l'échelle. Elle équipe aujourd'hui les grands modèles de langage et s'est étendue à l'image, à l'audio et aux modèles multimodaux.

Les architectures génératives

Les auto-encodeurs, les GAN et les modèles de diffusion apprennent la distribution des données pour en produire de nouvelles. Ils sont au cœur de l'IA générative, qui fait l'objet de sa propre fiche.

Ce réseau apprend à reconnaître des chiffres manuscrits sur le jeu de données MNIST (70 000 images de 28 × 28 pixels). Le code reprend exactement la boucle d'apprentissage décrite plus haut.

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

device = "cuda" if torch.cuda.is_available() else "cpu"

train_data = datasets.MNIST(
    "data", train=True, download=True, transform=transforms.ToTensor()
)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)

model = nn.Sequential(
    nn.Flatten(),
    nn.Linear(28 * 28, 256),
    nn.ReLU(),
    nn.Linear(256, 128),
    nn.ReLU(),
    nn.Linear(128, 10),
).to(device)

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    model.train()
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        logits = model(images)            # propagation avant
        loss = loss_fn(logits, labels)    # mesure de l'erreur
        optimizer.zero_grad()
        loss.backward()                   # rétropropagation du gradient
        optimizer.step()                  # mise à jour des poids
    print(f"Époque {epoch + 1} : perte {loss.item():.4f}")

Le modèle empile trois couches linéaires séparées par des activations ReLU, soit environ 235 000 paramètres. Après quelques époques, il reconnaît la grande majorité des chiffres du jeu de test. Remplacer ces couches denses par des couches convolutives (nn.Conv2d) améliore encore la précision, car le réseau exploite alors la structure spatiale de l'image.

La ligne device = "cuda" illustre le rôle du matériel. L'entraînement consiste essentiellement en multiplications de matrices, que les GPU exécutent massivement en parallèle grâce à des plateformes comme CUDA. Sur un modèle de cette taille, la différence reste modeste ; sur un réseau de vision ou un modèle de langage, elle se compte en jours, voire en semaines de calcul.

Le deep learning fait partie du machine learning, mais on oppose souvent les réseaux profonds aux modèles dits classiques (régressions, arbres de décision, forêts aléatoires, boosting).

Dans la pratique, le choix se fait d'abord selon les données. Pour prédire un risque de résiliation à partir d'un tableau de clients, un modèle de gradient boosting est souvent plus précis, plus rapide et plus simple à expliquer. Pour analyser des photos, des enregistrements ou des documents en texte libre, le deep learning est presque toujours la bonne option, le plus souvent en adaptant un modèle pré-entraîné.