Accueil › Glossaire › Prototypical Networks

Prototypical Networks

Les Prototypical Networks (ProtoNets) sont un algorithme de meta-learning pour le few-shot learning qui classifie de nouveaux exemples en calculant leur distance euclidienne aux prototypes de chaque classe, chaque prototype étant la moyenne des embeddings des exemples disponibles pour cette classe.

L’intuition derrière les Prototypical Networks

L’idée fondatrice des Prototypical Networks est d’une simplicité désarmante : il existe un espace d’embedding dans lequel les exemples d’une même classe se regroupent autour d’un seul point central, le prototype. Pour classifier un nouvel exemple, il suffit de projeter cet exemple dans le même espace et de regarder quel prototype est le plus proche.

C’est l’équivalent neuronalien du « nearest class mean » (classification par le centroïde le plus proche), une technique datant des années 1950, mais avec un twist crucial : l’espace dans lequel on calcule les distances est appris par un réseau de neurones. Ce réseau (l’embedding function) transforme les images brutes en vecteurs de features discriminants, spécifiquement optimisés pour que cette classification par proximité fonctionne bien.

Par rapport aux Matching Networks (Vinyals et al., 2016) qui les précèdent, les Prototypical Networks apportent deux simplifications majeures. Premièrement, ils calculent un seul prototype par classe (la moyenne des embeddings) plutôt qu’une distribution d’attention sur tous les exemples du support set. Deuxièmement, ils utilisent la distance euclidienne au carré plutôt que la similarité cosinus. Ces deux choix, en apparence anodins, améliorent significativement les performances et la scalabilité.

L’algorithme en détail

Setup et notation

On dispose d’un support set S contenant K exemples labellisés pour chacune des N classes à classifier (configuration N-way K-shot). On note S_k l’ensemble des exemples de la classe k. L’objectif est de classifier un exemple de requête x (query) dans l’une des N classes.

L’algorithme se déroule en trois étapes :

Étape 1 : Embedding

Chaque exemple x_i du support set est projeté dans un espace d’embedding via une fonction f_θ (un réseau de neurones, typiquement un CNN). On obtient un vecteur z_i = f_θ(x_i) de dimension d. L’architecture originale utilise un encodeur Conv-4 (4 blocs de convolution 3×3 avec 64 filtres, batch normalization, ReLU et max pooling), mais n’importe quel backbone peut être utilisé (ResNet, EfficientNet, Vision Transformer).

Étape 2 : Calcul des prototypes

Pour chaque classe k, le prototype c_k est calculé comme la moyenne des embeddings de tous les exemples de cette classe dans le support set :

c_k = (1 / |S_k|) × Σ f_θ(x_i)  pour x_i ∈ S_k

C’est tout. Pas de poids appris, pas de mécanisme d’attention, pas d’optimisation supplémentaire. La moyenne arithmétique des embeddings constitue le prototype de la classe. Cette simplicité est l’un des grands atouts des ProtoNets : le prototype est optimal au sens de la minimisation de la distance de Bregman aux points du cluster (un résultat théorique élégant démontré dans l’article original).

Étape 3 : Classification par distance

Pour un exemple de requête x, on calcule son embedding z = f_θ(x), puis sa distance euclidienne au carré à chaque prototype :

d(z, c_k) = ||z - c_k||²

La probabilité que x appartienne à la classe k est donnée par un softmax sur les distances négatives :

p(y = k | x) = exp(-d(z, c_k)) / Σ_j exp(-d(z, c_j))

L’exemple est classifié dans la classe du prototype le plus proche (distance la plus faible). L’entraînement optimise les paramètres θ de l’embedding function pour minimiser la perte de cross-entropy sur les exemples du query set, calculée via ces probabilités softmax.

Entraînement épisodique

Comme tous les algorithmes de meta-learning pour le few-shot learning, les Prototypical Networks utilisent l’entraînement épisodique. Chaque épisode simule un problème N-way K-shot :

On échantillonne N classes parmi les classes d’entraînement. Pour chaque classe, on tire K exemples comme support set et un nombre séparé d’exemples comme query set (typiquement 15 par classe). On calcule les prototypes à partir du support set, on classifie les exemples du query set, et on propage le gradient de la perte de classification pour mettre à jour les paramètres θ de l’encodeur.

Un résultat important de l’article original : entraîner avec plus de classes par épisode (higher « way ») que ce qui sera utilisé au test améliore significativement les performances. Par exemple, entraîner en 20-way ou 30-way pour un test en 5-way produit de meilleurs résultats qu’un entraînement en 5-way. La difficulté accrue pendant l’entraînement force le réseau à apprendre des embeddings plus discriminants et mieux structurés.

Décisions de design critiques

Distance euclidienne vs. cosinus

L’un des apports les plus significatifs de l’article est la démonstration empirique que la distance euclidienne surpasse la distance cosinus de manière substantielle, aussi bien pour les Prototypical Networks que pour les Matching Networks. Sur miniImageNet 5-way 5-shot, le passage de cosinus à euclidien améliore les performances de plusieurs points de pourcentage.

L’explication théorique est que la distance euclidienne est une divergence de Bregman, ce qui garantit l’optimalité du prototype comme moyenne du cluster. La distance cosinus n’est pas une divergence de Bregman, donc le prototype moyen n’est plus optimal sous cette métrique.

Choix du backbone

L’article original utilise un encodeur Conv-4 simple (4 couches convolutionnelles). Avec ce backbone modeste, les ProtoNets atteignent environ 68% sur miniImageNet 5-way 5-shot. Mais les performances dépendent fortement de la qualité de l’encodeur. Avec un ResNet-12 ou un WRN-28-10 pré-entraîné, les performances dépassent les 80%. Avec un ViT pré-entraîné via apprentissage autosupervisé (comme DINO), elles sont encore supérieures.

Ce constat a un corollaire pratique important : investir dans un meilleur backbone est souvent plus rentable que sophistiquer l’algorithme de meta-learning.

Configuration d’entraînement

Le nombre de « ways » (classes par épisode) pendant l’entraînement doit être supérieur ou égal au nombre de ways au test. Entraîner en 30-way pour tester en 5-way est un excellent choix. En revanche, le nombre de « shots » (exemples par classe) pendant l’entraînement doit correspondre au nombre de shots au test pour des résultats optimaux.

Variantes et extensions

Les Prototypical Networks ont inspiré un écosystème entier de variantes, chacune adressant une limitation spécifique.

TADAM : prototypes conditionnés par la tâche

TADAM (Oreshkin et al., 2018) améliore les ProtoNets en rendant l’embedding dépendant de la tâche courante. Un module de task conditioning modifie les paramètres des couches de batch normalization en fonction d’un vecteur de tâche (calculé à partir du support set). Cela permet au réseau d’accentuer les features pertinentes pour chaque tâche spécifique. Résultat : environ 76,7% sur miniImageNet 5-way 5-shot, soit ~8 points de plus que les ProtoNets originaux.

SSL-ProtoNet : prototypes + apprentissage autosupervisé

SSL-ProtoNet combine le pré-entraînement autosupervisé avec les Prototypical Networks. L’encodeur est pré-entraîné via une tâche de contrastive learning (les images augmentées d’un même exemple doivent être proches dans l’espace d’embedding, les images d’exemples différents doivent être éloignées). Ce pré-entraînement produit des features plus robustes et transférables, améliorant les performances few-shot d’environ 16% par rapport aux baselines supervisées avec des données SSL à grande échelle.

ProtoNets semi-supervisés

Les Prototypical Networks se prêtent naturellement à l’extension semi-supervisée. L’idée : en plus du support set labellisé, utiliser des données non labellisées pour affiner les prototypes. On attribue des pseudo-labels aux données non labellisées (par proximité aux prototypes actuels), puis on recalcule les prototypes en incluant ces données. Ce processus itératif (similaire à EM ou soft k-means) améliore les prototypes quand des données non labellisées pertinentes sont disponibles.

Proto-CLIP : prototypes vision-langage

Proto-CLIP (NVIDIA, 2024) combine les Prototypical Networks avec les modèles vision-langage comme CLIP. Il utilise simultanément des prototypes d’images (moyenne des embeddings visuels CLIP) et des prototypes de texte (embeddings des descriptions de classe) pour la classification few-shot. L’alignement des prototypes d’images et de texte renforce mutuellement les deux modalités. Le modèle existe en version training-free (utilisable directement avec CLIP) et en version fine-tunée, et a été validé pour la perception robotique en conditions réelles.

Prototypical Networks transductifs

Les ProtoNets transductifs ne classifient pas les exemples de requête indépendamment. Ils utilisent l’information statistique de l’ensemble du query set pour affiner les prototypes. L’idée est que le query set contient lui-même de l’information sur la distribution des classes, et que cette information peut améliorer la classification. En pratique, on itère entre la classification des requêtes et la mise à jour des prototypes en incluant les requêtes à haute confiance.

Prototypical Networks incrémentaux (FSCIL)

Le Few-Shot Class-Incremental Learning (FSCIL) étend les ProtoNets au scénario où de nouvelles classes apparaissent continuellement avec peu d’exemples, sans oublier les classes précédentes. Des travaux récents (2025) proposent de geler l’extracteur de features et de fine-tuner uniquement les prototypes via des offsets appris (class-specific et task-aware), transformant les centroïdes statiques en composants dynamiques et apprenables. C’est une direction prometteuse pour les systèmes en production qui doivent évoluer continuellement.

Applications concrètes

Vision industrielle et contrôle qualité

Les Prototypical Networks sont particulièrement adaptés à la détection de défauts industriels. Quand un nouveau type de défaut apparaît sur une chaîne de production, il suffit de quelques images annotées pour calculer le prototype de ce défaut et commencer à le détecter immédiatement, sans réentraîner le modèle entier. Pour la détection de dommages sur les matériaux composites (CFRP), des travaux ont montré une amélioration de la précision de classification de 55% à plus de 82% en utilisant seulement 4 exemples réels combinés avec des données autosupervisées.

Agriculture de précision

La classification de mauvaises herbes pour l’agriculture de précision bénéficie des ProtoNets. Des travaux récents (AMCIS 2025) combinent des ProtoNets quantifiés avec la distillation de connaissances pour déployer des classificateurs few-shot sur des appareils edge (embarqués sur les tracteurs), permettant une adaptation rapide à de nouvelles espèces de mauvaises herbes avec seulement quelques exemples annotés sur le terrain.

Extraction de relations en NLP

En traitement du langage naturel, les Prototypical Networks sont largement utilisés pour l’extraction de relations few-shot. Le benchmark FewRel est le terrain d’évaluation standard. Des variantes récentes (AIRE, 2025) améliorent les prototypes en intégrant les informations sémantiques des labels de relations et en utilisant les exemples du query set pour affiner les prototypes, ce qui compense les déviations dues au nombre limité d’exemples.

Imagerie médicale

La classification histopathologique few-shot utilise fréquemment les ProtoNets. Le prototype d’un type de lésion rare peut être calculé à partir de quelques images annotées par un pathologiste expert. Des extensions avec estimation d’incertitude (prototypes gaussiens) permettent au modèle d’indiquer son niveau de confiance, ce qui est critique en contexte médical. Les ProtoNets sont aussi utilisés pour la segmentation semi-supervisée d’images médicales, combinant prototypes et apprentissage de représentations probabilistes.

Séries temporelles

Les Deep Prototypical Networks (DPN) étendent le concept aux séries temporelles, avec des applications en classification de données déséquilibrées (classe majoritaire vs. classe rare). Un module de masquage relationnel ajuste automatiquement la métrique de distance en fonction de la complexité des données, ce qui rend les ProtoNets robustes au déséquilibre de classes, un problème fréquent en production.

Systèmes de recommandation

Le problème du cold-start (recommander à un nouvel utilisateur sans historique) se reformule naturellement comme un problème few-shot. Le prototype d’un « type d’utilisateur » peut être calculé à partir de ses premières interactions, puis comparé aux prototypes de segments utilisateurs connus pour générer des recommandations personnalisées dès les premières actions.

Implémentation pratique

Code minimal

Voici le pseudo-code de l’inférence d’un Prototypical Network (la partie la plus simple de l’algorithme) :

# 1. Encoder le support set
support_embeddings = encoder(support_images)  # [N*K, d]

# 2. Calculer les prototypes (moyenne par classe)
prototypes = []
for k in range(N):
    class_embeddings = support_embeddings[k*K:(k+1)*K]
    prototypes.append(class_embeddings.mean(dim=0))
prototypes = stack(prototypes)  # [N, d]

# 3. Classifier les requêtes
query_embedding = encoder(query_image)  # [d]
distances = squared_euclidean(query_embedding, prototypes)  # [N]
probabilities = softmax(-distances)  # [N]
predicted_class = argmin(distances)

L’ensemble de l’inférence tient en quelques lignes. C’est un avantage majeur en production : la simplicité du code réduit le risque de bugs et facilite l’audit. L’implémentation officielle est disponible sur GitHub en PyTorch, et la librairie learn2learn fournit une implémentation complète avec entraînement épisodique.

Considérations de production

En production, les prototypes peuvent être pré-calculés et stockés. Quand une nouvelle classe apparaît, il suffit de calculer son prototype (une seule inférence de l’encodeur sur les exemples, suivie d’une moyenne) et de l’ajouter au catalogue. Aucun réentraînement du modèle n’est nécessaire. L’inférence se réduit alors à un calcul de distance entre le vecteur de requête et les prototypes stockés, ce qui est extrêmement rapide (comparable à une recherche de voisins les plus proches).

Pour les systèmes à très grand nombre de classes, on peut utiliser une structure d’index approximatif (FAISS, ScaNN) pour accélérer la recherche du prototype le plus proche. Cela rend les ProtoNets viables même avec des milliers de classes.

Forces et limites

Forces

La simplicité est la force numéro un. L’algorithme est facile à comprendre, à implémenter, à débugger et à auditer. Il n’y a pas de gradient à calculer au moment de l’inférence (contrairement à MAML), ce qui rend l’inférence rapide et déterministe. L’ajout de nouvelles classes est instantané (calculer un prototype). Le fondement théorique (divergence de Bregman, estimation de densité) est solide. Et les performances sont compétitives avec des méthodes bien plus complexes.

Limites

Le prototype moyen peut être inadéquat quand la distribution d’une classe est multimodale (deux sous-clusters distincts). Un prototype unique situé entre les deux clusters ne représente bien ni l’un ni l’autre. Des variantes avec prototypes multiples ou prototypes gaussiens (modélisant une distribution plutôt qu’un point) atténuent ce problème.

Les performances dépendent fortement de la qualité de l’encodeur. Un mauvais backbone produira des embeddings non discriminants, et les prototypes seront inutiles. C’est pourquoi le pré-entraînement de l’encodeur (supervisé ou autosupervisé) sur un grand dataset est souvent plus impactant que l’optimisation de l’algorithme de meta-learning lui-même.

En cross-domain (entraîner sur un domaine, tester sur un autre), les ProtoNets souffrent du distributional shift comme toutes les méthodes metric-based. Les features apprises sur ImageNet ne se transfèrent pas forcément bien à l’imagerie médicale ou satellite.

Verdict

Les Prototypical Networks sont l’algorithme de few-shot learning que tout praticien devrait connaître et maîtriser en premier. Pas parce qu’ils sont les plus performants (SimpleShot avec un bon backbone fait souvent mieux), mais parce qu’ils incarnent l’équilibre parfait entre simplicité, performance et praticité. Leur inférence sans gradient, leur capacité à ajouter de nouvelles classes instantanément, et leur fondement théorique solide en font le premier choix pour les systèmes en production qui doivent s’adapter rapidement à de nouvelles catégories.

Si vous débutez en few-shot learning, implémentez les ProtoNets en premier. Comprenez pourquoi la distance euclidienne fonctionne mieux que cosinus. Expérimentez avec différents backbones. Et seulement si les performances ne suffisent pas, explorez les variantes plus sophistiquées. Dans la majorité des cas industriels, un bon encodeur pré-entraîné + ProtoNets suffit. C’est l’une de ces rares situations en ML où la solution la plus simple est aussi l’une des meilleures.