Momentum Contrast for Unsupervised Visual Representation Learning
- Publication
- CVPR 2020Conférence
- Premier dépôt sur arXiv
- arXiv:1911.05722
Citer cet article · BibTeX
La référence correspond à la version liée et cite les auteurs de l’article original.
@misc{contrastivelearningmocov12019,
title = {{Momentum Contrast for Unsupervised Visual Representation Learning}},
author = {Kaiming He and Haoqi Fan and Yuxin Wu and Saining Xie and Ross Girshick},
year = {2019},
eprint = {1911.05722},
archivePrefix = {arXiv},
url = {https://arxiv.org/abs/1911.05722}
}
Tant d'équipes ont déjà proposé leur lecture de l'apprentissage contrastif que Facebook AI Research, FAIR, ne pouvait guère rester à l'écart.
Ses chercheurs entrent donc dans la discussion avec une idée : la clé pourrait être le momentum !
Définition du problème
En TAL, les mots et les unités sous-lexicales forment un espace discret et peuvent servir de « dictionnaire ». Les images occupent au contraire un espace continu de grande dimension, sans découpage naturel comparable aux mots. Construire un dictionnaire pour apprendre par contraste suppose donc de choisir dynamiquement des clés positives et négatives.
Les articles que nous avons déjà lus donnent de bons résultats, mais deux difficultés subsistent :
- La taille du dictionnaire est souvent limitée par le lot ou la mémoire GPU.
- Quand les paramètres du réseau changent, les anciens vecteurs du dictionnaire peuvent ne plus être cohérents avec les nouveaux.
La banque mémoire d'un article précédent permet d'agrandir le dictionnaire. Mais ses vecteurs mémorisés ont été calculés avec d'anciens paramètres et peuvent manquer de cohérence avec ceux produits maintenant.
Pourquoi ne pas se limiter au mini-lot courant ?
Cela ne suffit pas non plus.
Les caractéristiques d'un même lot sont plus cohérentes, mais la taille pratique du lot en vision limite le nombre de négatifs disponibles. Or trop peu de négatifs peut nuire à l'apprentissage contrastif.
Les auteurs cherchent donc à augmenter la taille du dictionnaire tout en préservant la cohérence de ses représentations. Leur réponse est Momentum Contrast (MoCo).
En bref : une file conserve beaucoup de négatifs, et un encodeur des clés évolue lentement par mise à jour avec momentum pour rester compatible avec les clés historiques.
Est-ce vraiment aussi simple ?
Regardons les détails.
Résolution du problème
MoCo repose sur l'hypothèse qu'un dictionnaire riche en négatifs et dont l'encodage reste assez cohérent au fil de l'entraînement aide à apprendre de meilleures représentations.
Le schéma résume sa conception :
Une requête et une clé sont calculées par deux encodeurs. L'encodeur des requêtes traite le lot courant ; l'encodeur des clés calcule la clé positive du lot courant. Les clés des lots précédents demeurent dans la file et servent de négatifs. Pour réduire l'écart entre anciennes et nouvelles clés, les auteurs mettent l'encodeur des clés à jour lentement :
où et sont les paramètres des encodeurs de requêtes et de clés, et est le coefficient de momentum, par exemple 0,999. Les paramètres de l'encodeur des clés suivent ainsi ceux de l'encodeur des requêtes plus progressivement, ce qui limite les variations d'encodage au sein du dictionnaire.
Les auteurs ajoutent une file pour conserver les nombreux négatifs.
Elle peut être bien plus grande qu'un lot. À chaque itération, les clés calculées sur le nouveau lot entrent en fin de file, tandis que les plus anciennes en sortent. Le dictionnaire reste vaste et diversifié sans qu'il faille réencoder tout le jeu de données à chaque mise à jour.
Déroulement de l'algorithme
Les auteurs ont peut-être deviné que tout le monde n'aurait pas la patience de lire le texte en entier : ils donnent le pseudo-code complet. Le décortiquer revient presque à parcourir toute la méthode.
Suivons-le ligne par ligne :
# f_q, f_k: encoder networks for query and key
# queue: dictionary as a queue of K keys (CxK)
# m: momentum
# t: temperature
f_k.params = f_q.params # initialize
- Les paramètres de l'encodeur des clés
f_ksont initialisés avec ceux de l'encodeur des requêtesf_q.- Ils sont identiques au départ ; ensuite, le premier suit lentement le second par momentum.
for x in loader: # load a minibatch x with N samples
- Un chargeur de données lit un mini-lot
xde N exemples.- En pratique,
loaderpeut être unDataLoaderPyTorch qui fournit les lots successifs.
- En pratique,
x_q = aug(x) # a randomly augmented version
x_k = aug(x) # another randomly augmented version
- On applique deux augmentations aléatoires aux mêmes images
x.- Recadrage, retournement et perturbation de couleur produisent deux vues
x_qetx_kde chaque image. x_qva à l'encodeur des requêtes,x_kà celui des clés : les deux vues forment un couple positif.
- Recadrage, retournement et perturbation de couleur produisent deux vues
q = f_q.forward(x_q) # queries: NxC
k = f_k.forward(x_k) # keys: NxC
- Chaque encodeur produit les caractéristiques de sa vue.
qetkont chacun la formeN x C: N exemples, avec C caractéristiques par exemple.
k = k.detach() # no gradient to keys
k.detach()arrête la propagation du gradient à traversk.- L'encodeur des clés est mis à jour par momentum, pas par rétropropagation.
- On évite ainsi que le graphe de calcul remonte jusqu'à ses paramètres.
# positive logits: Nx1
l_pos = bmm(q.view(N,1,C), k.view(N,C,1))
- Ce calcul donne les logits positifs.
- Les vues
q.view(N,1,C)etk.view(N,C,1)permettent le produit matriciel par lotsbmm. - Le résultat a la forme
(N,1,1), assimilable à(N,1): un produit scalaire entre les deux vues de chaque image.
- Les vues
# negative logits: NxK
l_neg = mm(q.view(N,C), queue.view(C,K))
- On calcule les logits négatifs.
queueest une matrice(C x K)de K clés à C dimensions.- Le produit de
q.view(N,C)etqueue.view(C,K)produit(N,K), soit la similarité de chaque requête avec les K clés conservées. - Ces clés viennent des lots antérieurs et servent de négatifs pour la requête courante dans cette tâche de substitution.
# logits: Nx(1+K)
logits = cat([l_pos, l_neg], dim=1)
- On concatène les logits positifs et négatifs.
- Chaque ligne de
(N,1+K)contient un positif en position 0 et K négatifs ensuite.
- Chaque ligne de
# contrastive loss, Eqn.(1)
labels = zeros(N) # positives are the 0-th
loss = CrossEntropyLoss(logits/t, labels)
- L'entropie croisée calcule la perte contrastive, proche d'InfoNCE.
labels=zeros(N)place le positif de chacun des N exemples à l'indice0.- La division des logits par la température
trègle la concentration du Softmax. - La perte favorise donc le choix de la position positive parmi
1+Kpositions.
# SGD update: query network
loss.backward()
update(f_q.params)
- La rétropropagation et l'optimiseur mettent à jour l'encodeur des requêtes
f_q.loss.backward()calcule les gradients ;update(f_q.params)applique la mise à jour, par exemple avec SGD.
# momentum update: key network
f_k.params = m*f_k.params + (1-m)*f_q.params
- L'encodeur des clés est mis à jour par momentum :
- Un proche de 1, par exemple 0,999, rend son évolution lente.
- Les clés anciennes et nouvelles sont ainsi calculées avec des encodeurs plus proches les uns des autres.
# update dictionary
enqueue(queue, k) # enqueue the current minibatch
dequeue(queue) # dequeue the earliest minibatch
- On met à jour le dictionnaire, donc la file :
enqueue(queue,k)ajoute les N clés courantes en fin de file.dequeue(queue)retire les plus anciennes afin de garder la capacité K.- La file conserve ainsi des clés récentes et diverses pour les itérations suivantes.
Retenons les points principaux du pseudo-code :
- Deux encodeurs
f_qetf_k: le premier calcule les requêtes du lot ; le second calcule leurs clés positives, tandis que les clés anciennes restent dans la file comme négatifs. Aucun gradient ne met directement à jourf_k. - Mise à jour par momentum : les paramètres de
f_ksuivent lentement ceux def_q, pour réduire les incohérences dues aux changements rapides du réseau. - Grand dictionnaire sous forme de file : seules les nouvelles clés du lot doivent être encodées ; elles entrent dans la file quand les plus anciennes en sortent. On peut ainsi conserver beaucoup de négatifs sans banque mémoire couvrant tout le jeu de données.
- Perte contrastive : les produits scalaires avec la clé positive et les négatifs donnent les logits, puis un Softmax et une entropie croisée réalisent une perte de type InfoNCE.
L'algorithme associe donc un grand dictionnaire actualisé progressivement à un encodeur des clés stabilisé par momentum, afin d'apprendre des représentations visuelles utiles pour d'autres tâches.
Tâche de substitution
L'objectif de l'article n'est pas de créer une nouvelle tâche de substitution. MoCo propose un mécanisme général pour construire un dictionnaire grand et cohérent destiné à l'apprentissage contrastif.
Les expériences utilisent la discrimination d'instances : deux vues augmentées de la même image forment un couple positif ; des vues d'autres images servent de négatifs.
Un problème rencontré par les auteurs mérite toutefois notre attention : la triche par Batch Normalization, ou BN cheating.
Dans un lot, Batch Normalization partage des statistiques entre exemples. Une requête et sa clé positive pourraient ainsi échanger indirectement de l'information par ces statistiques, ce qui réduirait la perte sans améliorer réellement les représentations.
Les auteurs emploient donc Shuffling BN : sur plusieurs GPU, ils mélangent l'ordre du lot des clés avant de le répartir entre GPU, puis rétablissent l'ordre après encodage. Le lot des requêtes reste dans son ordre initial. Requête et clé positive utilisent ainsi des statistiques BN de sous-lots différents, ce qui réduit cette fuite d'information.
Discussion
Choisissons quelques figures et tableaux pour juger MoCo ; l'article donne les résultats complets.
Robustesse des caractéristiques
Les auteurs évaluent leurs caractéristiques avec une classification linéaire.
- Préentraînement autosupervisé : entraînement MoCo sans étiquettes sur ImageNet-1M, ou IN-1M, pour obtenir un extracteur de caractéristiques.
- Extracteur figé : les couches convolutives sont gelées et seule une couche entièrement connectée finale avec Softmax est entraînée avec les étiquettes, pendant 100 époques.
- Évaluation : précision de classification top-1 avec un seul recadrage sur la validation ImageNet.
Ce protocole courant en vision sonde les caractéristiques sans les effets d'un réglage fin complet.
Trois façons de gérer la perte contrastive sont comparées :
- End-to-end : les encodeurs de requêtes et de clés reçoivent tous deux un gradient.
- Memory bank : les caractéristiques des clés sont conservées, mais les anciennes peuvent diverger de celles du réseau actualisé.
- MoCo : un encodeur des clés mis à jour par momentum et une grande file de négatifs.
Les résultats figurent ici :
- La précision des trois méthodes augmente avec la taille du dictionnaire dans les configurations testées, signe qu'un dictionnaire plus grand peut couvrir davantage de cas.
- End-to-end est limité par la taille du mini-lot. Avec huit cartes Volta de 32 Go, les auteurs atteignent environ 1 024 exemples par lot ; l'agrandir encore soulève des difficultés d'entraînement.
- Memory bank atteint 58,0 % pour , contre 60,6 % pour MoCo, soit 2,6 points de pourcentage de moins. Les auteurs suggèrent que le décalage entre caractéristiques anciennes et récentes peut jouer un rôle.
- MoCo obtient les meilleurs résultats dans les grandes configurations du graphique, ce qui soutient l'idée d'un dictionnaire à la fois grand et assez cohérent.
Effet du coefficient de momentum
Les auteurs étudient ensuite l'effet de .
Avec ResNet-50 et un dictionnaire de , ils rapportent :
| momentum | 0 | 0.9 | 0.99 | 0.999 | 0.9999 |
|---|---|---|---|---|---|
| accuracy (%) | fail | 55.2 | 57.8 | 59.0 | 58.9 |
Le coefficient influe nettement sur la qualité des caractéristiques :
- À , la précision est bien plus faible.
- À , l'entraînement échoue.
Les valeurs de 0,99 à 0,9999 donnent de meilleurs résultats ici, avec un maximum proche de 0,999. Cela cadre avec l'idée qu'un encodeur des clés évoluant lentement stabilise le dictionnaire.
Comparaison avec d'autres méthodes
Les auteurs préentraînent MoCo avec ResNet-50 et des versions élargies 2× et 4×, puis comparent le nombre de paramètres et la précision de classification linéaire.
- MoCo + R50 : 60,6 % en top-1.
- MoCo + R50w4× : 68,6 % avec un modèle plus grand.
Le tableau suivant précise les résultats : pour le ResNet-50 standard, d'environ 24 millions de paramètres, les 60,6 % de MoCo dépassent les autres modèles de taille comparable indiqués.
Conclusion
MoCo est un mécanisme contrastif simple et efficace. Grâce à la mise à jour par momentum et à la file, il maintient un grand dictionnaire dont les clés restent relativement cohérentes sans supervision par étiquettes.
Cette conception se prête à plusieurs tâches et échelles ; elle offre une solution utile pour apprendre des représentations visuelles en conciliant coût et performance dans les expériences de l'article.