Robustesse en faible régime (1) — ReBaPL : le prompt learning bayésien répulsif

TL;DR. Le prompt learning adapte CLIP avec quelques images par classe, mais il overfitte. ReBaPL le reformule en problème d'inférence bayésienne : au lieu d'optimiser un prompt, on échantillonne la distribution des bons prompts avec fonctionnelle entre échantillons — mesurée par MMD ou Wasserstein sur les représentations, pas sur les poids. Résultat : meilleure généralisation partout (base→novel, cross-dataset, domain shift), en plug-and-play sur les méthodes existantes.

Commençons par une expérience que tout praticien a vécue. Vous adaptez un modèle de pointe (MaPLe) à la reconnaissance de fleurs, avec 16 images par classe, en le laissant tourner 15 epochs. Verdict sur les classes d'entraînement : 97,2 %. Champagne ? Pas si vite. Sur les classes que le modèle n'a jamais vues : 70,9 %. Et en entraînant moins longtemps (5 epochs), on obtient 96,3 % / 73,3 % — un peu moins bon là où c'est facile, nettement meilleur là où ça compte. Ces chiffres, tirés des annexes du papier dont nous allons parler, résument tout le problème : plus on optimise, plus on s'enfonce dans les particularités du jeu d'entraînement.

Adapter un grand modèle vision-langage comme CLIP à une tâche précise, avec seulement quelques images par classe, est en effet devenu un réflexe : au lieu de ré-entraîner le modèle, on apprend un prompt — un petit vecteur de contexte qui oriente le modèle vers la bonne tâche. C'est le prompt learning. Et comme on vient de le voir, avec si peu de données, on surapprend (overfitting) : le modèle généralise mal aux classes et aux domaines qu'il n'a jamais vus.

Le papier ReBaPL (Repulsive Bayesian Prompt Learning, Bendou et al., 2026) propose un changement de point de vue radical : et si, au lieu de chercher le meilleur prompt, on cherchait à décrire toute la distribution des bons prompts ? C'est la promesse de l'inférence bayésienne. La difficulté, c'est que cette distribution est multimodale — il existe de nombreux prompts très différents, tous excellents sur les données d'entraînement, mais qui généralisent différemment. ReBaPL apporte deux idées pour l'explorer efficacement :

1. un échantillonneur MCMC malin (rcSGHMC) qui alterne des phases d'exploration et d'échantillonnage ;
2. une force répulsive qui pousse les prompts à être fonctionnellement différents — mesurée non pas sur les poids, mais sur les représentations qu'ils produisent, via des distances entre distributions (MMD, Wasserstein).

Ce que vous saurez à la fin. Comment fonctionne CLIP et le prompt learning multi-modal ; pourquoi l'estimation ponctuelle (MLE/MAP) overfit ; ce qu'est échantillonner un posterior et comment le faire par gradient bruité (Langevin, SGLD, SGHMC, SGMCMC cyclique) ; pourquoi et comment ReBaPL ajoute une répulsion dans l'espace des représentations ; ce que valent MMD et la distance de Wasserstein ; et ce que montrent les expériences.

C'est un deep-dive : on construit chaque brique depuis son intuition. Accrochez-vous, mais rien n'est laissé dans l'ombre.

Fil rouge. Pour garder les pieds sur terre, on suivra tout au long de l'article un cas concret : EuroSAT, un jeu de classification d'images satellite en 10 classes (forêt, rivière, zone résidentielle, culture annuelle…), avec 16 images par classe pour s'adapter. C'est un cas d'école : très éloigné des photos « naturelles » du pré-entraînement de CLIP (le zero-shot y plafonne à ≈ 56 % sur les classes de base), il force le prompt à réellement travailler. C'est aussi, on le verra, le dataset où ReBaPL réalisera son plus gros gain.

Partie I — Le décor : le prompt learning sur CLIP

Où l'on découvre comment CLIP classe des images sans entraînement, comment on lui apprend des prompts, et pourquoi l'approche standard finit toujours par overfitter.

CLIP en cinq minutes

CLIP (Radford et al., 2021) est un modèle entraîné à aligner des images et des textes dans un même espace latent. Il possède deux encodeurs :

• un encodeur d'image (un ViT ou un ResNet) qui transforme une image $x$ en un vecteur $u \in \mathbb{R}^d$ ;
• un encodeur de texte (un Transformer) qui transforme une phrase $T$ en un vecteur $v \in \mathbb{R}^d$.

Ces deux encodeurs sont entraînés par apprentissage contrastif sur des centaines de millions de paires (image, légende) : les paires qui vont ensemble sont rapprochées, les autres éloignées. Résultat : dans l'espace latent partagé, la similarité cosinus entre une image et un texte mesure à quel point ils « parlent de la même chose ».

Figure 1 — Le pipeline CLIP et la classification zero-shot de bout en bout : deux encodeurs gelés projettent l'image et les prompts de classe dans un espace partagé ; la classe prédite est celle du texte le plus aligné avec l'image (argmax des similarités cosinus).

Ce mécanisme suffit à faire de la classification zero-shot, sans le moindre ré-entraînement. Pour classer une image parmi $C$ classes, on fabrique $C$ phrases du type "a photo of a {classe}", on les encode en $v_1, \dots, v_C$, et on choisit la classe dont le texte est le plus similaire à l'image. Formellement, la probabilité de la classe $y$ s'écrit comme un softmax sur les similarités :

où $\tau$ est une température qui contrôle le piqué de la distribution. La qualité de cette classification dépend énormément du texte choisi : "a photo of a dog" ne donne pas le même vecteur que "dog". Sur notre fil rouge EuroSAT, un bon prompt manuel ressemble à "a centered satellite photo of a forest" — et malgré cela, le zero-shot plafonne autour de 56 % : les images satellite sont trop loin de ce que CLIP a vu en pré-entraînement. C'est tout l'enjeu du prompt.

Du prompt manuel au prompt appris

Écrire les prompts à la main ("a photo of a ...", "a close-up photo of a ...") est fastidieux et sous-optimal. L'idée du prompt learning est de remplacer les mots par des vecteurs appris. On ne cherche plus la bonne phrase en anglais : on laisse la descente de gradient trouver directement les vecteurs de contexte qui maximisent la performance sur nos quelques exemples.

• CoOp (Zhou et al., 2022) apprend $b$ vecteurs de contexte continus $[P^1, P^2, \dots, P^b]$ que l'on place devant l'embedding du mot de classe, côté texte uniquement. Ces vecteurs ne correspondent à aucun mot réel — ce sont des « pseudo-mots » optimisés.
• CoCoOp rend ces vecteurs conditionnels à l'image (le prompt s'adapte à chaque entrée), ce qui améliore la généralisation mais reste côté texte.
• Les méthodes multi-modales (MaPLe, MMRL, VaMP) vont plus loin : elles injectent des tokens appris dans les deux branches — texte et image — et à plusieurs profondeurs des Transformers.

Pourquoi les deux branches ? Parce qu'adapter uniquement le texte, c'est ne réajuster qu'une moitié du modèle. En apprenant des prompts côté vision et côté langage, on aligne mieux les deux modalités pour la tâche cible.

Formalisons un peu (on peut sauter ce bloc sans perdre le fil). Notons $\mathcal{L}_1, \dots, \mathcal{L}_K$ les $K$ couches du Transformer texte et $\mathcal{V}_1, \dots, \mathcal{V}_K$ celles du Transformer image. Côté langage, on glisse des tokens appris $P_{i}$ à côté des embeddings de mots $W$, couche par couche jusqu'à une profondeur $J$, puis on laisse le Transformer propager le tout :

Côté vision, mêmes récurrences avec les tokens $\tilde{P}_i$, les patchs $E$ et le class token $c$, la représentation finale $u$ sortant de la dernière couche :

Ce qu'il faut retenir : des tokens appris sont injectés dans les deux flux, à plusieurs profondeurs (deep prompting), et c'est de là que sortent l'image $u$ et le texte $v$ qui seront comparés.

Un point subtil et important : les prompts vision et langage ne doivent pas être appris indépendamment. On veut une synergie entre modalités. Les méthodes multi-modales introduisent donc une coupling function $\mathcal{F}$ qui conditionne les prompts vision sur les prompts langage :

Concrètement, $\mathcal{F}$ est une projection linéaire pour MaPLe, une construction un peu plus riche pour MMRL. Elle sert de pont : le gradient circule entre les deux branches, et les prompts vivent dans un espace couplé.

Figure 2 — Le deep prompting multi-modal : les tokens appris (P côté texte, P̃ côté image) sont injectés couche par couche jusqu'à la profondeur J ; la coupling function relie les deux branches. Tout le reste — les deux encodeurs — est gelé.

Dans tous les cas, on note $\theta$ l'ensemble des paramètres apprenables : les prompts langage, les prompts vision, et les paramètres de la coupling function. Le modèle CLIP, lui, reste entièrement gelé. On optimise $\theta$ par maximum de vraisemblance (MLE) sur nos $n$ exemples étiquetés :

où $u_i$ est l'embedding de l'image $i$ (désormais influencé par les prompts vision) et la vraisemblance $p(y_i \mid u_i, \theta)$ est le softmax de similarité vu plus haut (les $v_c$ étant influencés par les prompts langage).

Le problème central : optimiser un seul point, c'est overfitter

Le MLE — et sa variante régularisée, le MAP (maximum a posteriori) — renvoie un seul jeu de paramètres $\theta^\star$. C'est une estimation ponctuelle. Avec seulement 16 images par classe, ce point unique se cale sur les particularités du jeu d'entraînement : couleurs, arrière-plans, biais de collecte. Il excelle sur les classes vues (base) mais chute sur les classes nouvelles (novel) ou les domaines décalés. Et il ne dit rien de son incertitude.

Écrit noir sur blanc, le MAP maximise le log-posterior — la vraisemblance de nos exemples plus un terme de prior :

MaPLe et MMRL sont exactement cela : des estimateurs MAP (le MLE en est le cas sans prior). Le problème n'est pas la qualité de ce point — c'est qu'un point ne suffit pas.

Or il se trouve que le paysage de perte du prompt learning est plat et multimodal : il existe une multitude de prompts $\theta$ qui atteignent quasiment la même perte d'entraînement, mais qui généralisent très différemment. Choisir arbitrairement l'un d'eux (celui où la descente de gradient s'est arrêtée) est un pari risqué.

Sur EuroSAT, concrètement : avec 160 images d'entraînement (16 × 10 classes), un prompt peut apprendre à s'accrocher à la couleur dominante des parcelles, un autre à la texture des zones bâties, un troisième à un mélange des deux. Les trois frôlent le sans-faute sur les images d'entraînement — mais face à des classes ou des régions jamais vues, leurs comportements divergent complètement.

Figure 3 — Plusieurs bassins « aussi bons » à l'entraînement, mais de qualité de généralisation différente. Un seul point ne capture pas cette richesse.

L'idée de ReBaPL découle directement de ce constat : ne pas parier sur un seul prompt, mais échantillonner plusieurs prompts représentatifs de la région des bonnes solutions, puis les combiner (ensembling). Pour cela, il faut passer du langage de l'optimisation à celui de l'inférence bayésienne.

Partie II — Le virage bayésien

Où l'on passe de « trouver le meilleur $\theta$ » à « échantillonner tous les bons $\theta$ » — et où l'on construit l'échantillonneur brique par brique : Langevin, SGLD, SGHMC, puis le schedule cyclique.

Rappel express d'inférence bayésienne

En optimisation, on cherche le meilleur $\theta$. En bayésien, on cherche la distribution de $\theta$ compatible avec les données. Le théorème de Bayes relie le posterior $p(\theta \mid \mathcal{D})$ à la vraisemblance $p(\mathcal{D} \mid \theta)$ et à un prior $p(\theta)$ :

Le dénominateur $p(\mathcal{D})$ (l'évidence) est une constante de normalisation en général incalculable — mais on peut souvent s'en passer. En pratique on travaille avec le logarithme, et on définit le potentiel comme l'opposé du log-posterior :

Ce potentiel joue le rôle d'une « énergie » : les $\theta$ probables (posterior élevé) sont ceux d'énergie faible. Le MAP, c'est simplement le minimum de $U$ — le point le plus bas. Mais nous, on ne veut pas le minimum : on veut échantillonner toute la distribution $p(\theta \mid \mathcal{D})$, c'est-à-dire tirer des $\theta$ proportionnellement à $e^{-U(\theta)}$.

Figure 4 — Trois réponses au même problème. Le MLE et le MAP renvoient un seul point (le MAP étant tiré vers le prior, en pointillés) ; l'approche bayésienne décrit toute la distribution — y compris le second mode, invisible pour les deux autres.

Reste la vraie question : comment tirer des échantillons d'une distribution qu'on ne connaît qu'à travers son potentiel ?

Échantillonner le posterior avec du gradient bruité

Voici l'idée-clé, à la fois simple et profonde : une descente de gradient à laquelle on ajoute la bonne quantité de bruit ne converge pas vers un point — elle échantillonne la distribution. C'est la dynamique de Langevin :

Le terme $-\alpha\,\nabla U$ attire vers les zones probables (comme une descente de gradient) ; le terme $\sqrt{2\alpha}\,\varepsilon_k$ injecte juste assez de hasard pour que la chaîne ne s'immobilise pas et visite toute la distribution. C'est la discrétisation (pas de temps $\alpha$) d'une équation différentielle stochastique (SDE) — la diffusion de Langevin — pilotée par un mouvement brownien $W_t$ :

Pourquoi ce facteur $\sqrt{2}$ précis ? L'équation de Fokker–Planck associée montre que la densité de $\theta_t$ converge, quand $t \to \infty$, vers la loi stationnaire $p_\infty(\theta) \propto e^{-U(\theta)}$ — c'est-à-dire exactement le posterior. Le coefficient de bruit équilibre au cordeau l'attraction du gradient et la diffusion : trop peu de bruit et l'on retombe sur le MAP (le mode) ; trop de bruit et l'on diffuse vers la loi uniforme. La valeur $\sqrt{2}$ est celle qui vise juste le posterior.

Problème pratique : calculer $\nabla U$ exige de parcourir tout le jeu de données à chaque pas. Welling & Teh (2011) proposent donc le SGLD (Stochastic Gradient Langevin Dynamics), qui estime le gradient sur un mini-batch $B$ de taille $m \ll n$ :

C'est le mariage du MCMC et de la descente de gradient stochastique. Mais SGLD a un défaut : en haute dimension, il converge lentement — la marche aléatoire met un temps fou à traverser le paysage.

Ajouter de l'inertie : SGHMC

Pour accélérer l'exploration, on ajoute de l'inertie. Plutôt que de laisser $\theta$ zigzaguer, on lui donne un moment $r$ (une vitesse) : le paramètre « roule » dans le paysage au lieu de tituber. Mathématiquement, on augmente l'espace d'état avec ce moment et l'on définit un hamiltonien — une énergie totale « potentielle + cinétique » :

dont la loi jointe stationnaire est $p(\theta, r) \propto e^{-H(\theta, r)}$. Sa $\theta$-marginale est exactement le posterior visé — on a juste ajouté une variable auxiliaire gaussienne $r$. La dynamique continue avec friction $\eta$ et bruit (calibrés par la relation de fluctuation–dissipation) s'écrit :

Discrétisée sur mini-batch, elle donne le SGHMC (Stochastic Gradient Hamiltonian Monte Carlo, Chen et al., 2014) :

Intuition physique. Imaginez une bille qui roule dans le paysage $U$. Le gradient $-\nabla U$ est la pente qui l'accélère vers les vallées. La friction $\eta$ l'empêche de s'emballer (sans frottement, elle oscillerait sans fin). Le bruit $\varepsilon_k$ la fait vibrer juste assez pour explorer. Le terme $\hat\gamma$ estime le bruit parasite introduit par les mini-batches, et la friction est calibrée pour le compenser — de sorte que la loi stationnaire reste bien le posterior. C'est exactement la mécanique hamiltonienne (position + quantité de mouvement), rendue stochastique.

Figure 5 — Même budget d'itérations sur une vallée allongée : SGLD (bleu) piétine en marche aléatoire, SGHMC (vert clair) glisse le long de la vallée grâce à son inertie, atteint le mode et échantillonne autour.

Le SGHMC combine donc l'efficacité du mini-batch avec l'exploration rapide des dynamiques à moment. Mais il lui manque encore un ingrédient pour attraper plusieurs modes d'un coup.

Explorer plusieurs modes : le SGMCMC cyclique

Une chaîne MCMC classique, une fois tombée dans un bassin d'énergie faible, a du mal à en ressortir : elle échantillonne très bien un mode, mais rate les autres. Zhang et al. (2019) proposent le SGMCMC cyclique : au lieu d'un learning rate qui décroît une fois, on le fait osciller selon un schedule cosinus, en répétant $C$ cycles. Chaque cycle se découpe en deux phases :

• une phase d'exploration (grand $\alpha_t$) : la chaîne bondit loin, franchit les barrières et cherche un nouveau mode ;
• une phase de sampling (petit $\alpha_t$ + bruit) : la chaîne se stabilise dans le mode trouvé et on y collecte des échantillons.

Figure 6 — Le learning rate oscille : chaque cycle explore (α élevé) puis échantillonne (α faible). On collecte un échantillon en fin de chaque cycle.

Une famille unifiée. SGLD (pas de moment) et SGHMC (avec moment) sont deux membres de la même famille, le SGMCMC : des discrétisations de processus de Markov en temps continu conçus pour échantillonner le posterior, qui diffèrent seulement par la manière d'incorporer moment, friction et bruit. Dans la suite, « méthode bayésienne » = un membre de cette famille.

Nous avons maintenant tout le vocabulaire. Reste à comprendre l'apport propre de ReBaPL, qui tient en deux idées.

Partie III — Les deux idées de ReBaPL

Où ReBaPL entre enfin en scène : une force répulsive entre échantillons pour ne jamais revisiter le même mode, une distance mesurée dans le bon espace — celui des représentations — et l'algorithme complet qui assemble le tout.

Idée 1 — une force répulsive pour diversifier les modes

Le SGMCMC cyclique explore plusieurs modes… en théorie. En pratique, rien n'empêche deux cycles successifs de retomber dans le même bassin — surtout si ce bassin est large et attractif. On gaspille alors des cycles à ré-échantillonner la même solution : c'est le mode collapse.

L'idée de ReBaPL : ajouter une force répulsive qui pousse activement les échantillons du cycle courant loin de ceux des cycles précédents. On modélise cette répulsion par un potentiel répulsif $V(\theta, \theta')$ — grand quand $\theta$ et $\theta'$ se ressemblent, petit quand ils diffèrent — dont la force est le gradient :

En dérivant explicitement ce potentiel, la force prend une forme parlante :

On lit tout dans cette expression. La force pointe dans la direction $\nabla_\theta d_\Theta$ qui augmente la distance (elle éloigne $\theta$ de $\theta'$). Son amplitude explose quand $d_\Theta \to 0$ (deux prompts quasi identiques se repoussent violemment, le $\epsilon$ au dénominateur bornant juste la singularité) et décroît en $1/d_\Theta^{3}$ quand ils s'éloignent. Bref : diversifier sans détruire — la répulsion agit fort sur les doublons et s'efface entre modes déjà distincts.

Figure 7 — Le bilan des forces sur un échantillon $\theta$ : l'attraction du potentiel (bleu) le tire vers le mode, le bruit (rouge) le fait explorer localement, et la répulsion (vert) le pousse loin de l'échantillon du cycle précédent $\theta'$. La somme, plus l'inertie du moment, décide du pas suivant.

Le meilleur moyen de saisir l'effet est un toy example minimal. Prenons un posterior à deux modes (un mélange de deux gaussiennes). Sans répulsion, si la chaîne démarre près du mode de gauche, elle y reste. Avec la répulsion vis-à-vis de l'échantillon précédent, elle est repoussée et découvre le second mode :

Figure 8 — À gauche, sans répulsion : les deux cycles convergent vers le même mode. À droite, avec répulsion : le second cycle est repoussé et capture l'autre mode. C'est tout l'intérêt de ReBaPL, illustré sur un cas jouet.

Ramené à notre fil rouge : les deux modes de la Figure 8, ce sont nos deux « stratégies » de prompt sur EuroSAT — celle qui regarde la couleur des parcelles et celle qui regarde la texture du bâti. Sans répulsion, on échantillonne deux fois la stratégie couleur ; avec répulsion, on récupère les deux.

Reste une question cruciale : dans quel espace mesurer la distance $d_\Theta$ entre deux prompts ? Prenez dix secondes pour y réfléchir avant de lire la suite — le réflexe naturel est un piège.

Idée 2 — repousser dans l'espace des représentations

Le premier réflexe serait de comparer les prompts dans l'espace des poids : $d_\Theta(\theta, \theta') = \lVert \theta - \theta' \rVert$. Mauvaise idée, pour deux raisons :

1. Les symétries de permutation. Dans un réseau de neurones, on peut permuter des neurones (et leurs poids) sans changer du tout la fonction calculée. Deux $\theta$ très éloignés dans l'espace des poids peuvent donc représenter exactement la même fonction. La distance euclidienne sur les poids est trompeuse.
2. La rareté des données. L'espace des poids est de très haute dimension et mal contraint en few-shot ; sa géométrie est difficile à exploiter directement.

La proposition de ReBaPL est élégante : ne comparez pas les paramètres, comparez ce qu'ils produisent. Deux prompts sont « différents » s'ils induisent des distributions de représentations différentes. On note $U_\theta = \{u_{\theta,i}\}_{i=1}^{n}$ l'ensemble des embeddings produits par le modèle paramétré par $\theta$ sur un mini-batch d'images, et l'on mesure :

où $d_{\mathcal{P}(\mathcal{U})}$ est une distance entre distributions (une métrique de probabilité). On capture ainsi la similarité fonctionnelle entre prompts, invariante aux reparamétrisations. La répulsion encourage alors des modes fonctionnellement diversifiés — ce qui est précisément ce qui aide la généralisation.

Figure 9 — À gauche : permuter les neurones cachés donne un $\theta'$ très éloigné de $\theta$ dans l'espace des poids… pour une fonction identique. À droite : on compare plutôt les distributions de représentations $U_\theta$ et $U_{\theta'}$, insensibles à ces symétries.

Il nous faut maintenant des outils pour mesurer une distance entre deux nuages de points (deux distributions échantillonnées). ReBaPL en utilise deux : le MMD et la distance de Wasserstein.

Les métriques de probabilité : MMD et Wasserstein

Le MMD (Maximum Mean Discrepancy). L'idée : deux distributions $p$ et $q$ sont identiques si et seulement si toutes leurs moyennes de features coïncident. On plonge les points dans un espace de features via un noyau $\kappa$ — typiquement un noyau gaussien (RBF), qui mesure une similarité douce entre deux vecteurs :

et l'on compare les moyennes de ces similarités. L'estimateur empirique, à partir de $n$ points de $p$ et $m$ points de $q$, s'écrit :

On lit ces trois termes très simplement : similarité moyenne à l'intérieur de $p$, plus similarité moyenne à l'intérieur de $q$, moins deux fois la similarité croisée entre $p$ et $q$. Si $p$ et $q$ se recouvrent, le terme croisé est grand et le MMD est petit ; si elles sont disjointes, le MMD est grand. Coût de calcul : $\mathcal{O}(n^2)$.

Pour aller plus loin — le MMD comme distance dans un RKHS. Formellement, le MMD est défini comme l'écart maximal des moyennes sur une famille de fonctions tests $\mathcal{F}$ : $\operatorname{MMD}(p,q) = \sup_{f \in \mathcal{F}} \big(\mathbb{E}_{x\sim p}[f(x)] - \mathbb{E}_{y\sim q}[f(y)]\big)$. Lorsque $\mathcal{F}$ est la boule unité d'un espace de Hilbert à noyau reproduisant (RKHS) de noyau $\kappa$, ce sup admet une forme close : $\operatorname{MMD}(p,q)^2 = \lVert \mu_p - \mu_q \rVert^2$, où $\mu_p$ est le mean embedding de $p$. La formule empirique ci-dessus en découle directement.

La distance de Wasserstein (transport optimal). Autre intuition, plus géométrique. Imaginez $p$ comme un tas de sable et $q$ comme un trou à combler. La distance de Wasserstein, c'est le coût minimal pour transporter tout le sable de $p$ vers $q$ — d'où son surnom d'earth mover's distance. On cherche le meilleur plan de transport $\gamma^\star$ (qui dit combien de masse va du point $i$ au point $j$), et le coût est la somme des masses déplacées fois les distances au carré :

où $\Gamma$ est l'ensemble des plans de transport valides — les matrices dont les marges redonnent les deux distributions (masses uniformes $1/n$ et $1/m$ ici) :

Ces contraintes garantissent qu'on déplace toute la masse de $p$ et qu'on remplit exactement $q$, sans en créer ni en perdre. Contrairement au MMD, le Wasserstein tient compte de la géométrie de l'espace (les distances réelles entre points), au prix d'un calcul plus lourd : $\mathcal{O}(n^3)$ pour les solveurs exacts (un programme linéaire), contre $\mathcal{O}(n^2)$ pour le MMD.

Figure 10 — Deux façons de mesurer un écart entre distributions : le MMD compare des moyennes de similarités (noyau, à gauche) ; le Wasserstein cherche le plan de transport optimal de l'une vers l'autre (à droite).

Pour aller plus loin — α-Wasserstein et Sinkhorn. La définition générale, la $\alpha$-Wasserstein, utilise un coût $d(x,y)^\alpha$ ; on prend ici $\alpha = 2$. Le calcul exact passe par un programme linéaire ($\mathcal{O}(n^3)$). Une alternative, la divergence de Sinkhorn, régularise le problème par entropie et tombe à $\mathcal{O}(n^2)$ par itération — mais sur de petits mini-batches, elle demande beaucoup d'itérations pour être précise, si bien que les auteurs conservent le Wasserstein exact.

Point rassurant : ces distances sont calculées sur de petits mini-batches de représentations déjà en cache (32 à 64 échantillons). Le surcoût total (de l'ordre de 700 ms/itération) est négligeable devant les passes avant/arrière du modèle.

L'algorithme complet : rcSGHMC

On assemble tout. ReBaPL propose le rcSGHMC (repulsive cyclical SGHMC) : un SGHMC, planifié de façon cyclique, augmenté d'une force répulsive inter-cycles dans l'espace des représentations. Voici la mise à jour, colorée selon les trois rôles :

Décodons les trois couleurs :

• Bleu — exploration/exploitation. Le moment avec friction et la force du potentiel $\nabla\tilde{U}$, pilotés par le learning rate cyclique $\alpha_t$. Grand $\alpha_t$ = exploration, petit $\alpha_t$ = affinage.
• Rouge — sampling. Le bruit d'échantillonnage, injecté uniquement dans la phase de sampling (l'indicatrice $\mathbf{1}_{[t/T > \beta]}$ le coupe pendant l'exploration).
• Vert — répulsion. La somme des forces répulsives $F$ vis-à-vis des $K$ échantillons du cycle précédent ($c-1$), pondérée par la force de répulsion $\xi$.

La notation à trois indices peut dérouter : $k$ indexe les échantillons, $t$ les itérations à l'intérieur d'un cycle, et $c$ les cycles. Chaque cycle $c = 1, \dots, C$ enchaîne $t = 1, \dots, T$ itérations pour produire $k = 1, \dots, K$ échantillons.

Le papier (et donc cet article) recycle par ailleurs certaines lettres. Ce tableau récapitule tous les symboles et signale les pièges :

En pseudo-code, la boucle d'entraînement ressemble à ceci :

for c in range(1, C + 1):                    # cycles
    for t in range(1, T + 1):                # itérations dans le cycle
        alpha_t = 0.5 * alpha_0 * (cos(pi * ((t - 1) % (T // C)) / (T // C)) + 1)
        grad = grad_potential(theta, minibatch())          # ∇Ũ(θ)
        # force répulsive vis-à-vis des échantillons du cycle précédent
        F = repulsion(theta, samples_prev_cycle) if c > 1 else 0.0
        # bruit injecté uniquement en phase de sampling
        noise = 0.0
        if (t / T) > beta:
            noise = sqrt(2 * (eta - gamma_hat) * alpha_t) * randn_like(theta)
        r = (1 - eta) * r - alpha_t * grad + noise         # moment
        theta = theta + r + xi * F                         # position
    samples.append(theta.detach().clone())   # 1 échantillon par cycle (K = 1)

Et la répulsion elle-même, calculée dans l'espace des représentations :

def repulsion(theta, prev_thetas, images):
    # U_θ : distribution des représentations produites par θ sur un mini-batch
    U = image_encoder(images, prompts=theta)               # (n, d)
    force = 0.0
    for theta_prev in prev_thetas:
        U_prev = image_encoder(images, prompts=theta_prev)
        d2 = mmd_squared(U, U_prev)                         # ou wasserstein
        V = 1.0 / (d2 + eps)                                # potentiel répulsif
        force = force - grad(V, wrt=theta)                  # F = -∇_θ V
    return force

À la fin, on ne garde pas un seul prompt. Ce qu'on veut vraiment prédire, c'est la distribution prédictive a posteriori — la moyenne de tous les modèles pondérée par leur probabilité sous le posterior :

Cette intégrale est incalculable… mais nos $C \times K$ échantillons du posterior en sont précisément une estimation Monte-Carlo. L'ensembling de ReBaPL n'est donc pas un artifice : c'est l'approximation naturelle du prédictif bayésien, avec une pondération uniforme $\omega_{c,k} = 1/(C \cdot K)$.

C'est là que la diversité paie : plus les prompts échantillonnés sont fonctionnellement variés (grâce à la répulsion), plus la moyenne couvre de modes et plus elle est robuste. L'inférence sur les $C \cdot K$ modèles est massivement parallélisable, donc le surcoût reste modéré.

Figure 11 — La méthode complète en un coup d'œil : chaque cycle explore (learning rate élevé) puis échantillonne (faible + bruit) un mode, en étant repoussé des échantillons des cycles précédents via $d(U_\theta, U_{\theta'})$ ; l'ensembling final moyenne les prédictions des C échantillons.

Un mot sur la modularité, qui est un argument fort du papier : rcSGHMC est un remplacement plug-and-play de l'optimiseur. On peut le brancher au-dessus de n'importe quelle méthode de prompt learning MLE existante — les auteurs le font sur MaPLe et MMRL — sans toucher à l'architecture. ReBaPL transforme ainsi n'importe quelle méthode ponctuelle en sa version bayésienne.

Partie IV — Est-ce que ça marche ?

Où l'on vérifie que tout cela paie : trois protocoles d'évaluation, onze datasets, deux méthodes hôtes — et des ablations qui isolent ce qui compte vraiment.

Le dispositif expérimental

Backbone CLIP ViT-B/16 (l'architecture que nous décortiquons dans notre deep-dive dédié), régime 16-shot (16 images étiquetées par classe). ReBaPL est évalué en plug-and-play sur MaPLe et MMRL, selon trois protocoles standards du domaine :

• Base → Novel : sur chaque dataset, on entraîne sur la moitié des classes (base) et on teste aussi sur l'autre moitié (novel), jamais vue. On mesure la moyenne harmonique (HM) entre les deux — un bon compromis oblige à ne pas sacrifier l'une pour l'autre.
• Cross-dataset transfer : on entraîne sur ImageNet, puis on évalue sur 10 autres datasets sans ré-entraîner.
• Domain generalization : on entraîne sur ImageNet et on teste sur ses variantes décalées (ImageNet-V2, -Sketch, -A, -R).

Le tout sur 11 datasets de classification (ImageNet, Caltech101, OxfordPets, StanfordCars, Flowers102, Food101, FGVCAircraft, SUN397, UCF101, DTD, EuroSAT).

Les résultats

En base → novel (moyenne sur les 11 datasets), ajouter ReBaPL améliore systématiquement la baseline, sur les classes base comme, souvent, sur les novel :

Soit +1.15 de HM pour MaPLe et +0.79 pour MMRL. Le détail par dataset est plus parlant que la moyenne — et c'est notre fil rouge qui rafle la mise. Sur EuroSAT, MMRL + ReBaPL fait bondir la précision novel de 77.20 à 83.63 (+6.43) et la moyenne harmonique de 85.50 à 89.71 (+4.21) ; côté MaPLe, +2.46 de HM. La boucle est bouclée : c'est exactement le scénario annoncé en introduction — là où le domaine est loin du pré-entraînement, le posterior des prompts est riche en modes divers, et l'échantillonner (plutôt que d'en optimiser un seul) rapporte gros. Sur ImageNet, MaPLe + ReBaPL gagne +1.83 en novel et +1.51 de HM (70.74 → 72.25). À l'inverse, sur des datasets déjà quasi saturés (OxfordPets, Caltech101), les marges sont minces voire légèrement négatives en novel : logique, il reste surtout de la place à prendre là où la généralisation est difficile.

En cross-dataset (entraîné sur ImageNet, évalué sur 10 autres datasets sans ré-entraînement — moyenne des cibles), même tendance :

Là encore, le gain se concentre là où le transfert est dur : EuroSAT (+5.20 pour MaPLe, +3.14 pour MMRL), Flowers102 (+1.50 / +1.04), UCF101 (+1.60 / +0.37) et FGVCAircraft (+1.14 pour MaPLe). Sur les cibles « faciles » et proches d'ImageNet, l'écart est faible mais reste positif.

Enfin, la domain generalization teste la robustesse au décalage de domaine : entraîné sur ImageNet, évalué sur quatre variantes volontairement décalées (ImageNet-V2 rééchantillonné, -Sketch dessins, -A adversarial, -R rendus artistiques).

ReBaPL améliore les quatre cibles décalées pour les deux méthodes, et — c'est le point crucial — sans rien sacrifier sur le domaine source : l'accuracy ImageNet monte aussi (+0.70 pour MaPLe, +0.87 pour MMRL). MaPLe + ReBaPL décroche même le meilleur score sur ImageNet-A (49.73), la variante la plus adversariale. On gagne donc en robustesse hors-domaine sans payer sur le domaine d'origine — exactement ce qu'on attend d'une meilleure caractérisation du posterior.

Ce qui compte vraiment : les ablations

Les ablations sont éclairantes car elles isolent la contribution de chaque idée (moyenne sur les 11 datasets, sur MaPLe) :

Deux enseignements :

1. L'échantillonnage bayésien seul aide déjà (+0.56 de HM sans répulsion) : rien que sampler le posterior au lieu d'optimiser un point réduit l'overfitting.
2. La répulsion ajoute une couche de gain (+0.5 à +0.6 de HM de plus), surtout sur les classes novel — ce qui confirme qu'explorer plus de modes améliore la généralisation. Le choix MMD vs Wasserstein est presque indifférent (0.08 % d'écart) : c'est le principe de répulsion qui compte, pas la métrique précise.

Les analyses complémentaires précisent le tableau :

• Force de répulsion $\xi$ — c'est un compromis en cloche : trop faible, elle n'explore pas assez et le gain est marginal ; trop forte, elle domine la dynamique et éjecte les échantillons hors des modes (le papier illustre ce régime où la répulsion écrase l'attraction du posterior). Les valeurs retenues sont d'ailleurs petites : $\xi = 10^{-3}$ (MaPLe), $10^{-4}$ (MMRL).
• Nombre de cycles $C$ — c'est le levier principal. Sur DTD, la HM passe d'environ 67.5 % à $C=1$ (un seul échantillon, à peine mieux que sans répulsion) à ≈ 70.5 % à $C=3$, puis ≈ 72 % vers $C=10$ avant de saturer. Logique : plus de cycles = plus de modes distincts capturés.
• Nombre d'échantillons par cycle $K$ — au contraire, il compte peu. Sur Flowers102, passer de $K=1$ à $K=5$ ne bouge la HM que de 84.07 à 84.22. La leçon : ce qui aide, c'est la diversité entre modes (portée par $C$ et la répulsion), pas d'empiler des échantillons corrélés dans un même mode. D'où le choix $K=1$ dans le papier.
• Diversité effective — une matrice de distances de Wasserstein entre les représentations de différents cycles montre noir sur blanc que la répulsion produit des modèles fonctionnellement plus éloignés (distances plus grandes) que sans répulsion. La mécanique fait donc bien ce qu'elle promet.

Côté coût, enfin, la répulsion se calcule sur des mini-batches de représentations déjà en cache : $\mathcal{O}(n^2)$ pour le MMD, $\mathcal{O}(n^3)$ pour le Wasserstein, soit ≈ 700 ms/itération — négligeable devant les passes du modèle. À l'inférence, l'ensembling sur 3 cycles ajoute peu (≈ 276 ms contre 242 ms pour MaPLe seul) et se parallélise trivialement.

En pratique. Pour reproduire : MaPLe + ReBaPL utilise $\alpha \approx 0.002$, 3 cycles, répulsion MMD ($\xi = 10^{-3}$, batch de répulsion 32) ; MMRL + ReBaPL utilise $\alpha \approx 0.001$, 3 cycles, répulsion Wasserstein ($\xi = 10^{-4}$, batch 64), avec un burn-in AdamW en début de cycle avant de basculer sur SGHMC. Point important relevé par les auteurs : MaPLe entraîné trop longtemps (15 epochs) overfit (base/novel 97.2/70.9) alors qu'à 5 epochs il généralise mieux (96.3/73.3) — le gain de ReBaPL vient donc bien de l'échantillonnage du posterior, pas d'un simple surplus de calcul.

Conclusion et perspectives

ReBaPL réussit un joli tour de force conceptuel : transformer le prompt learning d'un problème d'optimisation (trouve le meilleur prompt) en un problème d'inférence (décris la distribution des bons prompts), tout en restant plug-and-play sur les méthodes existantes. Les deux ingrédients qui font la différence :

• un échantillonneur rcSGHMC qui, grâce au schedule cyclique et à la répulsion, explore réellement la nature multimodale du posterior des prompts ;
• une répulsion mesurée dans l'espace des représentations — via MMD ou Wasserstein — qui contourne les pièges de l'espace des poids et encourage une diversité fonctionnelle, celle qui aide vraiment la généralisation.

Les limites sont assumées : un surcoût de calcul (plusieurs échantillons à entraîner et à assembler), et des hyperparamètres supplémentaires ($\xi$, $\beta$, $C$) à régler. Les pistes futures évoquées incluent d'autres métriques de probabilité (Sinkhorn, mesures info-théoriques) et des mécanismes cycliques adaptatifs, qui ajusteraient automatiquement le nombre de cycles selon la diversité atteinte.

Le message à retenir dépasse le prompt learning : dès qu'un modèle est appris avec peu de données et un paysage de perte plat et multimodal, parier sur un seul minimum est fragile. Échantillonner plusieurs solutions diverses — et les faire diverger fonctionnellement — est une recette de robustesse élégante et générale.

Cet article ouvre une série sur la robustesse en faible régime de données. Le fil : en few-shot, une solution ponctuelle est un estimateur à trop haute variance — mieux vaut en considérer plusieurs. ReBaPL le fait par un posterior bayésien répulsif ; les épisodes suivants montrent que la lecture fréquentiste (moyenner réduit la variance) et la lecture bayésienne finissent par se rejoindre.

Pour continuer

• Épisode suivant de la série — Robustesse en faible régime (2) — SVGD : d'où vient la force de répulsion de ReBaPL. On y voit que « des particules qui se repoussent pour couvrir un posterior » est une idée antérieure et générale — le socle conceptuel que ReBaPL applique aux prompts.
• Le papier : ReBaPL sur arXiv — les annexes valent le détour (toy example détaillé, ablations complètes, théorie MMD/transport optimal).
• Le code officiel : github.com/SigmaNova/ReBaPL — pour brancher rcSGHMC sur votre propre méthode de prompt learning.
• Les briques, si besoin de réviser : notre article sur la descente de gradient ; CoOp et MaPLe pour le prompt learning ; Welling & Teh (2011) pour SGLD ; Chen et al. (2014) pour SGHMC ; Zhang et al. (2019) pour le SGMCMC cyclique.

Sources : Bendou, Ezzahir, Montesuma et al., « ReBaPL: Repulsive Bayesian Prompt Learning », 2026. Références principales : CLIP (Radford et al., 2021), CoOp/CoCoOp (Zhou et al., 2022), MaPLe (Khattak et al., 2023), MMRL (Guo et al., 2025), SGLD (Welling & Teh, 2011), SGHMC (Chen et al., 2014), SGMCMC cyclique (Zhang et al., 2019), MMD (Gretton et al., 2012), transport optimal (Villani, 2008).