A Lightweight Library for Energy-Based Joint-Embedding Predictive Architectures

Paper: arXiv:2602.03604 Code: facebookresearch/eb_jepa Code reference: main @ 966e61e9 (2026-02-04)

1. Motivation (研究动机)

这篇论文的核心问题不是“再刷一个大规模 World Model SOTA”，而是把 JEPA（Joint-Embedding Predictive Architecture）这条路线做成一个可读、可改、可在单卡几小时内跑完的教育型开源库 EB-JEPA。作者认为，很多 World Model 或视频生成路线把目标放在 pixel-space reconstruction / generation：模型必须解释所有像素，包括背景纹理、噪声、颜色细节等对决策并不关键的因素。这样的生成式目标当然能产生视觉上漂亮的 rollout，但代价是计算量大、训练复杂，而且学到的表征未必最适合 perception、planning 或 control。JEPA 的立场相反：不要预测原始像素，而是在一个 learned representation space 里预测未来或另一视角的表示；能量（energy）就是预测表示与目标表示之间的不匹配程度。

现有 JEPA 系统的痛点在于“原则很清楚，实现门槛很高”。I-JEPA、V-JEPA、V-JEPA 2 等工作已经证明 joint embedding prediction 可以从图像扩展到视频和物理直觉，但公开实现通常是研究/生产级大系统：依赖复杂、训练资源重、模块之间不容易替换，对想理解 JEPA 机制或教学演示的人并不友好。相反，很多入门自监督库更偏 SimCLR/VICReg/BYOL 图像表征学习，缺少从静态图像到 temporal latent prediction，再到 action-conditioned world model 和 goal-conditioned planning 的一条连续路径。

本文要解决的具体目标是：构建一个轻量级 library，把 JEPA 的三个层级放在同一个 energy-based 形式下实现出来：Image-JEPA 负责图像 view invariance；Video-JEPA 负责 latent-space temporal prediction；AC-video-JEPA 负责 action-conditioned latent dynamics，并把这个 dynamics 接到 MPPI / CEM planning 上。作者强调每个例子都应该是 self-contained 的：用户可以只看一个目录就跑通 CIFAR-10 图像表征、Moving MNIST 视频预测或 Two Rooms 规划任务，而不是先理解一个大型训练平台。

这个问题值得研究，是因为 JEPA 的潜在价值不只在于“预测下一个 embedding”。如果 representation space 足够语义化，模型可以避开像素级建模的无关细节，把计算集中在可预测、可控制、可用于目标规划的因素上。对研究者来说，EB-JEPA 提供了一个最小可运行基线：可以替换 encoder、predictor、regularizer、planner，快速验证某个 collapse prevention 策略、temporal loss 或 planning objective 是否真的有作用。对教学来说，它把“能量函数—表征预测—防坍塌正则—规划”这条链路连成完整实验，而不是停留在公式或大模型故事层面。

Figure 1 解读：图中把 EB-JEPA 的三个示例按复杂度串起来。左侧是 image-level self-supervised learning：两个增强视图经过 encoder 后在表示空间对齐；中间是 Video-JEPA：模型从过去若干帧的表示预测下一帧表示；右侧是 action-conditioned world model：动作也进入 predictor，输出可用于 goal-directed planning 的 future latent states。最重要的不是某个单独模块，而是同一套 energy-based JEPA 接口可以覆盖图像表征、视频 rollout 和规划三种任务。

2. Idea (核心思想)

核心 insight：JEPA 可以被理解成一种 energy-based model，其中低能量表示“上下文、动作、目标表示彼此兼容”。EB-JEPA 的新意不是提出一个更大的 backbone，而是把这种能量视角落到一个模块化 PyTorch library：encoder $f_{\theta }$、predictor $g_{\varphi }$、可选 action encoder $q_{\omega }$、anti-collapse regularizer $\mathcal{R}$ 和 planner 都是可替换组件。

关键创新可以概括为三点。第一，论文把 Image-JEPA、Video-JEPA、AC-video-JEPA 写成同一个统一目标，使读者能看到从 view invariance 到 temporal prediction 再到 action-conditioned planning 的连续扩展。第二，库中同时提供 VICReg 与 SIGReg 两类显式正则，强调 JEPA 不依赖负样本，也不必只靠 stop-gradient trick 防坍塌。第三，作者把 representation learning 的结果接到 MPPI/CEM planning：目标不是重建漂亮画面，而是在 latent space 里优化动作序列，让 predicted representation 靠近 goal representation。

与现有方法的根本差异：相比 pixel reconstruction world models（例如直接预测未来帧的 video model），EB-JEPA 的 predictor 只需要预测 encoder representation；相比 I-JEPA/V-JEPA 这类大规模研究系统，EB-JEPA 更强调单卡、短训练、可拆解的 reference implementation；相比 SimCLR 这样的 contrastive learning，它不需要负样本队列，而通过 variance/covariance 或 SIGReg 维持表征的非坍塌和可用维度。

3. Method (方法)

3.1 统一的 energy-based JEPA 形式

论文把 JEPA 训练写成一个通用能量最小化问题。给定输入 $x$、目标输入 $x^{\prime }$、可选动作 $a$，encoder 产生 $z=f_{\theta }(x)$，action encoder 产生 $u=q_{\omega }(a)$，predictor 给出 $g_{\varphi }(z,u)$，目标表示为 $z^{\prime }=f_{\theta }(x^{\prime })$。总目标是： $\mathcal{L}={\mathcal{L}}_{\text{pred}}(g_{\varphi }(z,u),z^{\prime })+\lambda \mathcal{R}(z).$ 其中 ${\mathcal{L}}_{\text{pred}}$ 是 representation-space prediction error，$\mathcal{R}$ 是防止 representation collapse 的 regularizer。直觉上，JEPA 的“energy”不是像素似然，而是“当前表示、动作条件和目标表示是否相互兼容”。如果模型把所有输入都编码成常数，prediction loss 会很小但表征不可用，所以必须加入显式正则，让 batch 内不同样本和不同 feature dimension 保持足够 spread。

三个任务分别是这个公式的特例。Image-JEPA 从同一张图像生成两个 augmented views $x,x^{\prime }$，直接最小化两者表示距离： ${\mathcal{L}}_{\text{image}}=\Vert z-z^{\prime }{\Vert }_2^2+\lambda \mathcal{R}(z,z^{\prime }).$ Video-JEPA 把序列写为 $x_{1:T}$，encoder 输出 $z_t=f_{\theta }(x_{t-w:t})$，predictor 用上下文 $z_{t-v:t}$ 预测下一步表示： ${\mathcal{L}}_{\text{video}}={\sum }_{t=1}^{T-1}\Vert g_{\varphi }(z_{t-v:t})-z_{t+1}{\Vert }_2^2+\lambda \mathcal{R}(z_{1:T}).$ AC-video-JEPA 再加入动作序列 $(a_t)$，$u_t=q_{\omega }(a_{t-w:t})$，预测器变成 action-conditioned latent dynamics： ${\mathcal{L}}_{\text{world}}={\sum }_{t=1}^{T-1}\Vert g_{\varphi }(z_{t-v:t},u_{t-v:t})-z_{t+1}{\Vert }_2^2+\lambda \mathcal{R}(z_{1:T},u_{1:T}).$ 这三个任务的共同 energy 可以写成： $E(x,x^{\prime },a)={\mathcal{L}}_{\text{pred}}(g_{\varphi }(f_{\theta }(x),q_{\omega }(a)),f_{\theta }(x^{\prime })).$ Image-JEPA 中 $g_{\varphi }=\mathrm{Id}$ 且无动作；Video-JEPA 使用 temporal predictor；AC-video-JEPA 使用完整 action-conditioned predictor。这个统一形式的好处是工程上可以共享 JEPA.unroll、prediction cost、regularizer 和 probe/eval 代码。

3.2 Anti-collapse regularization：VICReg 与 SIGReg

JEPA 的主要失败模式是 representation collapse：encoder 输出常数，predictor 很容易匹配目标，但下游 probing 和 planning 完全失效。EB-JEPA 实现两类显式正则。

VICReg 风格的 variance/covariance 正则包含两部分。Variance term 要求每个 feature dimension 的 batch 标准差不低于 margin $\gamma$： ${\mathcal{L}}_{\text{var}}(Z)=\frac{1}{D}{\sum }_{j=1}^D\max \left(0,\gamma -\sqrt{\mathrm{Var}(Z_{:,j})+ϵ}\right).$ Covariance term 惩罚 off-diagonal covariance，让不同维度不要学同一件事： ${\mathcal{L}}_{\text{cov}}(Z)=\frac{1}{D(D-1)}{\sum }_{i\ne j}[C(Z){]}_{i,j}^2,C(Z)=\frac{1}{N-1}(Z-\bar{Z}{)}^{\top }(Z-\bar{Z}).$ 完整 VICReg regularizer 为： ${\mathcal{R}}_{\text{VICReg}}=\alpha {\mathcal{L}}_{\text{var}}+\beta {\mathcal{L}}_{\text{cov}}.$ SIGReg 来自 LeJEPA / SIGReg 思路：先用 projector $h_{\psi }$ 把 representations 映射到 embedding $r=h_{\psi }(z)$，再要求 embedding distribution 接近 isotropic Gaussian $\mathcal{N}(0,I)$。论文使用随机一维投影 ${\xi }_p\sim \mathcal{N}(0,I)$ 和 Epps-Pulley Gaussianity test statistic $\mathcal{G}$： ${\mathcal{R}}_{\text{SIGReg}}(Z)=\frac{1}{P}{\sum }_{p=1}^P\mathcal{G}(Z{\xi }_p).$ 在代码中，SIGReg 对应 eb_jepa/losses.py 的 BCS（Batched Characteristic Slicing）实现：每步用固定 seed 生成随机投影矩阵 $A$，计算 view1 = z1 @ A 和 view2 = z2 @ A，再用 epps_pulley 测试投影后的 Gaussianity，并加上两视图投影的一致性损失。论文 Figure 2 显示 SIGReg 对超参数更稳定，而 VICReg 能达到相近 peak performance 但需要更仔细的 std/cov 权重调参。

Figure 2 解读：这张图比较 CIFAR-10 Image-JEPA 中 SIGReg 与 VICReg 的超参数敏感性。结论不是 SIGReg 的最高点绝对碾压 VICReg，而是 SIGReg 只暴露一个主要 $\lambda$，在 naive search 中 average accuracy 更高；VICReg 需要同时协调 variance/covariance 权重，错误组合会直接坍塌到 10% 或很低准确率。

3.3 Multistep latent rollout：让训练分布接近推理分布

Video-JEPA 和 AC-video-JEPA 如果只训练 single-step teacher-forced prediction，推理时做 autoregressive rollout 会遇到 exposure bias：第 2 步以后输入不再是真实 $z_t$，而是模型前一步预测的 ${\hat{z}}_t$。论文因此加入 $k$-step rollout losses。对 $k=1,\dots ,K$： ${\mathcal{L}}_k={\sum }_{t=1}^{T-k}\Vert g_{\varphi }(z_{t-v:t}^{(k-1)},u_{t-v:t})-z_{t+1}{\Vert }_2^2,$ 其中递推状态为： $z_{t+1}^{(k)}=g_{\varphi }(z_{t-v:t}^{(k-1)},u_{t-v:t}),z_t^{(0)}=f_{\theta }(x_{t-w:t}).$ 论文把 video/world 总目标写为： ${\mathcal{L}}_{\text{video}}={\mathcal{L}}_{\text{pred}}+\lambda \mathcal{R}(z_{1:T}),{\mathcal{L}}_{\text{world}}={\mathcal{L}}_{\text{pred}}+\lambda \mathcal{R}(z_{1:T},u_{1:T}),{\mathcal{L}}_{\text{pred}}={\sum }_{k=1}^K{\mathcal{L}}_k.$ released code 中 JEPA.unroll 支持两种模式。parallel 用于 Video-JEPA 训练：每轮预测所有时间步，再把左侧 ground-truth context 拼回去；autoregressive 用于 AC-video-JEPA 和 planning：每次只取最后一个 predicted step 拼到序列末尾。这样同一个接口既能处理有完整 ground-truth trajectory 的训练，也能处理未来帧未知的 planning/inference。

论文公式与 released code 实现差异：论文公式写的是 ${\mathcal{L}}_{\text{pred}}={\sum }_k{\mathcal{L}}_k$，而 eb_jepa/jepa.py 在 unroll(..., nsteps=K) 中把 prediction loss 按 nsteps 平均；这不改变固定 $K$ 下的最优解，但会改变 loss scale，因此复现实验时不应直接按论文公式把 learning rate / regularizer weight 外推。另一个细节是 parallel mode 会在每轮 rollout 后 re-feed ground-truth context，autoregressive mode 则逐步 append predictions；这解释了为什么 Video-JEPA 与 AC-video-JEPA 的训练代码看起来不完全相同。

Figure 3a–3b 解读：左侧展示 50 epochs 内 variance-covariance regularization loss、prediction loss 和 mean Average Precision 的训练动态；右侧比较不同 $k$-step recursive prediction 的 AP，论文指出比 single-step training 更好，且 $k\approx 4$ 是性能/复杂度的 Pareto point。这个图验证了“训练时模拟多步 rollout”能缩小 teacher-forcing 与 autoregressive inference 之间的差距。

Figure 4 解读：Moving MNIST 可视化从左到右是输入帧、1-step prediction visualization 和完整 autoregressive rollout。因为模型预测的是 latent representation，图像只是通过 probe/decoder 可视化出来；图中数字运动轨迹保持连贯，说明 latent dynamics 捕获了主要时间结构，而不是只记住最近一帧。

3.4 AC-video-JEPA：动作条件世界模型与规划能量

AC-video-JEPA 在表示空间中学习动作条件动力学。Two Rooms 环境里状态是图像，动作是二维连续控制。encoder 把图像帧变成 latent states，RNN predictor 接收当前 latent state 和动作，预测下一 latent state。除了 variance/covariance，论文还加入两类对 planning 特别重要的 regularizer：temporal similarity loss ${\mathcal{L}}_{\text{sim}}$ 鼓励相邻时间的表征轨迹平滑；inverse dynamics model loss ${\mathcal{L}}_{\text{IDM}}$ 让相邻 latent states 保留足够信息以反推出动作。

总正则可理解为： ${\mathcal{R}}_{\text{world}}=\alpha {\mathcal{L}}_{\text{var}}+\beta {\mathcal{L}}_{\text{cov}}+\delta {\mathcal{L}}_{\text{sim}}+\omega {\mathcal{L}}_{\text{IDM}}.$ 这几个项的角色不同。Variance/covariance 防止表示空间整体坍塌；temporal similarity 避免 rollout 表示在相邻步骤剧烈跳动；IDM 迫使 representation 保留与 action consequence 有关的信息。Table 4 的 ablation 显示 IDM 移除后成功率降到 $1\pm 1\%$，说明如果 latent state 不能编码动作可辨识信息，planner 即使能在表示空间优化，也找不到真正可执行的动作序列。

Planning 阶段给定当前 observation $x_0$ 和 goal observation $x_g$，先编码 ${\hat{z}}_0=f_{\theta }(x_0)$、$z_g=f_{\theta }(x_g)$，再搜索动作序列 $a_{0:H-1}$。论文的 planning energy 为 cumulative latent distance： $E_{\text{plan}}(a_{0:H-1})={\sum }_t\Vert z_g-{\hat{z}}_t{\Vert }_2^2.$ 代码中 ReprTargetDistMPCObjective(sum_all_diffs=True) 对每个 candidate rollout 计算 target representation 和 predicted encodings 的 MSE，并在时间维求和；sum_all_diffs=False 时只取最后一步，这对应 Table 4 中 “MPPI (last state)” 的 ablation。MPPI 与 CEM 都在 action-sequence distribution 上迭代优化，区别是 CEM 只用 elite 样本的均值/方差更新，而 MPPI 对 elite costs 做 exponentiated weighting，更新更平滑。

论文公式与 released code 实现差异：Appendix 表中的 MPPI noise scale 写为 $\sigma =2$。released examples/ac_video_jepa/cfgs/planning_mppi.yaml 没有 max_std 字段，只有 var_scale: 1.5；但 var_scale 是 CEMPlanner 的参数，MPPIPlanner 通过 **kwargs 忽略它，并使用类默认 max_std=2。因此有效 MPPI noise scale 与论文表一致，但配置值分散在 yaml 和 class default 里，复现时需要同时检查 planning.py。

Figure 5 解读：三行分别是 Two Rooms 随机墙环境中的成功规划 episode。每行从左到右显示 initial frame、planning optimization 输出的完整轨迹和 goal frame；红色标记用于强调初始/目标位置。这个图的意义在于 EB-JEPA 不是只做 latent prediction metric，而是把 learned latent dynamics 接到可执行的 model-predictive planning 上，并在随机墙位置中达到高成功率。

3.5 Source-grounded pseudocode

下面伪代码基于 facebookresearch/eb_jepa 的 main@966e61e9，用于说明 released implementation 的真实数据流；它不是逐行 porting checklist。

def image_jepa_train_step(model, loss_fn, linear_probe, views, labels, optimizer, scaler):
    view1, view2 = views
    with torch.autocast(device_type="cuda", dtype=torch.float16):
        features, z1 = model(view1)       # ImageSSL backbone + projector
        _, z2 = model(view2)
        loss_dict = loss_fn(z1, z2)       # VICRegLoss or BCS(SIGReg)
        ssl_loss = loss_dict["loss"]
 
    with torch.no_grad():
        frozen_features = features.detach().float()
    logits = linear_probe(frozen_features)
    probe_loss = F.cross_entropy(logits, labels)
 
    optimizer.zero_grad()
    scaler.scale(ssl_loss + probe_loss).backward()
    scaler.step(optimizer)
    scaler.update()
    return loss_dict

def video_jepa_train_step(jepa, pixel_decoder, det_head, batch, optimizer, steps):
    x = batch["video"]
    loc_map = batch["digit_location"]
    optimizer.zero_grad()
    _, (jepa_loss, reg_loss, _, reg_dict, pred_loss) = jepa.unroll(
        x,
        actions=None,
        nsteps=steps,
        unroll_mode="parallel",
        compute_loss=True,
        return_all_steps=False,
    )
    recon_loss = pixel_decoder(x, x)
    det_loss = det_head(x, loc_map)
    total_loss = jepa_loss + recon_loss + det_loss
    total_loss.backward()
    optimizer.step()
    return {"jepa": jepa_loss, "reg": reg_loss, "pred": pred_loss}

def ac_video_jepa_train_step(jepa, xy_prober, batch, jepa_optimizer, probe_optimizer, cfg):
    x, actions, loc = batch[0], batch[1], batch[2]
    jepa_optimizer.zero_grad()
    with torch.autocast(device_type="cuda", dtype=torch.float16):
        _, (jepa_loss, reg, reg_unweighted, reg_dict, pred) = jepa.unroll(
            x,
            actions,
            nsteps=cfg.model.nsteps,
            unroll_mode="autoregressive",
            ctxt_window_time=1,
            compute_loss=True,
            return_all_steps=False,
        )
    jepa_loss.backward()
    jepa_optimizer.step()
 
    probe_optimizer.zero_grad()
    xy_loss = xy_prober(observations=x[:, :, :1], targets=loc[:, :, :1])
    xy_loss.backward()
    probe_optimizer.step()
    return {"jepa": jepa_loss, "reg_terms": reg_dict, "xy": xy_loss}

def mppi_plan(unroll, obs_init, target_objective, plan_length=90, num_samples=200,
              num_iters=20, num_elites=20, max_std=2.0, temperature=0.005):
    mean = torch.zeros(plan_length, 2)
    std = max_std * torch.ones(plan_length, 2)
    for _ in range(num_iters):
        actions = mean[:, None, :] + std[:, None, :] * torch.randn(plan_length, num_samples, 2)
        predicted = unroll(obs_init, einops.rearrange(actions, "t b a -> b a t"))
        cost = target_objective(predicted)[:, None]
        elite_idx = torch.topk(-cost.squeeze(1), num_elites, dim=0).indices
        elite_cost, elite_actions = cost[elite_idx], actions[:, elite_idx]
        min_cost = cost.min(0)[0]
        score = torch.exp(temperature * (min_cost - elite_cost[:, 0]))
        score = score / score.sum(0)
        mean = torch.sum(score[None, :, None] * elite_actions, dim=1) / (score.sum(0) + 1e-9)
        std = torch.sqrt(torch.sum(score[None, :, None] * (elite_actions - mean[:, None, :]) ** 2, dim=1) / (score.sum(0) + 1e-9))
    return mean[0]

Code reference: main @ 966e61e9 (2026-02-04) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
Unified JEPA module and rollout	eb_jepa/jepa.py	JEPA, JEPA.unroll, JEPAProbe
Image-JEPA training	examples/image_jepa/main.py	train_one_epoch, ImageSSL, VICRegLoss, BCS
Video-JEPA training	examples/video_jepa/main.py	ResNet5, ResUNet, StateOnlyPredictor, JEPA.unroll(..., unroll_mode="parallel")
AC-video-JEPA training	examples/ac_video_jepa/main.py	ImpalaEncoder, RNNPredictor, VC_IDM_Sim_Regularizer, JEPA.unroll(..., unroll_mode="autoregressive")
Regularizers	eb_jepa/losses.py	VCLoss, VICRegLoss, BCS, TemporalSimilarityLoss, InverseDynamicsLoss
Planning objective and optimizers	eb_jepa/planning.py	ReprTargetDistMPCObjective, CEMPlanner, MPPIPlanner, GCAgent
Dataset examples	eb_jepa/datasets/	MovingMNISTDet, two_rooms/*, traj_dset.py

4. Experimental Setup (实验设置)

实验覆盖三个递增难度任务。第一，Image-JEPA 在 CIFAR-10 上做图像表征学习；CIFAR-10 标准 split 为 50,000 training images 和 10,000 test images，代码使用 torchvision.datasets.CIFAR10 和 two-view augmentation。第二，Video-JEPA 使用 Moving MNIST；released dataset loader 从 mnist_test_seq.npy 读取 10,000 条原始序列，随机打乱后取 9,000 train / 1,000 val，并把每条序列按时间二分 reshape 成更短序列，所以有效样本数是 18,000 train / 2,000 val。第三，AC-video-JEPA 使用 Two Rooms navigation；eb_jepa/datasets/two_rooms/data_config.yaml 设定 size=100000、val_size=10000、sample_length=17、n_steps=91，环境包含随机 wall / door layout。

对比方法和变体主要是库内 ablation，而不是外部大模型 SOTA。Image-JEPA 比较 SIGReg 与 VICReg，并消融 projector 维度与 loss hyperparameters。Video-JEPA 比较 single-step 与 $k$-step recursive prediction，并报告 training dynamics / mean Average Precision。AC-video-JEPA 比较 MPPI full cost、CEM full cost、MPPI last-state-only cost，以及移除 variance、covariance、temporal similarity、IDM 后的成功率。

Evaluation metrics 包括：linear probing accuracy（冻结 encoder 特征后训练线性分类器，在 CIFAR-10 上测分类准确率）；Average Precision（Moving MNIST 中通过 detection head / probe 衡量预测 rollout 中 digit localization 的质量）；planning success rate（Two Rooms 中 episode 是否在最多 200 steps 内到达目标）；planning time（表中为每次配置约 37s）。这些指标的共同点是评估 representation 是否能支持下游任务，而不是只看像素重建误差。

Training config 以 released code 的具体配置为准，而不是泛化默认值。Image-JEPA ResNet VICReg 使用 examples/image_jepa/cfgs/default.yaml：dataset cifar10，batch size 256，ResNet backbone，projector hidden/output 2048/2048，VICReg std_coeff=1.0、cov_coeff=80.0，LARS optimizer，epochs 300，LR 0.3，weight decay $10^{-4}$，warmup epochs 10。Image-JEPA SIGReg 使用 examples/image_jepa/cfgs/sigreg.yaml：batch size 256，projector hidden/output 2048/128，epochs 300，LR 0.3，weight decay $10^{-4}$；loss type 在配置中对应 BCS/SIGReg sweep。

Video-JEPA 使用 examples/video_jepa/cfgs/default.yaml：Moving MNIST，batch size 64，encoder ResNet5(dobs=1,henc=32,dstc=16)，predictor ResUNet + StateOnlyPredictor(context_length=2)，projector spec 16-64-64，regularizer std_coeff=10.0、cov_coeff=100.0，training epochs 50，LR 0.001，multistep model.steps=4。

AC-video-JEPA 使用 examples/ac_video_jepa/cfgs/train.yaml：Two Rooms，batch size 384，dobs=2，Impala encoder，GRU/RNN predictor，latent/channel dimension dstc=32，training rollout nsteps=8，epochs 12，LR 0.001，weight decay $10^{-5}$，regularizer cov_coeff=8、std_coeff=16、sim_coeff_t=12、idm_coeff=1。

Planning 使用 examples/ac_video_jepa/cfgs/planning_mppi.yaml 加 eb_jepa/planning.py class defaults：MPPI, horizon 90, iterations 20, samples 200, elites 20, max norm 2.45, temperature 0.005, sum_all_diffs=true, num_act_stepped=1, max episode steps 200。

需要注意一个 paper/code 配置差异：论文 Appendix Table 5 的 “ViT Image-JEPA” 列写 epochs 300，并称该 codebase example 达到 87% linear probing accuracy；但 released examples/image_jepa/cfgs/transformers.yaml 当前默认 optim.epochs=100，sweep 里是 [50, 100, 1000]。主文 Table 1–3 的 ResNet-18 数字不受这个差异影响，因为它们使用 default.yaml / sigreg.yaml 的 300 epochs；如果复现 ViT example，需要以当前 config 或 commit 历史为准。

5. Experimental Results (实验结果)

5.1 Image-JEPA on CIFAR-10

主结果显示，ResNet-18 backbone 训练 300 epochs 后，SIGReg 与 VICReg 都能达到约 90–91% linear probing accuracy。Table 1 精确数值如下：SIGReg best accuracy 91.02%，average accuracy 89.22%，移除 projector 降低 3.3 points，best projector 为 $2048\times 128$；VICReg best accuracy 90.12%，average accuracy 84.90%，移除 projector 降低 2.9 points，best projector 为 $2048\times 1024$。这里 average accuracy 说明 SIGReg 在 naive hyperparameter search 中更稳；VICReg peak 很接近，但错误 std/cov 权重会明显失败。

Loss hyperparameter ablation 的精确数值：SIGReg 最优 $\lambda =10$ 得到 90.88%，$\lambda =1$ 得到 86.94%，$\lambda =100$ 得到 80.86%，$\lambda =0.1$ 只有 27.20%。VICReg 方面，std=1,cov=100 得到 90.12%，std=1,cov=10 得到 89.93%，std=10,cov=10 得到 89.20%，std=100,cov=100 只有 10.00%。这个结果直接支撑论文对 SIGReg 稳定性的说法：单个 $\lambda$ 的错误会损害性能，但 VICReg 的二维系数空间更容易落到坍塌或接近随机分类。

Projector design ablation 的精确数值：SIGReg 的 top projector 包括 $2048\times 128$ 91.02%、$4096\times 1024$ 91.00%、$2048\times 64$ 90.99%、$512\times 256$ 90.99%、$4096\times 64$ 90.96%，无 projector 为 87.75%。VICReg 的 top projector 包括 $2048\times 1024$ 90.12%、$4096\times 512$ 90.10%、$1024\times 1024$ 90.05%、$2048\times 512$ 90.03%、$4096\times 1024$ 90.02%，无 projector 为 87.27%。这说明 projector 不是装饰项，而是把 encoder representation 转到更适合 regularizer 的 embedding space；去掉后两种方法都损失约 3 points。

5.2 Video-JEPA on Moving MNIST

Video-JEPA 结果强调多步训练的重要性。Figure 3 中，随着 50 epochs 训练推进，regularization loss 和 prediction loss 下降，mean AP 提升；右侧 ablation 显示 $k$-step recursive prediction 显著优于 single-step prediction，且 $k\approx 4$ 是性能/复杂度的 Pareto point。Figure 4 的 qualitative rollout 显示，模型不仅能做一步预测，也能在 autoregressive rollout 中维持数字运动轨迹。这一部分没有主表给出每个 AP 的精确数字，但图和 caption 明确给出结论：多步 rollout training 缩小了 training/inference mismatch。

5.3 AC-video-JEPA planning on Two Rooms

Two Rooms 是最能体现 “representation + dynamics + planning” 的实验。Table 4 planner configuration 的精确数值：MPPI full cost 成功率 $97\pm 2\%$，时间 37s；CEM full cost 成功率 $96\pm 2\%$，时间 37s；MPPI last state 成功率 $89\pm 2\%$，时间 37s。也就是说，MPPI 和 CEM 在 full cumulative cost 下都很强，但只优化 final-state distance 会下降 8 points，说明沿途 latent trajectory 也提供了重要约束。

Regularization ablation 的精确数值更关键：full model 为 $97\pm 2\%$；移除 variance（$\alpha =0$）降到 $47\pm 3\%$；移除 covariance（$\beta =0$）降到 $46\pm 3\%$；移除 temporal similarity（$\delta =0$）降到 $61\pm 2\%$；移除 IDM（$\omega =0$）降到 $1\pm 1\%$。这组数说明 AC-video-JEPA 的 planning 成功不是 predictor 单独带来的，而是 collapse prevention、平滑表征轨迹和动作可辨识性共同作用。尤其 IDM 是最脆弱的部件：没有它，表示空间可能仍然能做某些预测，却不再保留足以让 planner 选择动作的信息。

5.4 限制与结论

这篇论文的限制也很清楚。第一，它是 lightweight library / tutorial paper，不追求大规模 benchmark SOTA；CIFAR-10、Moving MNIST、Two Rooms 都是教学友好、单卡可跑的任务，不能直接证明 EB-JEPA 在复杂真实视频、机器人或开放世界交互中可扩展。第二，action encoder 在 Two Rooms 中几乎是 identity，动作空间简单；更复杂机器人控制、离散语言动作或高维动作还需要额外建模。第三，planning 成功依赖 learned representation 的几何结构，如果 representation 对目标距离不敏感，latent MSE 作为 planning objective 会失效。第四，paper/code 当前存在少量配置分散或不一致，需要以 commit anchor 和具体 config 文件复现。

总体结论是：EB-JEPA 提供了一个清晰的 JEPA reference stack。它展示了同一套 energy-based joint-embedding prediction 思路如何从 image view invariance 迁移到 video latent dynamics，再迁移到 action-conditioned world model planning。实验数字并不是为了证明“轻量库打败大模型”，而是证明每个核心组件都有可观测作用：SIGReg/VICReg 防坍塌、projector 提升表征、multistep rollout 改善 temporal prediction、IDM 和 temporal similarity 让 latent dynamics 真正可规划。