Visual Autoregressive Modeling (VAR)
La modélisation autorégressive visuelle (VAR) génère des images de manière progressive, du grossier au détaillé, en prédisant en parallèle chaque carte de jetons à la résolution suivante. Présentation du tokenizer et du passage à l’échelle.
La modélisation autorégressive visuelle (VAR) est une méthode d'IA générative pour les images qui prédit une image sous forme de suite de cartes de jetons à résolution croissante, d'un seul jeton 1 x 1 à la grille complète, au lieu de prédire les jetons un par un dans l'ordre de lecture. Chaque étape génère en parallèle tous les jetons de l'échelle suivante, conditionnés par toutes les échelles plus grossières ; une image de 256 x 256 nécessite ainsi 10 étapes. Keyu Tian, Yi Jiang, Zehuan Yuan, Bingyue Peng et Liwei Wang, de l'université de Pékin et de ByteDance, ont présenté VAR en avril 2024 dans Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction, qui a remporté le prix du meilleur article de NeurIPS 2024. Pour la génération conditionnelle par classe sur ImageNet en 256 x 256, la méthode a amélioré la distance de Fréchet-Inception (FID) d'une référence autorégressive, la faisant passer de 18.65 à 1.73, et son score Inception, de 80.4 à 350.2, avec une inférence environ 20 fois plus rapide.
Pourquoi prédire l'échelle suivante#
Les premiers générateurs d'images autorégressifs, comme le Transformer de VQGAN et Parti de Google, convertissent une image en une grille de jetons discrets, l'aplatissent ligne par ligne et prédisent un jeton à la fois, comme un modèle GPT génère du texte. Cet ordre est mal adapté aux images. Un jeton ne peut voir que les jetons au-dessus et à sa gauche, alors que les régions d'une image dépendent les unes des autres dans toutes les directions ; une grille de 16 x 16 nécessite 256 étapes séquentielles. Prédire l'échelle suivante conserve l'objectif d'entraînement du Transformer et son ordre causal, mais remplace l'unité de prédiction : au lieu d'un jeton, c'est toute une résolution. Les jetons d'une échelle peuvent ainsi se voir entre eux, et chaque échelle voit l'image complète à toutes les résolutions plus grossières.
Le tokenizer multi-échelle#
Le tokenizer de VAR est un autoencodeur dont la représentation latente est compressée par quantification vectorielle multi-échelle. Son encodeur transforme une image de 256 x 256 en carte de caractéristiques de 16 x 16, qui est quantifiée à 10 échelles, de 1 x 1 à 16 x 16, avec un codebook partagé de 4,096 entrées. Chaque échelle ne quantifie que ce que les échelles plus grossières n'ont pas expliqué : le résidu. Les cartes grossières conservent ainsi les couleurs et la disposition générales, tandis que les cartes suivantes ajoutent des détails plus fins. Le même schéma résiduel s'applique ci-dessous à une photo sous-échantillonnée avec un codebook aléatoire :
import torch
import torch.nn.functional as F
from skimage import data
torch.manual_seed(0)
image = torch.tensor(data.astronaut(), dtype=torch.float32).permute(2, 0, 1)[None] / 255 # 1x3x512x512
features = F.interpolate(image, size=(16, 16), mode="area") # stand-in for a 16x16 encoder feature map
codebook = torch.rand(4096, 3) * 2 - 1 # one shared codebook of 4,096 entries; residuals can be negative
# Multi-scale residual quantization: each scale encodes what the coarser scales left out
residual, reconstruction = features.clone(), torch.zeros_like(features)
for side in (1, 2, 3, 4, 5, 6, 8, 10, 13, 16): # VAR's ten token-map sizes for 256 x 256 images
small = F.interpolate(residual, size=(side, side), mode="area").permute(0, 2, 3, 1).reshape(-1, 3)
tokens = torch.cdist(small, codebook).argmin(dim=1) # side x side discrete token map
quantized = codebook[tokens].reshape(1, side, side, 3).permute(0, 3, 1, 2)
upsampled = F.interpolate(quantized, size=(16, 16), mode="bicubic")
reconstruction, residual = reconstruction + upsampled, residual - upsampled
print(f"{side:>2}x{side:<2} tokens -> reconstruction error {(features - reconstruction).pow(2).mean():.5f}")L'erreur de reconstruction passe de 0.06267 après l'unique jeton 1 x 1 à 0.00212 après la carte 16 x 16, avec 680 jetons répartis sur les dix échelles. VAR entraîne conjointement son encodeur, son décodeur et son codebook. Les modèles de détection s'appuient sur le même type de pyramide pour la reconnaissance : Ultralytics YOLO26 prédit les objets à partir des niveaux de pyramide de caractéristiques aux pas de 8, 16 et 32 ; une image de 640 pixels produit donc des cartes de 80 x 80, 40 x 40 et 20 x 20, la carte grossière détectant les grands objets et la carte fine, les petits.
Comment VAR génère une image#
Un Transformer de type GPT génère les cartes de jetons dans l'ordre, avec un masque d'attention causal par blocs qui permet à chaque jeton de porter son attention sur sa propre échelle et sur toutes les échelles plus grossières :
Les auteurs ont entraîné des modèles comportant jusqu'à 2 milliards de paramètres et ont observé des lois d'échelle en loi de puissance, comme celles des grands modèles de langage, avec des coefficients de corrélation linéaire proches de -0.998 entre la taille du modèle et la perte de test. Le même modèle réalise sans entraînement supplémentaire du remplissage d'image, de l'extension d'image et de la retouche conditionnelle par classe en mode zero-shot : il fixe les jetons situés à l'extérieur de la zone retouchée à leurs valeurs de vérité terrain et échantillonne les autres.
Successeurs de VAR et notions connexes#
- Infinity : Lancé par ByteDance en décembre 2024, ce successeur de la génération texte-image remplace le dictionnaire de 4 096 éléments par des jetons binaires issus d’un tokenizer au vocabulaire pratiquement illimité. Il génère une image de 1024 x 1024 en 0,8 seconde, soit 2,6 fois plus vite que Stable Diffusion 3 Medium, et fait passer le score GenEval de 0,62 pour SD3 Medium à 0,73.
- Transformers de diffusion (DiT) : Ils débruitent des représentations latentes continues sur de nombreuses étapes. L'article sur VAR indique que cette méthode surpasse DiT en qualité d'image, en vitesse d'inférence, en efficacité des données et en évolutivité.
- Modèles de diffusion : Ils affinent chaque pixel ou représentation latente de l'image à chaque étape, en partant d'un bruit gaussien.
- Transformers génératifs masqués : MaskGIT de Google prédit en parallèle tous les jetons masqués d'une grille à résolution unique et conserve les plus fiables au fil d'environ 8 à 12 itérations.










