MAML : Guide complet — Meta-Learning Agnostique au Modèle

Résumé — MAML (Model-Agnostic Meta-Learning), proposé par Finn, Abbeel et Levine en 2017, est un algorithme de meta-learning qui apprend une initialisation de paramètres capable de s’adapter rapidement à de nouvelles tâches avec très peu d’exemples. Contrairement au transfer learning qui part d’une représentation figée, MAML trouve le point de départ idéal dans l’espace des paramètres pour que quelques pas de gradient suffisent à atteindre de bonnes performances. C’est l’approche fondatrice du « few-shot learning » profond moderne.

Principe mathématique

1. Objectif du Meta-Learning

Le meta-learning résoud le problème suivant : étant donnée une distribution de tâches p(T), trouver une initialisation \theta telle que, après adaptation par gradient descent sur une nouvelle tâche T_i, la performance soit optimale.

2. Inner Loop (Adaptation par Tâche)

Pour chaque tâche T_i échantillonnée, on effectue une ou plusieurs étapes de gradient descent à partir des paramètres meta \theta :

$$
\theta’i = \theta – \alpha · ∇\theta L_{T_i}(\theta)
$$

Où \alpha est le learning rate d’adaptation interne (hyperparamètre fixe).

Pour k steps de gradient :
$$
\theta’i = \theta – \alpha · ∑j ∇\theta L{T_i}(\theta’_i^{(j)})
$$

Les paramètres \theta’_i sont les paramètres adaptés spécifiquement pour la tâche T_i.

3. Outer Loop (Meta-Mise à Jour)

La mise à jour meta évalue la qualité de l’adaptation et ajuste l’initialisation \theta :

$$
\theta ← \theta – \beta · ∇\theta ∑_i L(\theta’_i)
$$

En développant le gradient (chaîne) :

∇\theta L(\theta’i) = ∇\theta L_{T_i}(\theta – \alpha · ∇\theta L(\theta))

Ce gradient est un gradient d’ordre supérieur car il contient des dérivées secondes (hessiennes). MAML les calcule explicitement via la différentiation automatique, sans approximation.

4. First-Order MAML (FOMAML)

Approximation qui ignore les gradients d’ordre supérieurs (hessiennes) pour réduire le coût calcul :

∇\theta L(\theta’i) ≈ ∇\theta’i L(\theta’_i)

En pratique, FOMAML atteint des performances très proches de MAML complet pour un coût bien inférieur.

Intuition

Imaginez deux étudiants qui préparent un examen de mathématiques.

L’étudiant classique (transfer learning) : il apprend par cœur les solutions de tous les exercices du manuel. Quand il tombe sur un exercice nouveau mais similaire, il s’en sort. Mais si l’exercice est différent, il est perdu.

L’étudiant MAML (meta-learning) : il ne mémorise pas les solutions. Il développe une « méthode de résolution » générale — il apprend à analyser un problème, identifier le type d’équation, choisir la bonne formule. Quand il découvre un exercice jamais vu, il applique sa méthode et résout le problème en 5 minutes avec seulement 2 exemples.

C’est toute la différence entre savoir et savoir apprendre. MAML apprend le savoir-apprendre.

Implémentation Python

MAML on Sine Wave (régression few-shot)

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# Réseau simple pour la régression
class SmallNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(1, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, 1)
        )
    def forward(self, x):
        return self.net(x)

# Générer une tâche sinusoidale
def generate_sine_task(amplitude=None, phase=None):
    if amplitude is None:
        amplitude = np.random.uniform(0.1, 5.0)
    if phase is None:
        phase = np.random.uniform(0, np.pi)
    def f(x):
        return amplitude * np.sin(x - phase)
    return f

# Inner loop: adapter les paramètres à une tâche
def inner_step(model, x, y, lr=0.01, inner_steps=2):
    adapted = nn.Sequential(*[layer for layer in model])
    for _ in range(inner_steps):
        pred = adapted(x)
        loss = ((pred - y) ** 2).mean()
        grad = torch.autograd.grad(loss, adapted.parameters(), create_graph=True)
        # Mise à jour manuelle des paramètres (nécessaire pour les gradients d'ordre supérieur)
        with torch.no_grad():
            for param, g in zip(adapted.parameters(), grad):
                param.sub_(lr * g)
    return adapted

# MAML Training
meta_model = SmallNet()
meta_optimizer = optim.Adam(meta_model.parameters(), lr=1e-3)
inner_lr = 0.01
outer_lr = 1e-3
n_tasks = 10
inner_steps = 2

for meta_step in range(10000):
    meta_optimizer.zero_grad()
    meta_loss = 0

    for _ in range(n_tasks):
        task_fn = generate_sine_task()

        # Support set (K=5 exemples pour l'adaptation)
        x_support = torch.rand(5, 1) * 4 - 2
        y_support = torch.tensor(task_fn(x_support.numpy()), dtype=torch.float32).unsqueeze(1)

        # Query set (10 exemples pour l'évaluation)
        x_query = torch.rand(10, 1) * 4 - 2
        y_query = torch.tensor(task_fn(x_query.numpy()), dtype=torch.float32).unsqueeze(1)

        # Inner loop: adaptation
        adapted = inner_step(meta_model, x_support, y_support, lr=inner_lr, inner_steps=inner_steps)

        # Outer loop: évaluer sur le query set
        y_pred = adapted(x_query)
        loss = ((y_pred - y_query) ** 2).mean()
        meta_loss += loss

    meta_loss /= n_tasks
    meta_loss.backward()
    meta_optimizer.step()

    if meta_step % 1000 == 0:
        print(f"Meta step {meta_step} | Meta Loss: {meta_loss.item():.6f}")

Classification Few-Shot (Omniglot 5-way 1-shot)

# Pour la classification, l'inner loop minimise la cross-entropy
# et l'outer loop agrège les performances sur toutes les tâches

def maml_classification_step(meta_model, task_data, inner_lr=0.4):
    x_support, y_support, x_query, y_query = task_data

    # Inner loop: adaptation rapide
    adapted = SmallNet()
    # Copier les poids
    for p_meta, p_adapt in zip(meta_model.parameters(), adapted.parameters()):
        p_adapt.data.copy_(p_meta.data)

    optimizer_inner = optim.SGD(adapted.parameters(), lr=inner_lr)
    for _ in range(1):  # 1-shot = 1 step suffit souvent
        optimizer_inner.zero_grad()
        logits = adapted(x_support)
        loss = nn.CrossEntropyLoss()(logits, y_support)
        loss.backward()
        optimizer_inner.step()

    # Évaler sur le query set
    logits_query = adapted(x_query)
    return nn.CrossEntropyLoss()(logits_query, y_query)

Hyperparamètres

Avantages de MAML

1. Model-agnostic : Fonctionne avec n’importe quelle architecture (MLP, CNN, RNN, Transformers). Pas de modifications spécifiques au réseau.
2. Few-shot impressionnant : S’adapte à une nouvelle tâche avec seulement 1-5 exemples, surpassant les approches supervisées classiques.
3. Double usage : Le même modèle peut servir à la fois pour le meta-learning et pour l’entraînement standard (il converge vers un bon minimum global).
4. Fondateur : MAML a inspiré une famille entière d’algorithmes (Reptile, ANIL, Meta-SGD).

Limites de MAML

1. Coût des gradients d’ordre supérieur : Le calcul des dérivées secondes est coûteux en mémoire et temps. FOMAML résout partiellement ce problème mais perd en précision.
2. Difficile à étendre aux réseaux très profonds : Les gradients d’ordre supérieurs à travers 50+ couches sont instables.
3. Sensible au learning rate interne : Un \alpha mal calibré fait diverger l’adaptation ou la rend inutile.

4 cas d’usage concrets

1. Reconnaissance de caractères nouveaux (Omniglot)

Omniglot contient 1623 caractères de 50 alphabets, chacun dessiné par 20 personnes différentes. MAML est entraîné sur un sous-ensemble d’alphabets, puis testé sur des alphabets jamais vus avec seulement 1-5 exemples par caractère. Les performances atteignent ~95% en 5-way 1-shot, surpassant largement les CNN classiques.

2. Personnalisation de modèles pour utilisateur individuel

Un modèle de reconnaissance vocale généraliste est entraîné avec MAML sur des données de milliers d’utilisateurs. Quand un nouvel utilisateur commence à l’utiliser, quelques minutes de parole suffisent pour adapter le modèle à son accent spécifique. C’est le « one-shot personalization ».

3. Adaptation de robots à de nouveaux environnements

Un robot entraîné avec MAML dans plusieurs environnements simulés (sols différents, pentes, obstacles) peut s’adapter à un nouvel environnement réel en quelques minutes d’expérience, plutôt que des heures de ré-entraînement.

4. Détection de pathologies rares en médecine

Un modèle de détection de tumeurs, méta-entraîné sur plusieurs types de tumeurs courantes, peut s’adapter à une pathologie rare avec seulement une dizaine de cas labellisés, là où un entraînement supervisé classique nécessiterait des centaines d’exemples.

Variantes et extensions de MAML

Le domaine du meta-learning a évolué rapidement après MAML, donnant naissance à des variantes qui adressent ses limitations :

Reptile (2018) : Au lieu de calculer des gradients d’ordre supérieur, Reptile fait simplement une moyenne entre les paramètres originaux θ et les paramètres adaptés θ’ : θ ← θ + ε(θ’ – θ). Cette simplification radicale atteint des performances similaires à MAML pour un coût calcul bien inférieur.

ANIL (2020) : Almost No Inner Loop sépare le corps du réseau (feature extractor) de la tête de classification. Seule la tête est adaptée dans l’inner loop, le corps reste fixe. Cela réduit considérablement le coût des gradients d’ordre supérieur tout en maintenant la qualité des représentations.

Meta-SGD (2017) : Au lieu d’un learning rate unique pour tous les paramètres, Meta-SGD apprend un taux d’apprentissage spécifique pour chaque paramètre du réseau. Cela permet au modèle de savoir quelles parties doivent être beaucoup modifiées et lesquelles doivent rester stables pour chaque nouvelle tâche.

ProtoNet (2017) : Prototypical Networks, une approche métrique plutôt qu’optimisation, apprend un espace d’embedding où les exemples de chaque classe se regroupent autour d’un prototype. La classification se fait par distance au plus proche prototype.

Conclusion

MAML a démontré qu’il était possible d’apprendre à apprendre. En optimisant l’initialisation des paramètres pour l’adaptabilité rapide, il a ouvert la voie à des systèmes capables de généraliser à partir de quelques exemples seulement.

Bien que des approches plus récentes comme Reptile (simplification de MAML) et les méthodes basées sur les transformers (ProtoNet avec attention) aient simplifié ou amélioré le concept, MAML reste le référent fondamental du few-shot learning par gradient. Sa contribution majeure est d’avoir formulé l’apprentissage rapide comme un problème d’optimisation de niveau supérieur, ouvrant la voie à des générations d’algorithmes de meta-learning toujours plus efficaces et pragmatiques.

Voir aussi

• Maîtriser la Manipulation des Chiffres dans les Carrés avec Python : Guide Complet et Astuces
• Python & expressions régulières : un duo gagnant pour traiter les données