Joint Embedding Predictive Architecture (JEPA)

Une architecture prédictive à plongements conjoints (JEPA) est une approche d’apprentissage auto-supervisé dans laquelle un réseau apprend en prédisant la représentation abstraite d’une partie masquée de son entrée à partir d’une partie visible. À partir d’une image dont certaines régions sont masquées, une JEPA prédit les plongements des régions masquées sans en reconstruire les pixels ; son signal d’entraînement se concentre donc sur le contenu sémantique prévisible, comme la forme et la disposition des objets, et ignore les détails imprévisibles, comme la texture des feuilles ou le bruit du capteur. Yann LeCun a proposé cette architecture dans son article de réflexion de 2022, Une voie vers l’intelligence machine autonome, comme élément de base des modèles du monde ; les modèles I-JEPA et V-JEPA de Meta la mettent en pratique pour les images et la vidéo.

Fonctionnement de JEPA#

Une JEPA comporte trois réseaux. Un encodeur de contexte, généralement un transformeur de vision (ViT), encode les patchs visibles. Un encodeur cible encode l’entrée complète, et ses plongements aux emplacements masqués servent de cibles. Un prédicteur, un transformeur plus étroit, reçoit les plongements de contexte ainsi que des jetons de masque qui indiquent l’emplacement de chaque cible, puis produit une estimation des plongements cibles. La fonction de perte correspond à la distance L2 moyenne entre les plongements cibles prédits et réels ; seuls l’encodeur de contexte et le prédicteur reçoivent des gradients. Dans I-JEPA, chaque image d’entraînement fournit quatre blocs cibles couvrant chacun 15 à 20 % de l’image et un bloc de contexte couvrant de 85 à 100 % de celle-ci ; toute partie qui chevauche les cibles est retirée, de sorte que le modèle doit déduire de grandes régions sémantiques à partir d’un contexte clairsemé.

Éviter l’effondrement des représentations#

La prédiction des plongements ouvre une échappatoire : si les deux encodeurs produisent le même vecteur constant pour chaque entrée, la prédiction est parfaite et la perte est nulle, un échec connu sous le nom d’effondrement des représentations. I-JEPA et V-JEPA évitent cet écueil grâce à une asymétrie. Aucun gradient ne se propage vers l’encodeur cible, et ses poids suivent plutôt une moyenne mobile exponentielle (EMA) des poids de l’encodeur de contexte, avec un coefficient de momentum qui commence à 0,996 et augmente linéairement jusqu’à 1,0 pendant l’entraînement d’I-JEPA. La même mise à jour EMA lisse, pour YOLO26, l’entraînement dans Ultralytics, où l’entraîneur conserve une moyenne mobile des poids du modèle, avec un coefficient de décroissance qui augmente progressivement jusqu’à 0,9999, puis enregistre cette copie moyennée comme point de contrôle. LeJEPA, publié en 2025 par Randall Balestriero et LeCun, remplace le modèle enseignant EMA et l’arrêt du gradient par un régulariseur appelé SIGReg, qui pousse les plongements vers une distribution gaussienne isotrope.

La boucle PyTorch ci-dessous entraîne une petite JEPA sur des vecteurs synthétiques, où une vue de contexte et une vue cible partagent une cause cachée à 8 dimensions.

import copy

import torch
from torch import nn

torch.manual_seed(0)
latent = torch.randn(512, 8)  # hidden cause shared by both views
x, y = latent @ torch.randn(8, 64), latent @ torch.randn(8, 64)  # context view x, target view y

encoder = nn.Sequential(nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 32))
target_encoder = copy.deepcopy(encoder).requires_grad_(False)  # updated only by EMA
predictor = nn.Linear(32, 32)
optimizer = torch.optim.Adam([*encoder.parameters(), *predictor.parameters()], lr=1e-3)

for step in range(1, 501):
    # Predict the target embedding from the context embedding; raw inputs are never reconstructed
    loss = nn.functional.mse_loss(predictor(encoder(x)), target_encoder(y))
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    with torch.no_grad():  # EMA update of the target encoder with momentum 0.996
        for target_param, param in zip(target_encoder.parameters(), encoder.parameters()):
            target_param.lerp_(param, 0.004)
    if step in {1, 500}:
        print(f"step {step}: latent loss {loss.item():.4f}, target embedding std {target_encoder(y).std(0).mean():.3f}")

Le code affiche step 1: latent loss 0.5372, target embedding std 0.547 et step 500: latent loss 0.0060, target embedding std 0.595. L’erreur de prédiction dans l’espace des plongements diminue d’environ 90 fois, tandis que la dispersion des plongements cibles reste stable ; la perte a donc diminué sans que les plongements s’effondrent en un vecteur constant.

JEPA et approches apparentées#

• Autoencodeurs masqués (MAE) : masquent les patchs de la même manière, puis reconstruisent les pixels manquants, ce qui mobilise la capacité du modèle pour les détails de bas niveau. JEPA prédit le contenu manquant dans l’espace des représentations.
• Apprentissage contrastif : rapproche les plongements de deux vues augmentées d’une image et éloigne ceux d’autres images ; il nécessite donc des exemples négatifs et des augmentations conçues manuellement, comme le recadrage et la variation des couleurs. I-JEPA n’utilise ni l’un ni l’autre.
• Méthodes d’auto-distillation, comme DINO : entraînent également un étudiant par rapport à un enseignant EMA en faisant correspondre les plongements de recadrages augmentés d’une même image. JEPA prédit plutôt le plongement d’une région à partir d’une autre, ce qui lui apprend la structure spatiale et temporelle.
• Modèles génératifs du monde : prédisent les trames futures dans l’espace des pixels, comme le font les générateurs vidéo. Un modèle du monde JEPA prédit les plongements futurs et peut planifier directement dans cet espace latent.

Modèles JEPA#

• I-JEPA (2023) : ce modèle d’image a entraîné un ViT-Huge/14 sur ImageNet avec 16 GPU A100 en moins de 72 heures ; ses caractéristiques se transfèrent à la classification linéaire, au comptage d’objets et à la prédiction de profondeur, sans augmentations de données conçues manuellement.
• V-JEPA (2024) : entraîné sur 2 millions de vidéos avec la prédiction de caractéristiques comme seul objectif, son plus grand modèle, un ViT-H/16 maintenu gelé, atteint 81,9 % sur Kinetics-400, 72,2 % sur Something-Something v2 et 77,9 % sur ImageNet-1k.
• V-JEPA 2 (2025) : préentraîné sur plus d’un million d’heures de vidéos provenant d’Internet, il atteint une précision top-1 de 77,3 % sur Something-Something v2 et un rappel@5 de 39,7 pour la prédiction d’actions sur Epic-Kitchens-100. Sa variante conditionnée par les actions, V-JEPA 2-AC, a été entraînée ensuite sur moins de 62 heures de vidéos de robots non étiquetées du jeu de données DROID ; elle a ensuite saisi et déposé des objets sans exemple préalable, avec des bras robotisés Franka dans deux laboratoires, en planifiant à partir d’objectifs visuels.