Progress-Think：基于语义进度推理的视觉语言导航新范式

Progress-Think：基于语义进度推理的视觉语言导航新范式 | CVPR 2026 精读

论文信息

标题：Progress-Think: Semantic Progress Reasoning for Vision-Language Navigation

会议：CVPR 2026

单位：中国人民大学信息学院、地平线机器人、中国科学院自动化研究所

代码：https://horizonrobotics.github.io/robot_lab/progress-think

论文：https://openaccess.thecvf.com/content/CVPR2026/papers/Wang_Progress-Think_Semantic_Progress_Reasoning_for_Vision-Language_Navigation_CVPR_2026_paper.pdf

一、背景：导航机器人的「进度迷茫症」

想象一下：你给家里的机器人下令「穿过客厅，右转进卧室，走到靠窗的床头柜停下」。机器人走着走着就容易犯两个经典错误：

空间碎片化失忆：明明刚走完客厅，转头就忘了自己已经完成了哪段指令，反复在原地打转；
身份漂移式迷路：走了一半拐错弯，还以为自己在正确路线上，越走越偏。

这就是视觉语言导航（VLN） 领域的长期痛点：长时序任务中，智能体很难稳定感知自己在整条指令中的完成进度。

过往方案主要有两种，但都不好用：

数字进度法：直接回归一个「完成百分比」的数值。但走了50%的路程，不等于完成了50%的指令语义，拐错弯的话走再远也白搭；
端到端黑盒法：VLA模型把进度藏在隐层里，不做显式建模。结果就是模型决策不可解释，长路径下误差越积越大，直接跑偏。

本文给出了一个优雅的新思路：不估数字进度，直接预测与当前观察对齐的指令语义片段，也就是「语义进度」。更厉害的是，整个过程不需要额外的进度标注，完全靠数据本身的结构特性自监督学习。

二、核心洞察：视觉与指令的单调共进展性

整个工作的基石，是一个被前人忽略的天然结构属性：视觉观察序列和指令语义序列是单调共同推进的。

图1 VLN中的单调共进展特性（出自原文Figure 1）

随着智能体不断移动、观察到的画面越来越多，与之匹配的指令前缀只会越来越长，不会出现「走了两步反而倒退回指令开头」的情况。就像你背课文，越往后背，能对应上的前文内容越多，不可能背着背着突然对齐到第一句。

通俗备注：这是一个非常强的先验约束。之前的方法都把进度当成一个纯预测问题，而本文直接利用这个天然的单调性，把无监督进度学习变成了一个可微分的对齐问题。

三、整体框架概览

Progress-Think把导航拆成「进度推理」和「动作决策」两个互补模块，通过三阶段训练实现无标注的进度学习，全程端到端可优化。

图2 Progress-Think整体框架与三阶段训练流水线（出自原文Figure 2）

三个训练阶段环环相扣：

自对齐进度预训练（SAPP）：纯自监督，先把进度推理模块教明白，能从视觉历史推断出完成了哪段指令；
进度引导策略预训练：冻住进度模块，用它输出的语义进度当「路标」，引导动作策略学习，让决策和进度对齐；
进度-策略联合微调（PPCF）：两个模块一起用强化学习打磨，进度估得准不准，最终用导航效果说话，互相促进。

四、核心方法详解

4.1 阶段一：自对齐进度预训练（SAPP）

这一步的目标是：在没有任何进度标注的情况下，让模型学会从视觉观察推断语义进度。

进度推理模块

首先定义进度推理模块 PRM：输入历史观察和当前帧，输出当前完成的指令语义片段。

I ^ ∗ t = F ∗ P ( O ∗ t , o ∗ t ) (1) \hat{\mathcal{I}}*{t}=F*{P}\left(\mathcal{O}*{t}, o*{t}\right) \tag{1} I^∗t=F∗P(O∗t,o∗t)(1)

符号全解释：

I ^ t \hat{\mathcal{I}}_{t} I^t：第 t t t步预测的、已完成部分的指令语义文本；
F P F_P FP：进度推理模块（Progress Reasoning Module）；
O ∗ t = o 0 , o 1 , . . . , o ∗ t − 1 \mathcal{O}*t = {o_0, o_1, ..., o*{t-1}} O∗t=o0,o1,...,o∗t−1：到第 t t t步为止的历史观察序列；
o t o_t ot：当前时刻的第一视角RGB图像。

前缀子集软交叉熵损失

怎么不用标注训练这个模块？核心思路是：正确的进度，一定是完整指令的一个前缀。

模型对每个可能的前缀长度 k k k，计算预测片段和真实指令前缀的交叉熵，再转成概率分布：

p θ ( k ∣ O ∗ t , I ) ∝ e x p ( − C E ( I ^ ∗ t , 1 : k , I 1 : k ) τ ) (2) p_{\theta}\left(k | \mathcal{O}*{t}, \mathcal{I}\right) \propto exp \left(-\frac{CE\left(\hat{\mathcal{I}}*{t, 1: k}, \mathcal{I}_{1: k}\right)}{\tau}\right) \tag{2} pθ(k∣O∗t,I)∝exp −τCE(I^∗t,1:k,I1:k) (2)

符号全解释：

p θ ( k ∣ O t , I ) p_\theta(k | \mathcal{O}_t, \mathcal{I}) pθ(k∣Ot,I)：给定观察和完整指令，当前进度对应第 k k k个前缀位置的概率；
k k k：指令前缀的长度，取值范围是 $1 , ∣ I ∣$ $1, \|\\mathcal{I}\|$ $1,∣I∣$ ；
C E ( ⋅ , ⋅ ) CE(\cdot, \cdot) CE(⋅,⋅)：交叉熵函数，衡量预测文本和真实前缀的差异；
I ^ t , 1 : k \hat{\mathcal{I}}_{t,1:k} I^t,1:k：模型预测的、长度为 k k k的进度文本；
I 1 : k \mathcal{I}_{1:k} I1:k：真实完整指令的前 k k k个token；
τ \tau τ：温度系数，控制概率分布的尖锐程度，越小越接近硬选择。

用概率分布的期望作为连续可微的进度长度：

k ^ ∗ t = E ∗ p θ $k$ \hat{k}*{t}=\mathbb{E}*{p_{\theta}} $k$ k^∗t=E∗pθ $k$

对应的前缀损失定义为：

L ∗ p r e f i x = E ∗ t $− τ l o g ∑ k e x p ( − C E ( I \^ ∗ t , 1 : k , I ∗ 1 : k ) τ )$ (3) \mathcal{L}*{prefix }=\mathbb{E}*{t}\left $-\\tau log \\sum_{k} exp \\left(-\\frac{CE\\left(\\hat{\\mathcal{I}}\*{t, 1: k}, \\mathcal{I}\*{1: k}\\right)}{\\tau}\\right)\\right$ \tag{3} L∗prefix=E∗t −τlogk∑exp −τCE(I^∗t,1:k,I∗1:k) (3)

通俗备注：这一步就是让模型「猜」自己走到了指令的第几个字，猜对的前缀给高分，猜错的给低分。全程用软概率，保证梯度能传回去，不需要人工标哪一步对应哪段指令。

单调排序损失

光有前缀对齐还不够，必须保证「进度只能往前走，不能倒退」。对同一轨迹中任意两个时刻 t i < t j t_i < t_j ti<tj，强制约束后者的进度长度不小于前者：

L ∗ m o n o = E ∗ ( i , j ) : t i < t j $m a x ( 0 , k \^ ∗ t ∗ i − k \^ ∗ t ∗ j )$ (4) \mathcal{L}*{mono }=\mathbb{E}*{(i, j): t_{i}<t_{j}}\left $max \\left(0, \\hat{k}\*{t\*{i}}-\\hat{k}\*{t\*{j}}\\right)\\right$ \tag{4} L∗mono=E∗(i,j):ti<tj $max(0,k\^∗t∗i−k\^∗t∗j)$ (4)

符号全解释：

L m o n o \mathcal{L}_{mono} Lmono：单调排序损失；
k ^ ∗ t i , k ^ ∗ t j \hat{k}*{t_i}, \hat{k}*{t_j} k^∗ti,k^∗tj：时刻 i i i和时刻 j j j预测的进度长度；
m a x ( 0 , ⋅ ) max(0, \cdot) max(0,⋅)：合页损失形式，只有当出现「进度倒退」时才会产生损失，正常前进时损失为0。

第一阶段总损失

L ∗ S A P P = L ∗ p r e f i x + L m o n o (5) \mathcal{L}*{SAPP}=\mathcal{L}*{prefix }+\mathcal{L}_{mono } \tag{5} L∗SAPP=L∗prefix+Lmono(5)

前缀损失保证进度和指令语义对齐，单调损失保证进度时序合理，两者结合就能在无标注下学到靠谱的语义进度。

4.2 阶段二：进度引导策略预训练

有了靠谱的进度推理模块，下一步就是用它来指导动作策略学习。

进度引导的VLA策略

策略网络的输入不再只有图像和指令，还加入了当前的语义进度：

a t : t + K − 1 = π θ ( O ∗ t , o ∗ t , I , I ^ t ) (6) a_{t: t+K-1}=\pi_{\theta}\left(\mathcal{O}*{t}, o*{t}, \mathcal{I}, \hat{\mathcal{I}}_{t}\right) \tag{6} at:t+K−1=πθ(O∗t,o∗t,I,I^t)(6)

符号全解释：

a t : t + K − 1 a_{t:t+K-1} at:t+K−1：一次性预测的未来 K K K步动作序列，本文中 ( K = 3 ) (K=3) (K=3)；
π θ \pi_\theta πθ：进度引导的VLA策略网络（PG-VLA）；
I ^ t \hat{\mathcal{I}}_t I^t：进度推理模块输出的已完成指令片段，相当于告诉策略「前面的不用管了，专注剩下的部分」。

策略预训练损失

这一阶段冻结进度推理模块，只训策略，用标准的交叉熵监督：

L ∗ p o l i c y = − l o g π ∗ θ ( a t : t + K − 1 ∗ ∣ O ∗ t , o ∗ t , I , I ^ t ) (7) \mathcal{L}*{policy }=-log \pi*{\theta}\left(a_{t: t+K-1}^{*} | \mathcal{O}*{t}, o*{t}, \mathcal{I}, \hat{\mathcal{I}}_{t}\right) \tag{7} L∗policy=−logπ∗θ(at:t+K−1∗∣O∗t,o∗t,I,I^t)(7)

其中 a t : t + K − 1 ∗ a_{t:t+K-1}^* at:t+K−1∗是专家轨迹的真实动作序列。

通俗备注：这一步就像先把「导航领航员」固定住，让「司机」学着根据领航员报的进度开车。领航员已经提前训好了，司机只需要专注于把动作做对。

4.3 阶段三：进度-策略联合微调（PPCF）

自监督学出来的进度，不一定最适配导航任务。于是第三阶段用强化学习，把两个模块放在一起联合优化，采用GRPO（组相对策略优化）框架。

三项互补奖励

作者设计了三个奖励，共同约束动作和进度的质量：

1. 动作奖励

只奖励预测序列中「最长正确前缀」，一旦第一步错了，后面全不算分，倒逼模型把前面的动作做对：

r a c t = ∑ i = 0 K − 1 ∏ j = 0 i 1 $a t + j = a t + j *$ (8) r_{act }=\sum_{i=0}^{K-1} \prod_{j=0}^{i} \mathbb{1}\left $a_{t+j}=a_{t+j}\^{\*}\\right$ \tag{8} ract=i=0∑K−1j=0∏i1 $at+j=at+j*$ (8)

符号全解释：

r a c t r_{act} ract：动作奖励，取值范围 0 , 1 , 2 , . . . , K {0,1,2,...,K} 0,1,2,...,K；
1 $\cdot$ \mathbb{1} $\\cdot$ 1 $\cdot$ ：指示函数，条件成立为1，否则为0；
a t + j a_{t+j} at+j：模型预测的第 j j j步动作；
a t + j ∗ a_{t+j}^* at+j∗：真实的第 j j j步动作。

2. 格式奖励

保证输出的动作序列符合语法规范，避免生成无效动作：

r f m t = { 1 , if a t : t + K − 1 is in valid format 0 , otherwise . (9) r_{fmt}= \begin{cases} 1, & \text{if}\ a_{t: t+K-1}\ \text{is in valid format} \\ 0, & \text{otherwise}. \end{cases} \tag{9} rfmt={1,0,if at:t+K−1 is in valid formatotherwise.(9)

3. 进度长度奖励

防止模型瞎吹进度------还没走几步就说自己走完了。进度文本长度不能超过完整指令，超长了就惩罚：

r l e n = { 1 , if ∣ I ^ t ∣ ≤ ∣ I ∣ − β ( ∣ I ^ t ∣ − ∣ I ∣ ) , otherwise (10) r_{len}= \begin{cases} 1, & \text{if}\ \left|\hat{\mathcal{I}}{t}\right| \leq|\mathcal{I}| \\ -\beta\left(\left|\hat{\mathcal{I}}{t}\right|-|\mathcal{I}|\right), & \text{otherwise} \end{cases} \tag{10} rlen=⎩ ⎨ ⎧1,−β( I^t −∣I∣),if I^t ≤∣I∣otherwise(10)

符号全解释：

r l e n r_{len} rlen：进度长度奖励；
∣ I ^ t ∣ |\hat{\mathcal{I}}_t| ∣I^t∣：预测进度文本的长度；
∣ I ∣ |\mathcal{I}| ∣I∣：完整指令的长度；
β \beta β：超长惩罚系数，大于0。

总奖励 ：三项直接相加

r t = r a c t + r f m t + r l e n (11) r_{t}=r_{act}+r_{fmt}+r_{len} \tag{11} rt=ract+rfmt+rlen(11)

GRPO联合优化

每次采样 N N N条轨迹，计算每条轨迹的优势函数：

A ( n ) = r ( n ) − m e a n ( r t ) s t d ( r t ) (12) A^{(n)}=\frac{r^{(n)}-mean\left(r_{t}\right)}{std\left(r_{t}\right)} \tag{12} A(n)=std(rt)r(n)−mean(rt)(12)

最终优化目标采用裁剪的策略梯度，同时更新策略和进度两个模块：

L ∗ P P C F = − E ∗ n $min ( ρ ( n ) A ( n ) , c l i p ( ρ ( n ) , 1 - ϵ , 1 + ϵ ) A ( n ) )$ (13) \mathcal {L}*{PPCF}=-\mathbb {E}*{n}\left $\\operatorname\* {min}\\left( \\rho \^{(n)}A\^{(n)}, clip(\\rho \^{(n)},1-\\epsilon ,1+\\epsilon )A\^{(n)}\\right) \\right$ \tag{13} L∗PPCF=−E∗n $min(ρ(n)A(n),clip(ρ(n),1-ϵ,1+ϵ)A(n))$ (13)

其中重要性采样比由两部分组成，分别对应策略网络和进度模块：

ρ ( n ) = π θ ( a t ( n ) ∣ O ∗ t , o ∗ t , I ^ ∗ t ( n ) ) π ∗ θ o l d ( a t ( n ) ∣ O ∗ t , o ∗ t , I ^ ∗ t ( n ) ) ⋅ F ∗ p ( I ^ ∗ t ( n ) ∣ O ∗ t , o t ) F p o l d ( I ^ ∗ t ( n ) ∣ O ∗ t , o t ) \rho^{(n)}=\frac{\pi_{\theta}\left(a_{t}^{(n)} | \mathcal{O}*{t}, o*{t}, \hat{\mathcal{I}}*{t}^{(n)}\right)}{\pi*{\theta_{old }}\left(a_{t}^{(n)} | \mathcal{O}*{t}, o*{t}, \hat{\mathcal{I}}*{t}^{(n)}\right)} \cdot \frac{F*{p}\left(\hat{\mathcal{I}}*{t}^{(n)} | \mathcal{O}*{t}, o_{t}\right)}{F_{p_{old }}\left(\hat{\mathcal{I}}*{t}^{(n)} | \mathcal{O}*{t}, o_{t}\right)} ρ(n)=π∗θold(at(n)∣O∗t,o∗t,I^∗t(n))πθ(at(n)∣O∗t,o∗t,I^∗t(n))⋅Fpold(I^∗t(n)∣O∗t,ot)F∗p(I^∗t(n)∣O∗t,ot)

通俗备注：这一步就是两个模块组队打怪升级。导航走得好，就说明进度估得准、动作选得对，两边一起加分；走得不好就一起调整。练到最后，进度模块越来越懂怎么报进度对导航最有帮助，策略模块也越来越会看进度走路。

五、实验结果全解析

5.1 实验设置

数据集：R2R-CE（室内连续环境导航）、RxR-CE（多语言跨数据集泛化）；
评价指标 ：
- SR（成功率）：成功到达终点的比例，越高越好；
- SPL（路径长度加权成功率）：兼顾成功率和路径效率，越高越好；
- NE（导航误差）：终点距离目标的距离，越低越好；
- OSR（预言家成功率）：轨迹中最优位置的成功率。

5.2 主实验：R2R-CE 新SOTA

表1 R2R-CE验证集（未见场景）性能对比（出自原文Table 1）

方法	单目RGB	深度	全景	NE↓	OSR↑	SR↑	SPL↑	外部数据
BEVBert †		✓	✓	4.57	67.0	59.0	50.0	-
ETPNav †		✓	✓	4.71	65.0	57.0	49.0	-
NaVILA	✓			5.22	62.5	54.0	49.0	2215K
Aux-Think	✓			5.49	62.9	55.7	48.7	1600K
MonoDream	✓			5.45	61.5	55.8	49.1	0K
Progress-Think（本文）	✓			4.68	63.6	60.1	53.6	0K

注：† 表示未使用大语言模型的传统方法。

结果分析：

零外部数据登顶：Progress-Think没有用任何额外的网页数据、VQA数据，只用模拟器内数据就拿到了SOTA，数据效率极高；
单目吊打多传感器：只用单目RGB输入，效果超过了带深度、带全景的传统方法，说明语义进度带来的决策收益，甚至超过了额外传感器的信息增益；
效率与精度兼顾：SR达到60.1%，SPL达到53.6%，相比之前的SOTA MonoDream，SR涨了4.3个点，SPL涨了4.5个点，提升非常显著。

5.3 跨数据集零样本泛化

表2 RxR-CE验证集零样本跨数据集泛化结果（出自原文Table 2）

方法	NE↓	OSR↑	SR↑	SPL↑
Seq2Seq	11.8	5.02	3.51	3.43
NaVid	8.41	34.5	23.8	21.2
MonoDream	8.57	35.9	25.1	21.6
Progress-Think（本文）	8.30	38.3	27.5	22.7

结果分析 ：

所有模型都只在R2R-CE上训练，直接拿到RxR-CE上测试，不做任何微调。Progress-Think依然保持SOTA，说明语义进度推理学到的是通用的导航逻辑，不是拟合特定数据集的分布，泛化能力很强。

5.4 进度表示形式对比

表3 不同进度表示方式的性能对比（出自原文Table 3）

方法	NE↓	OSR↑	SR↑	SPL↑
数字进度回归	8.25	37.7	33.4	26.2
指令重建	7.67	45.8	37.7	32.1
Progress-Think（本文）	6.84	50.4	43.8	38.5

结果分析：

数字进度最差：一个光秃秃的百分比没有语义信息，给策略的指导非常有限；
指令重建中等：全局重建指令太粗糙，没有步进式的对齐感；
语义进度最优：步进式、指令风格的进度表示，和导航的时序决策天然匹配，给策略的引导最直接。

5.5 消融实验

表4 SAPP与PPCF统一消融实验（出自原文Table 4）

前缀损失	单调损失	动作+格式奖励	进度长度奖励	NE↓	OSR↑	SR↑	SPL↑
				8.16	44.1	33.0	28.3
✓				7.26	45.8	39.4	34.6
✓	✓			6.94	48.4	41.4	36.5
✓	✓	✓		7.16	46.2	40.0	35.0
✓	✓	✓	✓	6.84	50.4	43.8	38.5

结果分析：

加上前缀软对齐损失，SR直接从33.0涨到39.4，说明显式进度建模本身就有巨大收益；
再加上单调损失，SR再涨2个点，证明「进度只进不退」是非常有效的结构先验；
只加动作和格式奖励的RL，性能反而略有下降，说明没有约束的话，进度容易估乱；
加上进度长度奖励后，性能全面反弹，SR冲到43.8，说明约束进度的合理性至关重要。

5.6 执行步数消融

表5 每步预测动作执行数量的消融（出自原文Table 5）

执行步数	NE↓	OSR↑	SR↑	SPL↑
1	4.73	62.1	58.0	51.1
2	4.80	62.2	58.9	52.3
3	4.68	63.6	60.1	53.6

结果分析 ：

一次预测三步、全部执行效果最好。只执行一步的话，模型太短视，频繁重规划反而积累误差；三步执行能更好地利用进度信息，决策更稳定。

5.7 指令粒度鲁棒性

图4 不同指令粒度下的性能对比（出自原文Figure 4）

横坐标是指令长度和步数的比值，越左指令越简略，越右指令越细碎。可以看到，无论指令是极度简略还是极度细碎，Progress-Think相比无进度的基线都有显著提升，尤其在两端极端情况提升更大。说明语义进度对不同风格的指令都有很强的适配性。

5.8 模型效率对比

表6 模型参数量与推理效率对比（出自原文Table 6）

方法	参数量↓	单集耗时↓	SR↑
NaVILA	8B	56.84s	54.0
Aux-Think	8B	58.04s	54.8
Progress-Think（本文）	2B+2B	36.60s	60.1

结果分析 ：

Progress-Think用两个2B模块，总参量远小于8B大模型，单集推理时间快了近40%，效果还高了5个点以上，性价比拉满。进度推理带来的收益，完全不需要靠堆参数实现。

5.9 定性可视化

图3 进度推理质量定性对比（出自原文Figure 3）

从图中可以直观看到：

GPT-4o和基线NVILA输出的都是空话、套话，和指令进度几乎对不上，甚至会幻觉；
去掉单调损失的版本，会出现进度顺序混乱的问题；
去掉联合微调的版本，进度描述比较模糊，不够精准；
完整的Progress-Think输出的进度，严格贴合指令的步骤，清晰对应智能体当前的位置，准确又简洁。

六、核心代码实现

以下是两个核心模块的简化PyTorch实现，对应论文中的关键逻辑。

6.1 单调排序损失实现

复制代码

import torch
import torch.nn as nn
import torch.nn.functional as F

class MonotonicOrderingLoss(nn.Module):
    def __init__(self):
        super().__init__()
    
    def forward(self, k_hat):
        """
        计算单调排序损失，对应论文公式(4)
        Args:
            k_hat: [T] 序列，每个时刻预测的进度长度
        Returns:
            loss: 标量损失
        """
        T = k_hat.shape[0]
        # 构造所有 i<j 的配对
        i_indices = []
        j_indices = []
        for i in range(T):
            for j in range(i+1, T):
                i_indices.append(i)
                j_indices.append(j)
        
        k_i = k_hat[i_indices]
        k_j = k_hat[j_indices]
        
        # max(0, k_i - k_j)，倒退的时候产生损失
        loss = torch.mean(torch.clamp(k_i - k_j, min=0.0))
        return loss

6.2 进度长度奖励计算

复制代码

def progress_length_reward(progress_text_len, full_instruction_len, beta=0.1):
    """
    计算进度长度奖励，对应论文公式(10)
    Args:
        progress_text_len: 预测进度文本的token长度
        full_instruction_len: 完整指令的token长度
        beta: 超长惩罚系数
    Returns:
        reward: 进度长度奖励
    """
    if progress_text_len <= full_instruction_len:
        return 1.0
    else:
        return 1.0 - beta * (progress_text_len - full_instruction_len)

七、总结与展望

核心贡献

范式创新：首次在VLN中提出语义进度推理，把进度估计从数值回归变成了视觉-语义的步进式对齐问题；
无监督训练：三阶段训练框架，完全不需要额外的进度标注，靠指令天然的单调共进展性就能自监督学习；
性能全面领先：在R2R-CE和RxR-CE上都取得SOTA，参数更小、速度更快、泛化性更好，还具备可解释性。

局限与未来

目前框架主要面向室内连续环境的类别指令导航，未来可以集成开放词汇能力，扩展到室外大场景，也可以和视觉语言导航中的其他推理模块结合，进一步提升长时序任务的鲁棒性。

总的来说，Progress-Think提供了一个非常清爽的思路：不用堆参数、不用加数据，只要抓住任务本身的结构特性，给模型加一个合理的显式锚点，就能带来显著的性能提升。这可能也是未来具身智能中，让决策更稳定、更可解释的一个重要方向。