Semantic Tube Prediction: Beating LLM Data Efficiency with JEPA

Paper: arXiv:2602.22617 Code: galilai-group/llm-jepa Code reference: main @ ea0017c6 (2026-04-15)

1. Motivation (研究动机)

这篇论文要解决的不是“再提出一个更大的 LLM”，而是质疑一个更底层的经验事实：Chinchilla-style scaling laws 把 loss 随数据、参数、计算量下降的关系拟合成稳定 power law，但这些 law 描述的是当前训练范式的平均行为，不一定是最优训练目标的下界。作者的核心问题是：如果 Next-Token Prediction (NTP) 这个局部重构目标把语义信号和表层噪声混在一起，那么数据效率瓶颈可能不是语言本身的必然属性，而是训练目标没有显式利用 representation geometry 的结果。

NTP 的局限在于它只要求 hidden state 经过 unembedding 后落入正确 token 的 Voronoi cell。对离散 token 预测来说，这已经足够让 cross-entropy 降低；但对连续 hidden trajectory 来说，一个 cell 内还有无限多位置。两个语义相近但应当分离的 prompt trajectory 可以穿过同一个 token cell 的不同位置；如果训练只约束 cell membership，而不约束 trajectory 在 cell 内的几何位置，hidden state 可能沿错误 geodesic 漂移，推理时的自回归误差会累积，最终出现 mode collapse、diversity loss 或 hallucination-like collision。

作者把这个问题表述为“error-free semantic trajectory”和噪声的分解。理想情况下，token 序列虽然离散，但其生成过程可以被嵌入到连续空间中的 ODE；若速度场足够光滑，Picard-Lindelöf uniqueness 表明不同初始条件的轨迹不会相交。再结合 Principle of Least Action，作者提出 Geodesic Hypothesis：正确语义轨迹在平滑语义流形上近似 geodesic，因此局部几乎线性。这样一来，NTP 的缺失约束就很清楚：它没有把 hidden states 压到这条局部线性的“管道”里。

Figure 1a–1b 解读：左侧给出 Semantic Tube 的几何图像：误差较小的 hidden trajectory 应当沿中心 geodesic 前进，沿 geodesic 的分量被解释为 signal，垂直方向偏离被解释为 noise。右侧给出数据效率现象：在 NL-RX-SYNTH 上，加入 STP 的模型在数据减半时几乎不掉点，并能在 $1/16$ 数据量附近匹配 full-data regular fine-tuning；这就是论文所谓“beating LLM data efficiency”的主要经验依据。

为什么值得研究？如果这个几何先验成立，LLM 训练不必完全依赖 brute-force data scaling；一个轻量 auxiliary objective 就能提升 SNR、减少所需样本数，并在推理时减少 trajectory collision 的风险。更具体地说，论文试图验证五个预测：${\mathcal{L}}_{\mathrm{NTP}}$ 本身不足、STP 提高 SNR 并提升 accuracy/data efficiency、STP 保留 diversity、最优 $\lambda$ 应该很小、identity predictor 比 learned projection 更合适。这些预测把“数据效率提升”从单纯 empirical trick 变成了对 hidden-state geometry 的可检验假说。

2. Idea (核心思想)

核心洞察：如果一段正确 token 序列在语义流形上沿 geodesic 移动，那么任意局部三点 $h_s,h_r,h_t$ 的位移方向应当近似共线；训练时只需惩罚偏离这条局部直线的 hidden-state motion，就能把表示轨迹压进一个 semantic tube，并把 NTP 没有约束的 cell-internal degrees of freedom 变成有用的几何约束。

关键创新是 Semantic Tube Prediction (STP)：它把 JEPA 的“在 embedding space 预测另一 view”改写成语言序列内部的几何自监督任务，不再需要显式构造 two-view augmentation 或额外 predictor。传统 LLM-JEPA 需要把 Text/Code 或 query/answer 组织成两个 view，并可能需要额外 forward pass；STP 则直接在同一次 forward 已经产生的 hidden states 上采样 $s<r<t$，用 cosine loss 约束位移方向。

和现有方法的根本差异：regular fine-tuning 只最小化 ${\mathcal{L}}_{\mathrm{NTP}}$；LLM-JEPA 用 explicit two-view representation alignment；STP 使用 Geodesic Hypothesis，把 sequence 自身当作连续语义路径，identity predictor 即可。换言之，它不是让模型“预测另一个 view 的 embedding”，而是让 hidden trajectory 的局部速度方向保持一致，从而在训练中压低垂直于 geodesic 的噪声。

3. Method (方法)

3.1 Overall framework：从 NTP 到 Semantic Tube

论文先把 LLM 训练写成 token sequence space 中的 ODE。令 $x_{\le t}$ 表示前缀，模型编码为 hidden state $h_t$，unembedding 后预测下一个 token。作者论证在平滑条件下，序列从不同 prompt 出发的 error-free trajectory 不应相交；但 NTP 只要求预测 token 正确，因此 hidden state 只需落入正确 Voronoi cell，并不保证落在 error-free trajectory 的正确位置。STP 的设计目标就是补上这个几何约束。

STP 把 hidden-state trajectory 分解为 signal/noise。对 $s<r<t$，沿 $h_t-h_s$ 的方向是语义前进方向，垂直方向是 deviation。论文的总目标写成： $\mathcal{L}={\mathcal{L}}_{\mathrm{NTP}}+\lambda \cdot {\mathcal{L}}_{\mathrm{STP}},$ 其中 ${\mathcal{L}}_{\mathrm{NTP}}$ 是标准 next-token cross entropy，$\lambda$ 控制 STP 正则强度。论文在主文中把 STP 解释为最小化局部方向偏差；实际常用表达可写作： ${\mathcal{L}}_{\mathrm{STP}}=1-\cos (h_t-h_r,h_r-h_s).$ 直觉上，如果 $h_s\to h_r$ 和 $h_r\to h_t$ 两段位移方向一致，那么 $h_r$ 就不会偏离由端点定义的局部 geodesic 太远。这个约束不是强行把整个句子拉成全局直线；它只假设 geodesic 在足够短的窗口内 locally linear。因此 $\lambda$ 必须小，既要压制 perpendicular noise，又要允许真实语义流形存在曲率。

Figure 2 解读：图中两个相似 prefix 的 hidden trajectories 都经过 “researcher” token 的 Voronoi cell，但它们在 cell 内的位置不同，对应后续应生成不同人物或事实。NTP 只保证进入同一 cell，不保证轨迹在 cell 中的位置；红色虚线表示误差把轨迹推到错误 geodesic 上，从而造成 mode collapse 或 hallucination-like continuation。

3.2 Geodesic Hypothesis 与 tube theorem

Geodesic Hypothesis 的形式是：token sequence trajectory $x_{\le t}$ 在 ${\mathbb{R}}^{T\times d_{\mathrm{model}}}$ 中 almost everywhere locally linear；由于 $h_t^{\ast }=\mathring{f}(x_{\le t})$，在 $\mathring{f}$ 足够平滑时，error-free hidden trajectory $h_t^{\ast }$ 也应当局部线性。论文定义 local linearity：存在窗口长度 $\tau$ 和误差界 $\epsilon$，对任意 $s<r<t$ 且 $|t-s|\le \tau$，有 $\Vert (h_r^{\ast }-h_s^{\ast }{)}_{\perp h_t^{\ast }-h_s^{\ast }}{\Vert }_2\le \epsilon .$ 这里 $x_{\perp y}$ 表示 $x$ 在垂直于 $y$ 方向上的分量。Straightening Lemma 进一步说，如果边界点满足 $h_s=h_s^{\ast },h_t=h_t^{\ast }$，并且 ${\mathcal{L}}_{\mathrm{STP}}\le ϵ$，那么中间点的垂直偏移满足： $\Vert (h_r-h_s{)}_{\perp h_t^{\ast }-h_s^{\ast }}{\Vert }_2\le \sqrt{2ϵ}\Vert h_r-h_s{\Vert }_2.$ Semantic Tube theorem 则给出结论：如果 $h^{\ast }$ locally linear，且对 $0\le s<r<t\le \tau$ 有 ${\mathcal{L}}_{\mathrm{STP}}\to 0$，则 $\Vert h_r-h^{\ast }{\Vert }_2\lesssim \epsilon .$ 随机采样三点时，若 $\mathbb{E}[1-\cos (h_t-h_r,h_r-h_s)]\to 0$，Markov inequality 给出高概率意义下的 random tube： $P(\Vert h_r-h^{\ast }{\Vert }_2>\epsilon +ϵ)\to 0.$ 这些式子共同说明：STP 不是直接知道 $h^{\ast }$，而是用局部共线性作为可观测替代目标；只要端点和局部线性假设近似成立，中间 hidden state 会被压到围绕 $h^{\ast }$ 的 tube 内。

Figure 3 解读：该图用“sentence aligns on a geodesic”的例子说明，概念方向不是孤立 token embedding，而是在上下文中形成的位移方向。STP 关注 $h_t-h_s$ 这种 context-aware displacement，因此同一个 token 在不同 prefix 下可以指向不同语义结果。

Figure 4a–4b 解读：左侧 loss curve 对应预测 (P1)：regular NTP 的 ${\mathcal{L}}_{\mathrm{NTP}}$ 可以下降并 plateau，但 ${\mathcal{L}}_{\mathrm{STP}}$ 并不会自然被压低；加入 STP 后，两者共同优化。右侧 loss-vs-$\lambda$ 展示 $\lambda$ 过大时会损害原始 NTP loss，因此 STP 应作为小权重几何正则，而不是替代语言建模目标。

3.3 Context-aware displacement 与 practical STP

论文强调 $h_t-h_s$ 不等于孤立子序列 $x_{[s,t]}$ 的 hidden state，而是“在上下文 $x_{\le s}$ 下追加子序列产生的语义演化”。例如同样的 token “France”，在 “The capital of” 后面会推动到 Paris 方向，在 “The language of” 后面会推动到 French 方向。这个 context-aware property 对语言很关键：如果直接对 token embedding 或 isolated span 做对齐，就会丢失前缀决定的语义方向。

Figure 9 解读：同一个 ${\vec{v}}_{\mathrm{France}}$ 在不同 prefix 中对应不同概念方向。图的作用是解释为什么 STP 用 hidden-state difference 而不是孤立 token representation：差分向量保留了上下文条件下的“语义位移”。

实践中，$s,r,t$ 可以随机选择。如果数据本身有 query/answer 两段结构，可以把 $s$ 放在 query 开始、$t$ 放在 answer 结束，并随机选择 $r$。对多选题等有干扰项的场景，论文还给出跳过中间无关 branch 的形式：令 $x_{[s,r]}$ 是 query，$x_{[r^{\prime },t]}$ 是正确 answer，则 ${\mathcal{L}}_{\mathrm{STP}}=1-\cos (h_t-h_{r^{\prime }},h_r-h_s).$ 这种设计把“语义路径应当平滑”变成了可用于不同任务格式的正则项。它的计算开销小，因为 forward pass 已经有 $h_s,h_r,h_t$；额外成本主要是 cosine similarity，不需要 LLM-JEPA 那种额外 two-view forward 或 predictor network。

论文公式与 released code 实现差异：论文主文用三点形式 $1-\cos (h_t-h_r,h_r-h_s)$ 解释 STP；stp.py 默认 --linear=random_span 的实现更像 span-level variant：从完整 user+assistant hidden trajectory 中随机抽取 patch，构造 patch = h_{\text{patch_end}}-h_{\text{patch_start}}，再把 patch 前后的位移相加为 before + after，最后最小化 weighted $1-\cos (\text{before}+\text{after},\text{patch})$。这与局部线性直觉一致，但不是逐字照搬论文的相邻三点公式；代码还支持 length_adjustment、random_span_times、mask/curvature 等 ablation 分支。

3.4 Released code grounded pseudocode

Code reference: main @ ea0017c6 (2026-04-15) — pseudocode and mapping based on this commit

3.4.1 数据格式化与 span 边界记录

def prepare_chat_example(messages, tokenizer, model_name, max_length=512):
    full_messages = get_messages(model_name, messages)
    formatted = tokenizer.apply_chat_template(
        full_messages,
        tokenize=False,
        add_generation_prompt=False,
    )
    input_ids, attention_mask = tokenizer(
        formatted,
        truncation=True,
        max_length=max_length,
        return_tensors="pt",
    ).values()
 
    labels = input_ids.clone()
    user_start, user_end = find_start_end(messages[1]["content"], tokenizer, input_ids, attention_mask)
    assistant_start, assistant_end = find_start_end(
        get_assistant_messages(model_name, dataset=None, messages=messages),
        tokenizer,
        input_ids,
        attention_mask,
    )
    labels[:assistant_start] = -100
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels,
        "user_start_end": torch.tensor([user_start, user_end]),
        "assistant_start_end": torch.tensor([assistant_start, assistant_end]),
    }

这段对应 stp.py::load_and_prepare_dataset。关键不是 tokenization 本身，而是保存 user/assistant 在 packed chat 中的边界；后续 random span loss 需要知道一个 offset 落在 user 还是 assistant 段内。

3.4.2 random-span STP 向量构造

def build_random_span_vectors(hidden_states, user_start_end, assistant_start_end, span_start, span_end):
    user_start, user_end = user_start_end[0] + 1, user_start_end[1] + 1
    assistant_start, assistant_end = assistant_start_end[0] + 1, assistant_start_end[1] + 1
 
    if span_start < user_end - user_start:
        patch_start = user_start + span_start
    else:
        patch_start = assistant_start + span_start - (user_end - user_start)
 
    if span_end <= user_end - user_start:
        patch_end = user_start + span_end
    else:
        patch_end = assistant_start + span_end - (user_end - user_start)
 
    if patch_start >= assistant_start:
        before = hidden_states[user_end - 1] - hidden_states[user_start - 1]
        before = before + hidden_states[patch_start - 1] - hidden_states[assistant_start - 1]
        patch = hidden_states[patch_end - 1] - hidden_states[patch_start - 1]
        after = hidden_states[assistant_end - 1] - hidden_states[patch_end - 1]
    elif patch_end <= user_end:
        before = hidden_states[patch_start - 1] - hidden_states[user_start - 1]
        patch = hidden_states[patch_end - 1] - hidden_states[patch_start - 1]
        after = hidden_states[user_end - 1] - hidden_states[patch_end - 1]
        after = after + hidden_states[assistant_end - 1] - hidden_states[assistant_start - 1]
    else:
        raise NotImplementedError("span crossing user/assistant boundary is handled by code branches")
 
    context_direction = before + after
    patch_direction = patch
    return context_direction, patch_direction

这段对应 RepresentationTrainer.get_embeddings 和 compute_loss 中的 self.linear == "random_span" 分支。它把一个随机 patch 的语义位移与剩余上下文位移做 cosine alignment；这就是 released code 中最接近论文 STP 的默认路径。

3.4.3 STP training step

def stp_train_step(model, batch, lambda_stp=0.02, gamma=1.0):
    outputs = model(
        input_ids=batch["input_ids"],
        attention_mask=batch["attention_mask"],
        labels=batch["labels"],
        output_hidden_states=True,
    )
    lm_loss = outputs.loss
    hidden = outputs.hidden_states[-1]
 
    user_vecs, patch_vecs, weights = [], [], []
    for i in range(hidden.shape[0]):
        user_len = batch["user_start_end"][i, 1] - batch["user_start_end"][i, 0]
        assistant_len = batch["assistant_start_end"][i, 1] - batch["assistant_start_end"][i, 0]
        full_len = user_len + assistant_len
        span_start, span_end = sample_s_t(full_len)
        context_vec, patch_vec = build_random_span_vectors(
            hidden[i], batch["user_start_end"][i], batch["assistant_start_end"][i], span_start, span_end
        )
        user_vecs.append(context_vec)
        patch_vecs.append(patch_vec)
        weights.append(length_weight(full_len, span_end - span_start))
 
    cosine = F.cosine_similarity(torch.stack(user_vecs), torch.stack(patch_vecs), dim=-1)
    stp_loss = 1.0 - torch.sum(cosine * torch.tensor(weights, device=cosine.device)) / torch.sum(torch.tensor(weights, device=cosine.device))
    total_loss = gamma * lm_loss + lambda_stp * stp_loss
    return total_loss, {"lm_loss": lm_loss.detach(), "stp_loss": stp_loss.detach()}

stp.py 实际写法中，total_loss = self.gamma * lm_loss + self.get_lbd() * jepa_loss；get_lbd() 支持 warmup/min lambda。默认 driver run_stp.sh 用 --linear=random_span，因此不会走 L2/MSE/InfoNCE 的旧 JEPA 分支。

3.4.4 Evaluation flow

def evaluate_checkpoint(model_folder, base_model, dataset):
    outputs = generate_jsonl(
        model_name=model_folder,
        input_file=f"{dataset}_test.jsonl",
        original_model_name=base_model,
        max_new_tokens=-1,
        split_tune_untune=True,
    )
    return compute_task_accuracy(outputs)

评估由 run_stp.sh 调 evaluate.py 完成。脚本对 regular 与 STP checkpoint 使用同一 test JSONL、同一 original model name，并对 Spider 传入 spider_data/database。

Paper Concept	Source File	Key Class/Function
STP fine-tuning entry	stp.py	main, RepresentationTrainer
Random span STP	stp.py	get_s_t, get_embeddings, compute_loss
Loss combination	stp.py	total_loss = gamma * lm_loss + get_lbd() * jepa_loss
Dataset/chat span construction	stp.py	load_and_prepare_dataset, find_start_end
Experiment driver	run_stp.sh	run_regular, run_jepa
Evaluation	evaluate.py	JSONL generation + task accuracy evaluation
Baseline LLM-JEPA code	finetune.py, run.sh	two-view JEPA fine-tuning branches

3.5 为什么它可能提高 SNR 与数据效率

作者没有直接测 hidden SNR，因为 self-supervised 表示中的 signal/noise ground truth 不可观测。论文用信息论推导连接 SNR、样本数和 accuracy。令离散 target token 为 $Y$，hidden states 为 $X^m=\{X_i{\}}_{i=1}^m$，则有 Data Efficiency lemma： $H(Y|X^m)\ge H(Y)-m\cdot I(Y;X).$ 若把 representation 写成 Gaussian channel $X=Z+N$，其中 $Z$ 是 signal、$N\sim \mathcal{N}(0,{\sigma }^{2}I)$ 是 noise，则 $\mathrm{SNR}=\frac{\mathbb{E}[\Vert Z{\Vert }^2]}{\mathbb{E}[\Vert N{\Vert }^2]},I(X;Y)=\frac{1}{2}\log (1+\mathrm{SNR}).$ 当训练后 $H(Y|X^m)\le ϵ$，所需样本量满足： $m\ge \frac{H(Y)-ϵ}{\frac{1}{2}\log (1+\mathrm{SNR})}.$ 因此如果 STP 确实减少垂直噪声、提高 SNR，所需 $m$ 会随 $\log (1+\mathrm{SNR})$ 增大而下降。Fano inequality 进一步给出错误率下界近似： $P_e\gtrsim \frac{H(Y)-m\cdot \frac{1}{2}\log (1+\mathrm{SNR})}{\log |\mathcal{V}|}.$ 这解释了论文的实验设计：不直接声称“测到了 SNR”，而是用 accuracy、data efficiency、diversity preservation 作为 SNR 改善的可观察后果。

Figure 10 解读：该图是 Straightening Lemma 的几何示意：端点对齐且 STP loss 小时，中间点的 perpendicular component 被压低；这就是 tube theorem 中“hidden state 被限制在最优轨迹附近”的关键几何步骤。

Figure 11 解读：推理时误差不再像训练中那样被 teacher forcing 截断，而会形成 Brownian-motion-like 累积项；inference cone 半径按 ${\sigma }_t\sqrt{t}$ 增长。STP 若压低 ${\sigma }_t$，就会收缩 cone，降低 trajectory collision 的概率。

4. Experimental Setup (实验设置)

4.1 Datasets and scale

论文评估的数据集包括 NL-RX-SYNTH、NL-RX-TURK、GSM8K、Spider、NQ-Open、HellaSwag，并在 released repo 中提供相应 JSONL 文件。按 galilai-group/llm-jepa 当前 commit 的文件计数：SYNTH train/test 为 8000/2000，TURK 为 8000/2000，GSM8K 为 7473/1319，Spider 为 6587/1447，NQ-Open 为 8000/1769，HellaSwag 为 8042/2000。repo 还包含 Rotten Tomatoes、Yelp、Paraphrase 等旧 LLM-JEPA 数据，但这篇 STP 主文的核心比较集中在上述六个任务和 SYNTH 的数据缩放实验。

4.2 Baselines

主要 baseline 有两类：Regular fine-tuning，即只优化 ${\mathcal{L}}_{\mathrm{NTP}}$；LLM-JEPA，即在 ${\mathcal{L}}_{\mathrm{NTP}}$ 外加入 earlier LLM-JEPA two-view loss。ablation 中还比较了 Semantic Tube family 的 Zero、Pred、Inst 等变体，Two Views family 的 Pred/Mean/Warmup 变体，Mask family 的 Inst/Recover/Pred 等变体，以及 Curvature family。

4.3 Metrics

核心 metric 是 task accuracy。对于 NL-RX-SYNTH/TURK，accuracy 衡量生成 regular expression 是否符合目标；GSM8K 是答案正确率；Spider 是 SQL/text-to-SQL 任务准确性；NQ-Open 是 open QA accuracy；HellaSwag 是 commonsense completion accuracy。数据效率实验还报告在 $1/2,1/4,1/8,1/16,1/32$ 训练数据下的 accuracy 曲线，并区分 full compute、half compute + $2\times$ learning rate 等设置。diversity 实验单独统计 functionally equivalent regex suffix .* 与 .*.* 的保留率。

4.4 Training config and reproducibility anchors

论文主文说每个配置用 5 个 random seeds 报告 mean/std。released code 的 run_stp.sh 给出可复现入口：torchrun --nproc_per_node=8 stp.py，regular 分支传 --regular，STP 分支传 --linear=random_span、--last_token=-2、--lbd=<lambda>、--predictors=0。

脚本默认示例为 meta-llama/Llama-3.2-1B-Instruct on synth，learning rate 2e-5，epochs 4，seeds 82,23,37,84,4，lambda 0.02。stp.py 的默认训练参数包括 max_length=512、per-device batch size 4、gradient accumulation 4、default LR 2e-5、default epochs 3、LoRA rank default 16 但默认 full fine-tuning。

因为 run_stp.sh 用 8 GPUs 且没有覆盖 batch/grad_accum，默认 effective batch size 为 $8\times 4\times 4=128$ examples/optimizer step。

需要注意：paper 图中覆盖 Gemma2、OpenELM、OLMo、Qwen3、DeepSeek-R1-Distill-Qwen、Llama 3B/8B 等大量配置，但当前 released repo 只把 driver 函数和一个默认循环公开；完整 sweep 的所有命令/日志未逐项包含在仓库中。因此上面的超参优先引用 run_stp.sh 和 stp.py，而不是从 README 泛化。

5. Experimental Results (实验结果)

5.1 Loss landscape and accuracy across tasks/models/sizes

Figure 5a–5c 解读：三组柱状图分别比较 datasets、model families、model sizes。论文结论是 Semantic Tube 即 ${\mathcal{L}}_{\mathrm{NTP}}+{\mathcal{L}}_{\mathrm{STP}}$ 在多数据集、多模型家族、多模型尺寸上都优于 regular NTP 和 LLM-JEPA。该图的重点是跨维度稳定性：STP 不是只对 SYNTH 或单个 Llama checkpoint 有效，而是在 Gemma2、OpenELM、OLMo、Qwen3、DeepSeek-R1-Distill-Qwen 以及 Llama 1B/3B/8B 中都显示优势。图中未给每个 bar 的数值标注，因此这里不伪造逐项精确数字；精确数字可见下方表格和带标注的 lambda/ablation 图。

Figure 6a–6b 解读：SVD 分解用于解释 STP 的 polymorphism。未归一化时，STP 的 singular value profile 更接近 regular fine-tuning，说明它仍保留原始向量长度中的复杂性；归一化后，STP 的方向结构更接近 LLM-JEPA，说明它在“方向”上施加简单结构。这支持一个重要解释：STP 不把所有 representation collapse 到低维，而是主要约束语义位移方向。

5.2 Data efficiency：16× less data

数据效率是论文最强 claim。作者在 NL-RX-SYNTH 上随机抽取 $1/2,1/4,1/8,1/16,1/32$ 数据子集，并对 Llama-3 1B、3B、8B 同时跑 Semantic Tube 和 regular fine-tuning。为了补偿样本数减少带来的 step 数下降，若使用 $1/n$ 数据，就训练 $n\times$ epochs。结论是：STP 在数据减半时 accuracy 几乎不下降，并在数据减少到 $1/16$ 时仍可匹配 full-data regular fine-tuning；regular NTP 一旦数据减半就明显下降。作者还测试 half compute，即 $n/2\times$ epochs + $2\times$ learning rate；这个设置在 full 或 $1/2$ 数据时不是最优，但在数据比例 $<1/2$ 时相对更有竞争力。

Figure 12a–12b 解读：这张 appendix 图把 data efficiency 结论扩展到 Llama3 3B 和 8B。两幅图都显示 STP 曲线在小数据区间更稳，而 regular NTP 曲线对数据减少更敏感。它加强了“16× less data”不是 1B 小模型偶然现象的论点。

5.3 Diversity preservation

论文用 SYNTH 中两个 functionally equivalent suffix .* 和 .*.* 来测试 diversity preservation。训练集中 .* 比 .*.* 多 35×，因此一个容易 mode-collapse 的模型会偏向多数后缀。表 1 的精确结果如下：

Suffix	Semantic Tube	Regular	LLM-JEPA
.*	88.5%	29.9%	68.9%
.*.*	68.0%	28.0%	32.0%

Semantic Tube 在两个后缀上都维持高准确率；LLM-JEPA 虽然在多数 .* 上较高，但在少数 .*.* 上只有 32.0%，体现出向多数模式坍缩的倾向；regular fine-tuning 两者都低。这个实验直接对应 (P3)：如果 STP 真的减少 trajectory collision，它应当更能保留等价但风格不同的输出。

5.4 Lambda tuning

Figure 13 解读：Llama-3 1B 上不同数据集的 accuracy-vs-$\lambda$ 曲线呈 concave 形态，峰值通常在 $0.01$ 到 $0.08$。图上标注的峰值包括 SYNTH $84.29\pm 0.36$、TURK $56.78\pm 0.68$、GSM8K $36.60\pm 0.53$、Spider $41.16\pm 0.30$、NQ-Open $26.59\pm 0.65$、HellaSwag $36.67\pm 0.44$。过大的 $\lambda$ 会快速降低 accuracy，并增大标准差，说明 STP 只是“软 tube”正则。

表 2 给出最佳 $\lambda$ 的精确值：

Setting	Best $\lambda$
SYNTH	0.02
TURK	0.04
GSM8K	0.005
Spider	0.04
NQ	0.16
HellaSwag	0.02
Gemma2	0.005
Qwen3	0.02
R1 Distill	0.04
OLMo	0.01
OpenELM	0.04
Llama3 3B	0.01
Llama3 8B	0.0025

这些值整体支持 (P4)：$\lambda$ 小于 1 很多，说明局部 geodesic 不是严格直线，正则过强会伤害任务学习。

5.5 Ablation and variants

Figure 8 解读：ablation 总览显示 Semantic Tube family 整体优于 Two View、Mask、Curvature 等替代 family；在 Semantic Tube 内部，Zero、Inst、Mean、Sign、Pred、Warmup 等变体均不如 Full。特别是 Pred 变体（训练线性 projector $P$ 使 $1-\cos (P(h_r-h_s),h_t-h_r)$ 最小）在各配置下降，支持作者的 (P5)：identity predictor 比 learned projection 更符合局部线性假设。

Figure 13a–13c 解读：这组 appendix 图分别展示 Semantic Tube、Two Views、Mask 三类变体的 $\lambda$ tuning。可读出的代表峰值包括 Tube $84.29\pm 0.36$、Tube Zero $83.80\pm 0.62$、Tube Pred $76.11\pm 1.66$、Tube Inst $81.93\pm 1.05$；Two Views 系列约为 $81.39\pm 0.65$、$81.58\pm 0.89$、$80.54\pm 0.49$、$76.07\pm 0.73$；Mask 系列标注 $74.14\pm 3.45$、$71.98\pm 1.60$、$69.42\pm 0.97$、$66.10\pm 2.70$。这些数值说明：最接近 geodesic/local-linearity 假设的 Tube full 变体最好，而加入 predictor 或改成 mask-recovery 任务会偏离核心机制。

Pairwise p-values 也支持 family-level superiority。best-performing LLM-JEPA2 相对 Two View、Mask、Curvature 的 one-tailed paired $t$-test p-values 分别为 $1.14\times 10^{-3}$、$1.77\times 10^{-3}$、$3.04\times 10^{-5}$；Two View 相对 Mask、Curvature 分别为 $4.76\times 10^{-3}$、$5.10\times 10^{-5}$；Mask 相对 Curvature 为 $1.28\times 10^{-4}$。在更细的 option 比较中，部分 p-value 超过 0.05（如 LLM-JEPA2 vs Zero 的 0.0534、2View+Warmup vs 2View 的 0.265、2View vs Pred 的 0.0689、Mask+all vs Inst/Recover 的 0.0629），因此作者没有把每个细粒度差异都过度解释。

5.6 Limitations and caveats

第一，Geodesic Hypothesis 是强假设。论文用 ODE、least action、local linearity 和 SNR 推导给出合理化，但没有直接观测真实语义流形或 ground-truth $h^{\ast }$；实验只能间接验证其后果。第二，STP 的好处依赖小 $\lambda$，过强正则会让模型过度追求直线化，损害本应弯曲的语义轨迹。第三，released code 与论文公式存在 span-level 实现差异，且公开脚本未完整覆盖论文中所有模型/数据集 sweep 的 exact launch commands。第四，主要实验集中在 fine-tuning 和相对小规模开源模型；“violating scaling laws”应理解为在 NL-RX-SYNTH 这类任务上打破 data term 的经验边界，而不是证明所有 LLM 预训练场景都能 16× 减少数据。

总体结论：STP 的贡献在于把 JEPA 的 embedding-space predictive learning 改造成语言序列内部的 geodesic regularizer。它的实现开销小、无需人工 two-view scaffold，并在数据效率、跨任务 accuracy、diversity preservation 和 ablation 上给出一致证据。最值得带走的技术点不是“cosine loss 又赢了”，而是：对连续 hidden-state trajectory 的 cell-internal geometry 施加正确弱约束，可能比单纯增加数据更有效。