Accueil › Glossaire › Reptile

Reptile (Meta-Learning)

Reptile est un algorithme de meta-learning de premier ordre développé par OpenAI qui apprend une initialisation optimale des paramètres d’un réseau neuronal en échantillonnant répétitivement une tâche, en s’entraînant dessus via SGD standard, puis en déplaçant l’initialisation vers les paramètres obtenus, sans calculer de gradients de second ordre.

Pourquoi Reptile existe

MAML est un algorithme de meta-learning puissant mais complexe. Il nécessite le calcul de gradients de second ordre (dérivée de la dérivée), ce qui impose de stocker le graphe de calcul complet à travers les pas de gradient internes. Le coût en mémoire GPU est élevé et croît linéairement avec le nombre de pas internes. L’implémentation requiert des librairies spécialisées comme higher pour PyTorch.

FOMAML (First-Order MAML) simplifie en ignorant les termes de second ordre, mais reste structurellement lié à MAML : il faut toujours distinguer explicitement un support set et un query set, calculer la perte sur le query set après adaptation, et propager le gradient à travers cette structure bi-niveau.

Reptile prend un chemin radicalement différent. Il élimine entièrement la distinction support/query dans la boucle interne. On échantillonne simplement une tâche, on fait K pas de SGD standard dessus (exactement comme un entraînement classique), et on déplace l’initialisation vers les paramètres obtenus. Pas de second dérivée, pas de graphe de calcul à stocker, pas de librairie spécialisée. L’algorithme tient en quelques lignes de code et ne nécessite qu’un accès « boîte noire » à un optimiseur standard (SGD, Adam).

L’algorithme

Pseudo-code officiel

Le pseudo-code de Reptile est d’une simplicité remarquable :

# Initialiser les paramètres φ
φ = random_init()

for iteration in range(num_iterations):
    # Échantillonner une tâche τ
    τ = sample_task()
    
    # Copier l'initialisation courante
    W = φ.clone()
    
    # Entraîner sur la tâche τ pendant k pas de SGD
    for step in range(k):
        W = W - α * grad(L_τ(W))
    
    # Mettre à jour l'initialisation vers les poids obtenus
    φ = φ + ε * (W - φ)

C’est tout. La mise à jour de l’initialisation est un simple pas dans la direction de (W – φ), c’est-à-dire vers les paramètres adaptés à la tâche. Le stepsize ε contrôle la vitesse de cette mise à jour. En alternative, on peut traiter (φ – W) comme un gradient et le passer à un optimiseur adaptatif comme Adam, ce qui fonctionne souvent mieux en pratique.

Version batchée

En pratique, on utilise une version batchée qui échantillonne plusieurs tâches par itération :

for iteration in range(num_iterations):
    # Échantillonner un batch de tâches
    tasks = sample_tasks(batch_size)
    
    gradients = []
    for τ in tasks:
        W = φ.clone()
        for step in range(k):
            W = W - α * grad(L_τ(W))
        gradients.append(φ - W)
    
    # Moyenne des "gradients" Reptile
    mean_gradient = average(gradients)
    φ = φ - ε * mean_gradient  # ou passer à Adam

La version batchée parallélise l’entraînement sur plusieurs tâches, réduisant la variance du gradient Reptile et accélérant la convergence. Chaque tâche peut être traitée indépendamment sur le GPU, ce qui se parallélise efficacement.

Pourquoi Reptile fonctionne

Le piège du k=1

Si k=1 (un seul pas de SGD par tâche), Reptile se réduit exactement au « joint training » : effectuer du SGD sur le mélange de toutes les tâches. Le joint training ne fait pas de meta-learning, il minimise simplement la perte moyenne. Quand le zero-shot learning n’est pas possible (par exemple, quand les labels sont permutés aléatoirement entre tâches), le joint training échoue complètement.

La magie de Reptile apparaît quand k > 1. Avec plus d’un pas de SGD, la mise à jour Reptile dépend des dérivées d’ordre supérieur de la fonction de perte, même si ces dérivées ne sont jamais calculées explicitement. C’est ce qui fait de Reptile un vrai algorithme de meta-learning et pas un simple entraînement multi-tâche.

Analyse par développement de Taylor

Les auteurs analysent Reptile en effectuant un développement de Taylor de la mise à jour. Avec k=2 pas de SGD et deux mini-batches différents de la même tâche (gradients g₁ et g₂), le gradient Reptile contient deux termes principaux :

Le premier terme est le gradient moyen de la tâche (similaire au joint training). Le second terme maximise le produit scalaire entre les gradients de différents mini-batches de la même tâche. Ce second terme est la clé : il favorise les paramètres pour lesquels différents sous-ensembles de données d’une même tâche « tirent dans la même direction », ce qui correspond exactement à la généralisation intra-tâche.

L’analyse montre que Reptile et MAML partagent les mêmes deux termes dans leur développement de Taylor, avec des pondérations différentes. C’est pourquoi les deux algorithmes, malgré des formes très différentes, produisent des résultats similaires. FOMAML et Reptile sont en réalité plus proches l’un de l’autre que MAML et Reptile, comme les auteurs le reconnaissent eux-mêmes.

Lien avec la généralisation du SGD

L’observation que Reptile favorise les initialisations pour lesquelles les gradients de différents mini-batches sont alignés a des implications au-delà du meta-learning. Elle offre une explication partielle de pourquoi le fine-tuning classique (par exemple, d’ImageNet vers un petit dataset) fonctionne bien : le SGD produit naturellement des initialisations qui généralisent bien à des tâches similaires. Reptile formalise et amplifie ce comportement naturel du SGD.

Reptile vs. MAML vs. FOMAML

Le message clé du tableau : Reptile sacrifie environ 1 point de pourcentage de précision par rapport à MAML/FOMAML, en échange d’une réduction drastique de la complexité d’implémentation et du coût mémoire. Pour un prototypage rapide ou des ressources limitées, c’est un compromis excellent.

L’avantage structurel de Reptile est qu’il ne nécessite pas de découper les données de chaque tâche en support set et query set. Chaque mini-batch de la tâche est utilisé indifféremment pour les pas de SGD internes. Cela simplifie le pipeline de données et rend Reptile naturellement compatible avec des situations où la séparation support/query est arbitraire ou artificielle.

Un autre avantage : Reptile peut utiliser un nombre illimité de pas internes k sans coût mémoire supplémentaire. MAML avec k=10 nécessite de stocker 10 niveaux de graphe de calcul. Reptile avec k=100 ne consomme pas plus de mémoire qu’avec k=2. C’est particulièrement utile pour les problèmes qui nécessitent beaucoup de pas d’adaptation (régression complexe, RL).

Implémentation pratique

Code minimal en PyTorch

import torch
import copy

def reptile_update(model, task_loader, inner_lr, inner_steps, meta_lr):
    """Un pas de Reptile."""
    # Sauvegarder l'initialisation
    init_state = copy.deepcopy(model.state_dict())
    
    # Inner loop : SGD standard sur la tâche
    optimizer = torch.optim.SGD(model.parameters(), lr=inner_lr)
    for step in range(inner_steps):
        x, y = next(task_loader)
        loss = criterion(model(x), y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    # Reptile update : déplacer l'initialisation
    with torch.no_grad():
        for name, param in model.named_parameters():
            param.data = (
                init_state[name] 
                + meta_lr * (param.data - init_state[name])
            )

Ce code est complet et fonctionnel. Pas de librairie spécialisée, pas de graphe de calcul à stocker, pas de distinction support/query. On utilise l’optimiseur standard de PyTorch et on déplace l’initialisation après adaptation. C’est la raison pour laquelle Reptile est le premier algorithme de meta-learning que tout praticien devrait implémenter.

Utilisation avec Adam

Au lieu de la mise à jour linéaire φ = φ + ε(W – φ), on peut traiter (φ – W)/α comme un gradient et le passer à Adam. Cela ajoute le momentum et le scaling adaptatif de Adam à la meta-optimisation, ce qui améliore généralement la convergence :

meta_optimizer = torch.optim.Adam(model.parameters(), lr=meta_lr)

# Après les inner steps...
meta_optimizer.zero_grad()
with torch.no_grad():
    for name, param in model.named_parameters():
        param.grad = (init_state[name] - param.data) / inner_lr
meta_optimizer.step()

Hyperparamètres recommandés

Le learning rate interne α (pour les pas de SGD internes) se situe typiquement entre 0.01 et 0.1. Le meta learning rate ε (ou le learning rate de Adam pour la meta-optimisation) est plus petit, typiquement entre 0.001 et 0.01. Le nombre de pas internes k doit être strictement supérieur à 1 (sinon Reptile se réduit au joint training). Les auteurs utilisent k=5 à k=10 dans leurs expériences. Le meta-batch size (nombre de tâches par itération) varie de 5 à 20.

Applications et cas d’usage

Few-shot classification

Sur les benchmarks standards (Omniglot, miniImageNet), Reptile atteint des performances compétitives avec FOMAML. Sur miniImageNet 5-way 5-shot avec un Conv-4, Reptile obtient environ 62%, contre ~63% pour FOMAML et MAML. L’écart est marginal. Les auteurs testent aussi la version transductive (où le modèle classifie l’ensemble du test set en une fois), qui améliore les résultats.

Régression few-shot

L’expérience canonique de régression sinusoïdale montre que Reptile apprend à régresser des sinusoïdes d’amplitude et de phase variables à partir de quelques points, avec des résultats similaires à MAML. La capacité de Reptile à utiliser un grand nombre de pas internes (k >> 5) est un avantage ici, car les tâches de régression bénéficient de plus d’itérations d’adaptation.

Federated learning

La structure de Reptile (entraîner localement sur une tâche, puis agréger vers un modèle global) ressemble fortement à FedAvg (Federated Averaging). Des travaux récents comme FedMcon formalisent ce lien et utilisent des principes de meta-learning pour améliorer l’agrégation dans le federated learning, notamment quand les distributions de données sont hétérogènes entre clients.

Prototypage rapide

La simplicité d’implémentation de Reptile en fait l’outil idéal pour le prototypage. Quand vous explorez si le meta-learning est pertinent pour votre problème, Reptile donne une réponse rapide sans investir dans l’infrastructure complexe de MAML. Si Reptile fonctionne, vous pouvez décider ensuite si les gains marginaux de MAML justifient la complexité supplémentaire. Si Reptile échoue, MAML échouera probablement aussi (puisque les deux algorithmes optimisent fondamentalement le même objectif).

Autres domaines

Reptile a été utilisé en classification d’images de plancton marin (transfert entre espèces rares), en reconnaissance d’activités humaines par radar (adaptation à de nouveaux sujets), en reconstruction d’antennes assistée par meta-learning, et en apprentissage continu (combinaison de Reptile avec des mécanismes anti-oubli). Sa simplicité le rend particulièrement adapté aux domaines où les praticiens ne sont pas des experts en meta-learning et ont besoin d’un algorithme qu’ils peuvent comprendre, implémenter et débugger rapidement.

Limites

Performances légèrement inférieures à MAML. Sur les benchmarks standards, Reptile perd environ 1 point de pourcentage par rapport à MAML complet. Cet écart est marginal mais existe. Si chaque point de précision compte, MAML ou LEO sont préférables.

Pas de publication en venue top-tier. L’article « On First-Order Meta-Learning Algorithms » est un rapport technique d’OpenAI (arXiv), pas un article publié dans une conférence peer-reviewed (ICML, NeurIPS). Cela n’affecte pas la qualité du travail (il cumule plus de 2 100 citations), mais c’est un facteur à considérer dans un contexte académique.

Analyse théorique incomplète. Les auteurs proposent deux arguments informels pour expliquer pourquoi Reptile fonctionne (développement de Taylor et distance aux variétés de solutions), mais reconnaissent que l’analyse n’est pas rigoureusement formelle. La compréhension théorique profonde de pourquoi les algorithmes de meta-learning de premier ordre fonctionnent aussi bien que ceux de second ordre reste un problème ouvert.

Sensibilité au nombre de pas internes k. Avec k=1, Reptile ne fait pas de meta-learning. Avec un k trop grand, l’adaptation interne peut « oublier » l’initialisation et converger vers un minimum local spécifique à la tâche, réduisant la transférabilité. Le choix de k est un hyperparamètre à calibrer.

Verdict

Reptile est la porte d’entrée idéale dans le meta-learning optimization-based. Son implémentation en quelques lignes de code, son coût mémoire minimal, et sa compatibilité avec n’importe quel optimiseur standard en font l’algorithme le plus accessible de la famille MAML. Les performances sont légèrement inférieures à MAML complet, mais l’écart est marginal et ne justifie pas la complexité supplémentaire dans la majorité des cas pratiques.

Le conseil pragmatique : commencez toujours par Reptile quand vous explorez le meta-learning optimization-based. Si Reptile ne fonctionne pas, passez à FOMAML (qui partage la même analyse théorique mais avec une structure support/query explicite). N’utilisez MAML complet (avec gradients de second ordre) que si les deux premiers échouent et que vous avez les ressources GPU pour supporter le coût de calcul. Et dans tous les cas, comparez avec les Prototypical Networks pour la classification few-shot : ils sont souvent meilleurs et toujours plus simples.