Retour à la bibliothèque
arXiv 2022CVPR 2023Transformers visuelsNotes de lecture

FlexiViT

La liberté des tailles de patches

Article original

FlexiViT: One Model for All Patch Sizes

Auteurs de l’article

Lucas Beyer · Pavel Izmailov · Alexander Kolesnikov …

Afficher les 10 auteurs

Lucas Beyer · Pavel Izmailov · Alexander Kolesnikov · Mathilde Caron · Simon Kornblith · Xiaohua Zhai · Matthias Minderer · Michael Tschannen · Ibrahim Alabdulmohsin · Filip Pavetic

Publication
CVPR 2023Conférence
Premier dépôt sur arXiv
arXiv:2212.08013
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{visiontransformersflexivit2022,
  title = {{FlexiViT: One Model for All Patch Sizes}},
  author = {Lucas Beyer and Pavel Izmailov and Alexander Kolesnikov and Mathilde Caron and Simon Kornblith and Xiaohua Zhai and Matthias Minderer and Michael Tschannen and Ibrahim Alabdulmohsin and Filip Pavetic},
  year = {2022},
  eprint = {2212.08013},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2212.08013}
}
Sur cette page

Regardons aujourd'hui un travail de Google Research.

Définir le problème

L'essor des Vision Transformers (ViT) marque un changement de paradigme dans la représentation visuelle.

On découpe l'image en patches de taille fixe, puis la self-attention traite leurs relations d'ensemble, au lieu de s'appuyer sur les filtres convolutifs des CNN traditionnels.

Mais derrière cette révolution, un choix essentiel reste longtemps considéré comme un hyperparamètre fixe : la taille des patches.

Pourquoi personne ne remet-il en question ce choix de Patch Size ?

Les auteurs soulignent un paradoxe :

  • La taille des patches change nettement le coût de calcul et les performances de classification.
  • Pourtant, on ne peut généralement pas la modifier sans réentraîner le modèle.

Pour rendre ViT plus adaptable aux ressources disponibles et plus facile à transférer, pourrait-on alors :

prendre « un même jeu de paramètres » et lui faire accepter « plusieurs tailles de patches » ?

Résoudre le problème

Avec cet algorithme sous les yeux, nous avons presque déjà lu tout l'article !

Regardons-le ligne par ligne.

Tirer au hasard la taille des patches

python
1 model = ViT(...)
2 for batch in data:
3     ps = np.random.choice([8, 10, ..., 40, 48])
4     logits = model(batch["images"], (ps, ps))
5     # [...] backprop and optimize as usual

Ces cinq lignes résument le comportement d'entraînement essentiel de FlexiViT :

  • Ligne 3 : avant chaque batch, tirer une taille de patch ps au hasard.
  • Ligne 4 : passer cette taille au modèle pour la propagation avant.
  • Ligne 5 : employer la rétropropagation habituelle, sans autre changement.

En tirant la taille des patches pendant l'entraînement, le modèle rencontre des longueurs de séquence, des encodages de position et des charges de calcul variés. Il apprend ainsi à conserver des prédictions stables d'une taille à l'autre.

Réorganisation dynamique dans le modèle

python
7 class ViT(nn.Module):
8     def __call__(self, image, patchhw):
9         # Patchify, flexibly:
10        w = self.param("w_emb", (32, 32, 3, d))
11        b = self.param("b_emb", d)
12        w = resize(w, (*patchhw, 3, d))
13        x = conv(image, w, strides=patchhw) + b

Ce passage traite le plongement initial des patches dans ViT, correspondant à la couche Conv2d(patch_size, d) de l'architecture d'origine :

  • Ligne 10 : créer par défaut des poids de plongement w de taille 32×32.
  • Ligne 12 : redimensionner w selon la taille de patch du batch.
  • Ligne 13 : avec ces poids redimensionnés, découper l'image par convolution dont le pas est patchhw.

Autrement dit, la découpe en patches devient dynamique plutôt que statique.

Il n'est plus nécessaire d'entraîner un embedding distinct pour chaque taille : un même ensemble de paramètres sert de base, puis un rééchantillonnage, PI-resize ou bilinéaire, l'adapte aux tailles voulues.

Encodage de position redimensionnable

python
14        # Add flexible position embeddings:
15        pe = self.param("posemb", (7, 7, d))
16        pe = resize(pe, (*x.shape[1:3], d))
17        return TransformerEncoder(...)(x + pe)

Le traitement des positions ressemble à celui des embeddings de patches :

  • Partir d'un posemb au format 7×7.
  • Le redimensionner à la grille de tokens actuelle, déterminée par patchhw.
  • L'ajouter à x avant l'encodeur Transformer.

Le sens spatial des positions n'est plus lié à une seule taille. Il peut suivre la longueur de la séquence et la structure de la grille, tout en conservant la self-attention du ViT initial et sa compatibilité avec les tâches aval.

Comment bien redimensionner les poids ?

Quand on accepte plusieurs tailles de patches, il est facile d'oublier que le produit scalaire entre les poids de patch embedding et le patch d'entrée change lui aussi avec la taille.

Prenons un patch d'entrée x∈Rp×px \in \mathbb{R}^{p \times p} et ses poids de plongement ω∈Rp×p\omega \in \mathbb{R}^{p \times p}.

Dans un ViT ordinaire, le token vient de leur produit scalaire :

e=⟨x,ω⟩e = \langle x, \omega \rangle

Mais si nous agrandissons xx et ω\omega par interpolation bilinéaire jusqu'à 2p×2p2p \times 2p, alors :

⟨x,ω⟩≈14⟨resizep2p(x),resizep2p(ω)⟩\langle x, \omega \rangle \approx \tfrac{1}{4} \langle \text{resize}^{2p}_{p}(x), \text{resize}^{2p}_{p}(\omega) \rangle

Le nouveau produit scalaire vaut donc environ quatre fois l'ancien. La norme du token varie avec la taille du patch, ce qui perturbe son sens.

Ce changement d'échelle peut gêner l'entraînement et la généralisation entre tailles de patches.

Pour garder le même résultat avant et après redimensionnement, on voudrait :

  • conserver la valeur du token, même si le patch et son embedding sont tous deux redimensionnés.
⟨x,ω⟩=?⟨Bx,ω^⟩\langle x, \omega \rangle \overset{?}{=} \langle Bx, \hat{\omega} \rangle

Ici, le redimensionnement bilinéaire peut s'écrire comme une application linéaire de matrice BB :

resizepp∗(o)=Bpp∗⋅vec(o)\text{resize}^{p^*}_{p}(o) = B^{p^*}_{p} \cdot \text{vec}(o)

Les auteurs proposent donc une transformation des poids plus cohérente avec ce produit scalaire :

  • Pseudo-Inverse Resize (PI-resize).

Son objectif est :

ω^=arg⁡min⁡ω^Ex∼X[(⟨x,ω⟩−⟨Bx,ω^⟩)2]\hat{\omega} = \arg\min_{\hat{\omega}} \mathbb{E}_{x \sim X} [\left( \langle x, \omega \rangle - \langle Bx, \hat{\omega} \rangle \right)^2]

Lorsque p∗≥pp^* \geq p, on peut utiliser la pseudo-inverse pour obtenir :

ω^=Pω\hat{\omega} = P \omega

avec :

P=B(B⊤B)−1=(B⊤)+P = B(B^\top B)^{-1} = (B^\top)^+

Ainsi, pour n'importe quel xx :

⟨x,ω⟩=⟨Bx,ω^⟩\langle x, \omega \rangle = \langle Bx, \hat{\omega} \rangle

Le produit scalaire du patch embedding est donc exactement préservé.

Dans la figure ci-dessous, les auteurs partent d'un ViT-B/8, redimensionnent conjointement les poids de patch embedding et les images d'entrée, puis mesurent la précision.

Ils comparent plusieurs façons de faire :

  • Vanilla resize : interpolation bilinéaire directe.
  • Norm heuristic : compensation de la norme des poids après redimensionnement.
  • Area heuristic : rééchelonnement selon le rapport des surfaces.
  • PI-resize : ajustement issu de l'égalité des produits scalaires.

PI-resize est la seule méthode de la figure qui conserve presque toute la précision quand on agrandit. Lorsqu'on réduit la taille, ses performances restent aussi les plus stables, sans oscillations aussi fortes.

Le monde des représentations de FlexiViT

FlexiViT a été conçu pour conserver de bonnes prédictions avec plusieurs tailles de patches.

Mais cela soulève une question plus profonde :

Les représentations internes du modèle restent-elles cohérentes quand la taille des patches change ?

Pour examiner cette stabilité, les auteurs utilisent deux méthodes de comparaison courantes :

  • CKA (Centered Kernel Alignment) : mesurer la ressemblance entre les sorties de différentes couches du réseau.
  • Arc-Cosine + t-SNE : convertir les similarités en distances, puis visualiser les représentations.

Ils observent ainsi si les cartes de caractéristiques produites aux différentes couches restent comparables pour plusieurs tailles de patches, par exemple lorsque la grille compte 5, 10 ou 30 positions par côté.

La figure ci-dessous fait ressortir plusieurs observations :

  • Début stable : avant le MLP de la couche 6, les représentations des couches 0 à 6 restent assez similaires, quelle que soit la taille des patches.
  • Milieu divergent : au MLP de la couche 6, les représentations se séparent nettement selon la taille de grille.
  • Fin qui se rapproche : les dernières couches, surtout la couche 11, retrouvent davantage de cohérence.
  • Token CLS stable : les patch tokens changent de distribution avec la grille, mais les représentations du token CLS qui sert à classer restent fortement alignées entre tailles.

Cette analyse révèle quelque chose d'intéressant :

FlexiViT ne « comprime » pas de force toutes les entrées en une représentation identique. Ses couches intermédiaires peuvent suivre des chemins adaptés à chaque résolution, puis revenir à des sorties de classification proches.

Voilà aussi une piste pour comprendre sa capacité à traiter plusieurs tailles de patches :

Le modèle apprend à « prendre des routes différentes pour arriver au même point ».

Discussion

La place manque pour reproduire ici tous les graphiques et tableaux de l'article.

Nous allons donc choisir quelques résultats intéressants. Pour le reste, le lecteur pourra consulter l'article original.

Vue d'ensemble des tâches

La figure montre le transfert de FlexiViT vers plusieurs tâches : classification d'images, segmentation sémantique, recherche image-texte et détection d'objets à vocabulaire ouvert.

Les auteurs prennent un FlexiViT-B préentraîné, puis le transfèrent séparément avec une taille de patch fixe, /16 ou /30, pour le fine-tuning et l'inférence. Ils le comparent à deux ViT-B préentraînés chacun avec la taille correspondante, dans le même régime de distillation.

Dans l'ensemble, FlexiViT reste proche du ViT préentraîné à la taille choisie. À /16, il fait un peu mieux sur certaines tâches ; à /30, un peu moins sur d'autres. Classification, PQ, AP, R@1 et mIoU sont des métriques différentes : il serait trompeur de les réunir en un seul écart en points de pourcentage.

Dans les tâches et les configurations montrées, le préentraînement à plusieurs tailles conserve donc approximativement la qualité des prédictions.

Surtout, ces performances viennent d'un seul jeu de poids.

Traditionnellement, prendre en charge diverses contraintes de calcul ou divers scénarios demande souvent plusieurs ViT entraînés séparément. Ici, FlexiViT offre une autre possibilité : des performances proches dans ces comparaisons, avec moins de backbones préentraînés à maintenir.

Pour une application qui doit choisir entre « meilleures performances » et « économies de ressources », un FlexiViT peut donc servir de backbone commun.

Transfert rapide et souplesse à l'inférence

Cette figure illustre une propriété intéressante pour le déploiement :

  • Le modèle peut être adapté avec une courte séquence de tokens, puis évalué sur une grille plus dense pour obtenir de meilleures performances.

Les auteurs font le fine-tuning d'un FlexiViT-B et d'un ViT-B/30 sur ImageNet-1K en utilisant seulement une grille 8×8, puis les testent sur plusieurs densités de grille.

Quand la grille devient plus dense, la précision du ViT-B/30 ordinaire monte légèrement puis chute vite. Celle de FlexiViT passe de 81,8 % à 85,3 % entre 8×8 et 24×24, soit un gain de 3,5 points de pourcentage.

Le graphique de droite compare ensuite le même FlexiViT-B après fine-tuning sur des grilles 8×8, 15×15 et 30×30, avec des tests couvrant à nouveau plusieurs tailles.

Les trois modèles adaptés peuvent employer une grille plus dense à l'inférence ; les courbes des adaptations à 8×8 et 15×15 redescendent toutefois légèrement tout au bout. Le gain n'est pas monotone.

Cela suggère une stratégie d'utilisation : faire rapidement le fine-tuning avec de gros patches quand les ressources manquent, puis passer à des patches plus fins à l'inférence pour gagner en précision dans la plage montrée.

Pour des systèmes qui doivent composer avec plusieurs budgets de calcul, mener des tests A/B ou ajuster dynamiquement leurs paramètres, cette combinaison d'un transfert moins coûteux et d'une inférence flexible ouvre des possibilités pratiques.

Détection d'objets à vocabulaire ouvert

Les auteurs intègrent FlexiViT à une tâche de détection d'objets à vocabulaire ouvert. Il sert d'encodeur d'images dans OWL-ViT, puis ils le comparent à des backbones ViT-B/16 et ViT-B/30 dont les tailles de patches sont fixes.

Le banc d'essai est LVIS, qui compte beaucoup de catégories avec une distribution en longue traîne. Cela en fait un cadre utile pour la détection zero-shot.

Quand on change la taille des patches à l'évaluation, la courbe AP de Flexi OWL-ViT, avec son backbone B/flexi, reste relativement stable. Les versions à backbone fixe perdent plus nettement en performance dès qu'elles quittent la taille employée à l'entraînement.

Pour des patches plus grands, comme /24 ou /30, et donc des grilles moins denses, Flexi dépasse le ViT-B/30 évalué hors de sa taille d'entraînement. Avec les petits patches /12, Flexi conserve environ 26 % d'AP. À /16, en revanche, le ViT-B/16 fixe fait un peu mieux : Flexi n'est pas premier à toutes les tailles.

Cette propriété est particulièrement intéressante pour la détection à vocabulaire ouvert.

La taille des objets varie beaucoup selon les scènes. On peut parfois vouloir localiser finement avec une grille dense, et parfois préférer une perception plus grossière à moindre coût.

Le codage flexible des patches permet d'ajuster la taille selon la tâche et les ressources, sans réentraîner un backbone pour chaque taille d'évaluation. C'est une forme d'adaptabilité utile pour des tâches open-world.

Le temps, c'est de la puissance de calcul

Pour finir, les auteurs examinent une autre possibilité :

  • utiliser la souplesse des tailles de patches pour accélérer le préentraînement de ViT.

La figure compare deux préentraînements sur ImageNet-21K. Le ViT-B/16 ordinaire garde une taille de patch fixe. Le (Flexi)ViT-B/16 suit un programme : commencer avec de gros patches, puis passer à la taille cible /16. Les deux sont évalués à /16.

Sur l'axe des heures de calcul TPU, le programme (Flexi)ViT obtient souvent une meilleure précision pour un budget comparable, mais l'écart ne grandit pas constamment. Vers 400 heures, les deux groupes de points diffèrent de moins d'un point de pourcentage. L'annexe juge les économies réelles, mais modestes.

Le principe ressemble à un programme d'apprentissage progressif :

Au début, de gros patches donnent un calcul rapide et une information grossière pour bâtir une représentation générale ; ensuite, des patches plus fins apportent des détails utiles à la reconnaissance.

Ces expériences montrent que, pour certains budgets d'entraînement, on peut atteindre une précision proche avec moins de calcul.

En pratique, cela donne une autre façon de régler le coût du préentraînement de ViT. Même si le modèle final ne doit utiliser qu'une seule taille de patch, ce programme peut, dans les conditions étudiées, économiser du calcul pour un résultat voisin. La « flexibilité » sert alors aussi pendant l'entraînement.

Conclusion

FlexiViT présente une stratégie simple et efficace : avec un seul modèle, on peut choisir entre plusieurs niveaux de calcul et de résolution.

Il n'ajoute pas une architecture compliquée. Il revient à une décision fondamentale de ViT, la patchification, et en tire un levier pour régler le calcul et la richesse des représentations.

Grâce au tirage aléatoire des tailles de patches, au redimensionnement PI-resize des poids et à l'aide de la distillation de connaissances, FlexiViT conserve des résultats stables sur diverses tâches aval. Classification, segmentation sémantique, détection à vocabulaire ouvert et recherche multimodale peuvent ainsi utiliser un seul backbone dans plusieurs contextes.

FlexiViT nous invite à repenser le rôle de la patchification. Peut-être verra-t-on d'autres idées, du codage des tokens à la compression de structure, de la fusion multi-échelle à l'ordonnancement guidé par les données.