目录
Xczzh21小时前32次提交

VerifyNav-World — 面向长程视觉语言导航的预测式世界推演、动作结果核验与因果恢复演化的韧性增强系统

赛题:第16题 面向开放环境的具身操作系统韧性增强技术 关键能力:① 环境异常感知与自适应响应 ② 任务执行闭环验证与失败恢复 ④ 错误归因与经验沉淀

方法总览与流程设计

📺 演示视频知行验航.mp4 — 完整系统效果展示(VLN-CE + Isaac Sim B2 机械狗)

VerifyNav-World 是一个面向长程视觉语言导航(VLN)的韧性增强系统,由两个互补子系统构成:

  • NavWorld:事件驱动的反事实世界模型,在相同当前状态下并行推演不同动作的未来后果,选择最优动作
  • VerifyNav:证据驱动的动作-结果核验与因果恢复框架,要求真实执行证据确认状态转移,并在失败时进行因果归因与结构化恢复
指令 → [NavWorld: 反事实推演 → 后果评分 → 动作选择]
         → 执行 → [VerifyNav: 证据编译 → 时序验证 → 提交/恢复]
           → 恢复后重验证 → 持续演化

1.训练环境安装

快速复现(推荐)

使用我们导出的完整 conda 环境,一键复现所有依赖:

# 从 environment.yml 重建完整环境(含 Habitat-Sim/Lab v0.1.7 + PyTorch 2.7 + Flash-Attention)
conda env create -f environment.yml
conda activate vlnce

环境包含 180+ 个精确版本依赖:PyTorch 2.7.1+cu128、Transformers 4.37.2、Habitat-Sim/Lab 0.1.7、Flash-Attention 2.8、DeepSpeed 0.14.5 等。

手动构建

要手动构建训练环境,请运行:

./environment_setup.sh VerifyNav-World
conda activate VerifyNav-World

数据集下载与仿真模拟器安装

1.1 VLN-CE数据集 与 Habitat-Sim模拟器

推理训练标注由我们的自动数据引擎生成,该引擎会在关键节点标注稀疏的自感知推理。请从 Dataset 下载数据,并在每个子文件夹中解压 videos.tar.gz

  • r2r / rxr: 由现有策略滚动执行得到的轨迹,并在需要时进行纠正;推理标注由我们的数据引擎生成。
  • r2rfollow / rxrfollow: 沿专家路径执行得到的轨迹;推理标注由我们的数据引擎生成。
  • Human: 不包含在本数据集中。请按照 NaVILA-Dataset 的说明进行处理:使用 **video IDs**,通过 yt-dlp 下载视频,并使用 NaVILA repo 中的 scripts/extract_rawframes.py 提取视频帧。

数据目录结构应如下所示:

VerifyNav-World
|--data
    ├─ reason
    |   ├─ r2r
    |   |    ├─ _anno_cot
    |   |    |    ├─ annotations_shuffle_uni.json
    |   |    |    ├─ cot_new.json
    |   |    ├─ videos
    |   ├─ rxr
    |   |    ├─ ...
    |   ├─ r2rfollow
    |   |    ├─ ...
    |   ├─ rxrfollow
    |   |    ├─ ...
    ├─ Human
    |   ├─ raw_frames
    |   |    ├─ <video_id>
    |   |    |    ├─ 0001.jpg
    |   |    |    ├─ ...
    |   ├─ annotations_shuffled.json

1.2 医院、工厂、城市等开放复杂场景数据 与 Isaac Sim模拟器 + Isaac Lab 强化学习动作框架安装

请确保你的计算机上已经安装 Isaac Sim。否则,请按照此指南完成安装。

如果通过 Omniverse Launcher 进行安装,请确保选择并安装 Isaac Sim 5.1.0。在 Ubuntu 22.04 或更高版本中,也可以通过 pip 进行安装:

pip install isaacsim-rl==5.1.0 isaacsim-replicator==5.1.0 isaacsim-extscache-physics==5.1.0 isaacsim-extscache-kit-sdk==5.1.0 isaacsim-extscache-kit==5.1.0 isaacsim-app==4.1.0 --extra-index-url https://pypi.nvidia.com

克隆Isaac Lab并链接扩展。

git clone git@github.com:isaac-sim/IsaacLab.git
sudo apt install cmake build-essential
./isaaclab.sh --install # or "./isaaclab.sh -i"

安装验证,请从存储库的顶部运行以下命令:

# Option 1: Using the isaaclab.sh executable
# note: this works for both the bundled python and the virtual environment
./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py

# Option 2: Using python in your virtual environment
python scripts/tutorials/00_sim/create_empty.py

下载Isaac Sim资产包和场景文件,请按照此指南完成安装:

sudo apt install aria2
cd ./data/isaacsim_data
aria2c -c --checksum=md5=0d1d98f46780d13bf83779c79360f883 "https://downloads.isaacsim.nvidia.com/isaac-sim-assets-complete-5.1.0.001.zip"
aria2c -c --checksum=md5=9a03f3a32a2962fce4f464fc784a9da9 "https://downloads.isaacsim.nvidia.com/isaac-sim-assets-complete-5.1.0.002.zip"
aria2c -c --checksum=md5=37ee649b2b35c6bc72958f12e625f862 "https://downloads.isaacsim.nvidia.com/isaac-sim-assets-complete-5.1.0.003.zip"

把包解压到文件夹里:

cat isaac-sim-assets-complete-5.1.0.001.zip isaac-sim-assets-complete-5.1.0.002.zip isaac-sim-assets-complete-5.1.0.003.zip > isaac-sim-assets-complete-5.1.0.zip
unzip "isaac-sim-assets-complete-5.1.0.zip" -d ~/isaacsim_assets

2. 训练

2.1 多模态编码器调优

我们以 NaVILA 风格的 VILA 为基础模型,其由 Llama-3 8B、SigLIP 和 mm_projector 组成,并采用 8 帧视觉输入。随后,使用我们的推理数据进行微调,使模型学习自感知推理能力。预训练模型以及我们训练得到的 模型权重 可从这里下载。

export DATA_ROOT=/path/to/data
bash scripts/train/sft_8frames.sh

2.2 World-VLN 训练(NavWorld 世界模型)

NavWorld 采用两阶段训练策略,在冻结的 VLM 骨架上逐步训练世界模型模块:

阶段 1:世界模型预训练(冻结 VLM 骨架)

训练目标:在世界模型模块(EventGraphEncoder、WorldStateModule、CounterfactualDynamicsModule)中建立从当前状态预测动作后果的能力。VLM 骨架(SigLIP + MM Projector + LLM)完全冻结。

参数 说明 默认值
navworld_num_slots 通用隐变量槽位数 (M) 8
navworld_num_candidates 候选动作数 (K) 5
navworld_max_events 每条指令最大任务事件节点数 16
lambda_trans 转移损失权重 1.0
export DATA_ROOT=/path/to/data
export VLM_CHECKPOINT=/path/to/vlm_checkpoint

bash scripts/train/train_navworld_stage1.sh

阶段 1 等效命令:

torchrun --nnodes=1 --nproc_per_node=8 --master_port=25001 \
    llava/train/train.py \
    --deepspeed scripts/zero2.json \
    --model_name_or_path ${VLM_CHECKPOINT} \
    --navworld_stage 1 \
    --freeze_vlm True \
    --num_train_epochs 5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --learning_rate 2e-4 \
    --navworld_num_slots 8 \
    --navworld_num_candidates 5 \
    --navworld_max_events 16 \
    --lambda_trans 1.0 \
    --output_dir outputs/navworld_stage1

在阶段 1 基础上,启用后果评分器(ConsequenceScorer)和后验校准模块(PosteriorCalibrationModule),并部分解冻 LLM 层进行联合优化。

参数 说明 默认值
lambda_trans 视觉-事件转移损失 1.0
lambda_cf 反事实偏好损失 0.5
lambda_cal 执行残差校准损失 0.3
python llava/train/train.py \
    --deepspeed scripts/zero2.json \
    --model_name_or_path outputs/navworld_stage1 \
    --navworld_stage 2 \
    --freeze_vision_tower True \
    --unfreeze_llm_layers 4 \
    --num_train_epochs 5 \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 8 \
    --learning_rate 1e-4 \
    --lambda_trans 1.0 \
    --lambda_cf 0.5 \
    --lambda_cal 0.3 \
    --output_dir outputs/navworld_stage2

损失函数

NavWorld 使用三个核心训练目标:

  • L_trans — 视觉-事件转移损失:监督未来视觉特征、任务事件信念和停止正确性预测
  • L_cf — 反事实偏好损失:预测评分分布与软分支效用分布之间的 KL 散度
  • L_cal — 执行残差校准损失:监督校准后的状态和不确定性估计

总损失:L_NavWorld = L_trans + λ_cf · L_cf + λ_cal · L_cal

2.3 VerifyNav 训练(动作-结果核验与因果恢复)

VerifyNav 采用三阶段渐进式训练策略,逐阶段引入更复杂的恢复与演化能力:

阶段 训练模块 冻结 训练目标 关键指标
1 A + B VLM 骨架 证据编译器 + 时序验证器 验证 F1,虚假进度 ↓
2 + C Vision Tower + 因果归因器 + 恢复策略 归因准确率,恢复成功率
3 + D Vision Tower + 策略演化 + 证伪原型 无效修复重复率 ↓

阶段 1:证据编译 + 时序验证

训练 Module A(TransitionParser + EvidenceCompiler)和 Module B(TemporalVerifier),VLM 骨架完全冻结:

python llava/train/train.py \
    --deepspeed scripts/zero2.json \
    --model_name_or_path /path/to/vlm_ckpt \
    --verifynav_stage 1 \
    --freeze_vlm True \
    --num_train_epochs 5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --learning_rate 2e-4 \
    --output_dir outputs/verifynav_s1

阶段 2:因果恢复

在阶段 1 基础上,解冻 LLM 最后 4 层,训练 Module C(CausalRecoveryModule):

python llava/train/train.py \
    --deepspeed scripts/zero2.json \
    --model_name_or_path outputs/verifynav_s1 \
    --verifynav_stage 2 \
    --unfreeze_llm_layers 4 \
    --num_train_epochs 5 \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 8 \
    --learning_rate 1e-4 \
    --output_dir outputs/verifynav_s2

阶段 3:证伪驱动演化

训练 Module D(FalsificationStrategyModule),引入闭环恢复控制器:

python llava/train/train.py \
    --deepspeed scripts/zero2.json \
    --model_name_or_path outputs/verifynav_s2 \
    --verifynav_stage 3 \
    --num_train_epochs 5 \
    --learning_rate 5e-5 \
    --output_dir outputs/verifynav_s3

损失函数

损失 模块 监督目标
L_comp A 证据集匹配 + 关系 + 时间窗口 + 稀疏性
L_ver B 三分类 CE + 六维残差回归 + 任务状态修正
L_attr C 因果类别 CE + 干预一致性 + 不变性
L_rep C 恢复算子选择 + 效果预测 + 效用排序
L_evo D 证伪残差 Huber + 演进评分排序

2.4 Isaac Lab 强化学习动作训练

B2 机械狗的运动控制策略采用 Isaac Lab + RSL-RL PPO 进行训练,分为两个阶段:

阶段 1:平地训练(~15 分钟,300 轮)— 学习基本站立和速度跟踪:

cd Isaccsim-test
bash b2_training/train.sh flat

阶段 2:崎岖地形训练(~2 小时,1500 轮)— 学会上下坡、越障、复杂地形:

bash b2_training/train.sh rough

完整训练流程(平地 → 崎岖 → 导出 policy.jit):

bash b2_training/train.sh all

训练完成后,导出的 policy.pt 可直接部署:

policy = torch.jit.load('policy.pt').cuda()
action = policy(obs)

3. 评估

3.1 VLN-CE 评估

本仓库基于 VLN-CE 构建,而 VLN-CE 依赖较早版本的 Habitat-LabHabitat-Sim

  1. 创建 Conda 环境 awarevln-eval(Python 3.10)
conda create -n awarevln-eval python=3.10
conda activate awarevln-eval
  1. 源代码编译 Habitat-Sim 和 Habitat-Lab(v0.1.7)

请按照 VLN-CE 配置指南进行配置。

为解决 NumPy 兼容性问题,请应用以下热修复:

python evaluation/scripts/habitat_sim_autofix.py # 替换 habitat_sim/utils/common.py
  1. 安装 VLN-CE 依赖
pip install -r evaluation/requirements.txt
  1. 安装 VILA 依赖
pip install https://github.com/Dao-AILab/flash-attention/releases/download/v2.5.8/flash_attn-2.5.8+cu122torch2.3cxx11abiFALSE-cp310-cp310-linux_x86_64.whl

pip install -e .
pip install -e ".[train]"
pip install -e ".[eval]"

pip install git+https://github.com/huggingface/transformers@v4.37.2
site_pkg_path=$(python -c 'import site; print(site.getsitepackages()[0])')
cp -rv ./llava/train/transformers_replace/* $site_pkg_path/transformers/
cp -rv ./llava/train/deepspeed_replace/* $site_pkg_path/deepspeed/
  1. 修复 WebDataset 版本
pip install webdataset==0.1.103

数据准备

请按照 VLN-CE 的说明,将 R2R / RxR 标注文件和 MP3D 场景数据下载至 evaluation/data/ 目录下。本项目使用 Val-Unseen 数据划分和单目 RGB 输入。

evaluation/data/datasets
├─ RxR_VLNCE_v0
|   ├─ val_unseen
|   |    ├─ val_unseen_guide.json.gz
|   |    ├─ ...
├─ R2R_VLNCE_v1-3_preprocessed
|   ├─ val_unseen
|   |    ├─ val_unseen.json.gz
|   |    ├─ ...
evaluation/data/scene_datasets
├─ mp3d
|   ├─ 17DRP5sb8fy
|   |    ├─ 17DRP5sb8fy.glb
|   |    ├─ ...

反事实训练数据生成(NavWorld)

NavWorld 需要同状态多动作分支数据来训练反事实动力学模块。使用自动数据引擎生成:

python evaluation/vlnce_baselines/navworld/data_engine.py \
    --dataset r2r \
    --split train \
    --output data/counterfactual/r2r_train_branches.json \
    --num-candidates 10

VerifyNav 训练数据生成

python evaluation/vlnce_baselines/verifynav/data_engine.py \
    --dataset r2r \
    --split train \
    --output data/verifynav/r2r_train_samples.json

运行评估

  1. 使用己训练生成的 outputs/

  2. 使用以下命令在 R2R-CE 上运行评估:

cd evaluation
bash scripts/eval/r2r.sh

示例:

  • 单 GPU:

    MODEL_PATH=../ck/TOTAL_CHUNKS=1 GPU_LIST="0" bash scripts/eval/r2r.sh
  • 多 GPU,例如使用 8 张 GPU:

    MODEL_PATH=../ck/ TOTAL_CHUNKS=8 GPU_LIST="0,1,2,3,4,5,6,7" bash scripts/eval/r2r.sh
  1. 使用以下命令在 RxR-CE 上运行评估:
MODEL_PATH=../ck/ bash scripts/eval/rxr.sh
  1. NavWorld 评估(R2R-CE val-unseen):
cd evaluation
bash scripts/eval/r2r_navworld.sh
  1. VerifyNav 评估:
cd evaluation
MODEL_PATH=../ck/verifynav_s3 bash scripts/eval/r2r_verifynav.sh
  1. 评估结果保存在 evaluation/eval_awarevln/<CKPT_NAME>/ 目录下。各项指标会自动汇总;如需重新汇总,请运行:
python scripts/eval_jsons.py eval_awarevln/awarevln/VLN-CE-v1/val_unseen NUM_CHUNKS
python scripts/eval_jsons.py eval_awarevln/awarevln/RxR-VLN-CE-v1/val_unseen NUM_CHUNKS

3.2 Isaac Sim 动态评估

加载模型并部署 VLM 服务

python ./Isaccsim-test/vlm_server.py \
    --model_path ./models/navila-siglip-llama3-8b-8f \
    --port=54321 \
    --num_video_frames 1

加载 B2 机械狗和强化学习动作模型

加载 RL 运动策略 model_2999.pt,输入自然语言指令 --instruction 即可开始自主导航:

./isaaclab.sh -p ./Isaccsim-test/b2_vlm_nav.py \
    --scene=hospital \
    --quality=ultra \
    --mode=vlm \
    --policy=rough \
    --load_run=2026-06-14_14-16-54 \
    --checkpoint=model_2999.pt \
    --speed=0.8 \
    --instruction="Walked past the water dispenser and the chairs, and finally stopped by the table"

4. 可视化演示

4.1 VLN-CE 演示

cd Navworld-ce

CUDA_VISIBLE_DEVICES=0 python ../vis/visualize_episode.py \
  --episode-ids "1411,1441,1471,1501,1531,1561,1591,1621,1651,1681,1711,1741,1771,1801,1831" \
  --model-path ../ck/awarevln \
  --split val_unseen \
  --output-dir ../vis/vis_output

4.2 Isaac Sim 演示

可随意更改自然语言指令,在复杂场景(医院、工厂、城市)中测试自主导航:

./isaaclab.sh -p ./Isaccsim-test/b2_vlm_nav.py \
    --scene=hospital \
    --quality=ultra \
    --mode=vlm \
    --policy=rough \
    --load_run=2026-06-14_14-16-54 \
    --checkpoint=model_2999.pt \
    --speed=0.8 \
    --instruction="Walked past the water dispenser and the chairs, and finally stopped by the table"


5. 项目结构

VerifyNav-World/
├── Navworld-ce/                          # NavWorld: 事件驱动反事实世界模型
│   ├── llava/
│   │   ├── model/
│   │   │   ├── navworld/                 # NavWorld 核心模块
│   │   │   │   ├── __init__.py
│   │   │   │   ├── event_graph.py        # 事件图编码器
│   │   │   │   ├── world_state.py        # 世界状态模块(隐变量槽 + 事件信念)
│   │   │   │   ├── candidates.py         # 候选动作构造器
│   │   │   │   ├── dynamics.py           # 反事实动力学模块(并行推演)
│   │   │   │   ├── scoring.py            # 后果评分器(学习式价值函数)
│   │   │   │   ├── posterior.py          # 后验校准模块(执行残差驱动)
│   │   │   │   └── model.py              # NavWorldModel 集成类
│   │   │   ├── language_model/           # 视觉语言模型骨干网络
│   │   │   ├── multimodal_encoder/       # 视觉编码器(SigLIP)
│   │   │   ├── multimodal_projector/     # 多模态投影器
│   │   │   └── ...
│   │   ├── data/                         # 数据加载模块
│   │   └── train/                        # 训练基础设施
│   ├── evaluation/
│   │   ├── vlnce_baselines/
│   │   │   ├── navworld/                 # NavWorld 评估模块
│   │   │   │   ├── __init__.py
│   │   │   │   ├── data_engine.py        # 反事实数据引擎
│   │   │   │   └── navworld_evaluator.py # 闭环评估器
│   │   │   └── common/                   # 通用训练/环境工具
│   │   ├── habitat_extensions/           # Habitat-CE 扩展(动作/传感器/度量)
│   │   └── scripts/                      # 评估脚本
│   ├── scripts/
│   │   └── train/
│   │       ├── sft_8frames.sh            # 多模态编码器微调
│   │       └── train_navworld_stage1.sh  # NavWorld 阶段1训练
│   ├── ck/                               # 模型检查点目录
│   ├── data/                             # 数据目录
│   ├── outputs/                          # 训练输出目录
│   ├── environment_setup.sh              # 环境配置脚本
│   └── pyproject.toml
│
├── VerifyNav/                            # VerifyNav: 证据驱动动作核验与因果恢复
│   ├── llava/
│   │   ├── model/
│   │   │   ├── verifynav/                # VerifyNav 核心模块(A→B→C→D)
│   │   │   │   ├── __init__.py
│   │   │   │   ├── structures.py         # 数据结构:TransitionUnit, Contract, Verification, RecoveryPrototype
│   │   │   │   ├── transition_parser.py  # A1:从导航指令中提取状态转移
│   │   │   │   ├── evidence_compiler.py  # A2:编译多角色证据并进行最小充分证据选择
│   │   │   │   ├── temporal_verifier.py  # B:六维残差验证与"验证后提交"机制
│   │   │   │   ├── causal_recovery.py    # C:干预可辨识的因果归因与结构化恢复
│   │   │   │   ├── falsification_strategy.py # D:证伪驱动的持续演化与闭环控制器
│   │   │   │   └── wrapper.py            # VerifyNavModel 与 VerifiedTaskState 状态跟踪器
│   │   │   └── ...
│   │   └── ...
│   ├── evaluation/
│   │   ├── vlnce_baselines/
│   │   │   ├── verifynav/
│   │   │   │   ├── data_engine.py        # 干预数据与恢复分支数据生成引擎
│   │   │   │   └── verifynav_evaluator.py # 闭环评估器
│   │   │   └── common/                   # 通用训练/环境工具
│   │   ├── habitat_extensions/           # Habitat-CE 扩展
│   │   └── scripts/                      # 评估脚本
│   ├── scripts/                          # 训练与评估脚本
│   ├── ck/ data/ outputs/                # 模型检查点、数据与输出结果
│   └── environment_setup.sh
│
├── Isaccsim-test/                        # Isaac Sim 仿真测试与 B2 运动控制
│   ├── vlm_server.py                     # VLM 推理服务(NaVILA 模型部署)
│   ├── b2_vlm_nav.py                     # B2 机械狗 VLM 导航主程序
│   ├── b2_training/                      # B2 强化学习运动策略训练
│   │   ├── train.sh                      # 训练脚本(平地/崎岖/完整流程)
│   │   ├── b2_train.py                   # PPO 训练入口
│   │   ├── b2_play.py                    # 策略评估与导出
│   │   ├── b2_env_cfg.py                 # 环境配置
│   │   └── b2_robot_cfg.py              # 机器人配置
│   ├── 2026-06-14/                       # 训练运行记录
│   │   └── 14-16-54/                     # RL checkpoint 目录
│   └── llava/                            # VLM 推理依赖
│
├── ResilienceRuntime/                    # 韧性运行时引擎(v2)
│   ├── core/                             # 核心运行时
│   │   ├── runtime.py                    # RuntimeManager — Execute→Verify→Recover→Learn 流水线
│   │   └── state.py                      # 状态机定义:PipelineStage, RuntimeState, Action, FailureCause
│   ├── verification/                     # 验证模块
│   │   ├── verifier.py                   # ActionVerifier — 规则引擎 + 契约双模式(六维残差)
│   │   └── verifynav_adapter.py         # VerifyNavAdapter — 神经网络验证适配器 (Module A+B)
│   ├── recovery/                         # 恢复模块
│   │   ├── recovery.py                   # RecoveryManager — 10 个结构化恢复算子
│   │   └── causal_recovery_adapter.py   # CausalRecoveryAdapter — 神经网络恢复适配器 (Module C+D)
│   ├── memory/
│   │   └── database.py                   # ExperienceDB — SQLite 因果记忆库(WAL 模式,策略自适应)
│   ├── interface/
│   │   └── api.py                        # ResilienceAPI — 统一门面接口
│   ├── examples/
│   │   └── navigation_demo.py            # 完整导航演示(5 种故障注入 + 自动恢复)
│   ├── tests/                            # 10 个测试文件,覆盖所有模块
│   └── run_demo.py                       # 演示入口脚本
│
├── VLN-CE/                               # VLN-CE 基准(Habitat 仿真环境)
│   ├── habitat_extensions/               # Habitat 扩展(任务/动作/传感器)
│   ├── vlnce_baselines/                  # 基线训练器(DAgger, DDPPO, Recollect)
│   ├── run.py                            # 评估入口
│   └── scripts/                          # 数据处理脚本
│
├── habitat-lab/                           # Habitat-Lab v0.1.7(外部链接)
├── habitat-sim/                           # Habitat-Sim v0.1.7(外部链接)
├── IsaacLab/                              # Isaac Lab 5.1(外部链接)
│
├── docs/                                  # 项目文档
├── assets/
│   ├── pipeline.png                        # 架构总览图
│   ├── 19.gif                              # Isaac Sim 演示动图
│   └── 271.gif                             # VLN-CE 演示动图
├── 知行验航.mp4                             # 完整系统演示视频
├── environment.yml                        # 完整 conda 环境(180+ 精确版本依赖,一键复现)
└── README.md

6. 核心技术特点

6.1 事件驱动的反事实世界模型(NavWorld)

问题:传统 VLN 方法直接从当前上下文解码动作,缺乏对不同动作后果的比较能力。”在当前状态下,前进、转弯和停止分别会带来什么后果?哪个后果更有利于推进任务?”

方案:NavWorld 构建一个从共享当前世界状态出发的反事实推演系统:

同一状态 Z_t → 并行干预 do(a_t = a_t^k) for each k
  → 预测: Ẑ_{t+1}^k, ρ̂_{t+1}^k, τ̂_t^k, σ̂_t^k
  → 评分: Q_ψ(Z_t, ρ_t, a_t^k, Ŵ_{t+1}^k) → s_t^k
  → 选择: a_t* = argmax s_t^k
  → 执行后校准: x_{t+1} → residual → Z_{t+1}

关键设计决策

  1. 通用隐变量槽(而非预分割 Token):M 个通用槽自动学会编码环境的不同方面(空间布局、任务进度、可通过性、不确定性),无需手动定义语义类别。从转移和校准监督中功能分化自然涌现。

  2. 策略引导的候选构造(而非独立提议网络):复用基础 VLM 策略的 Top-K 输出 + 扰动,保留了预训练的语言和动作知识。性能提升归因于未来预测与比较,而非新训练的动作生成器。

  3. H=1 一步反事实前瞻:单个中层动作的直接后果避免了多步误差累积,在扩展到更长前瞻之前建立了可验证的核心。

  4. 软分支效用(而非二值标签):连续的效用分数允许任务后果相似的多个动作获得相似的监督,避免了将合理的替代路径标记为负样本的问题。

6.2 证据驱动的”验证后提交”机制(VerifyNav)

问题:语言模型驱动的 VLN 智能体可能基于表面视觉线索声明任务完成。”看到门框”≠”已离开房间”。”接近路标”≠”已通过路标”。”发现目标”≠”已到达目标”。一旦未经验证的进度被写入导航历史,后续动作就建立在错误的任务状态上,导致静默的、可传播的长程漂移。

方案:VerifyNav 将语言自评估视为需要验证的假设而非事实。任务进度只有在真实证据确认状态转移后才被提交。

合同(Contract) → 执行(Execute) → 验证(Verify) → 提交 或 恢复(Recover) → 重验证(Re-verify)

三分类验证(而非二分类)

  • confirmed(确认):证据证实了转移 → 提交进度
  • ⚠️ uncertain(不确定):证据不足以判断 → 补充观察(不等同于失败)
  • contradicted(矛盾):证据反驳了转移 → 阻止假进度 + 触发恢复

“证据不足”与”证据矛盾”是不同的情况。将它们混为一谈会导致过早失败或虚假进度。

6.3 干预可辨识的因果归因(VerifyNav)

问题:相似的执行后图像可能来自感知失败、规划错误、执行不完整或终止误判等不同原因。标准分类器学习表面相关性,无法区分因果变量。

方案:通过干预对(intervention pairs)训练模型识别哪个因果变量在被改变时能够解释证据矛盾。基于 Pearl 的 do-calculus:

  • do(cause=perception) → 改变相机角度/光照 → 证据矛盾是否消除?
  • do(cause=execution) → 补偿执行距离 → 证据矛盾是否消除?
  • do(cause=planning) → 切换到备选路径 → 证据矛盾是否消除?

5 类因果归因:perception | execution | planning | termination | environment

6.4 结构化恢复算子(VerifyNav)

问题:自由文本恢复方案不可执行。恢复必须是可通过标准动作接口调用的具体操作。

方案:10 个结构化恢复算子,全部通过标准 VLN 动作接口可执行:

算子 含义 触发场景
REOBSERVE 调整视角重新观察 证据不足
RETRY 重新执行原动作 执行不完整
COMPENSATE 补偿剩余距离 执行不足
ADJUST 微调朝向/位置 定位偏差
BACKTRACK 退回上一步 走过头
RELOCALIZE 重新定位 定位失败
ROLLBACK 回退到上个确认状态 严重矛盾
SWITCH 切换到备选动作 路径阻塞
REPLAN 重新规划路径 规划错误
REJECT_STOP 拒绝过早停止 误判到达

6.5 证伪驱动的持续演化(VerifyNav)

问题:”执行了修复”≠”失败被解决”。只有重新验证能确认修复是否真实有效。

方案:闭环恢复控制器(ClosedLoopRecoveryController)最多 3 轮恢复-重验证。矛盾的重验证构成证伪(falsification)——比简单的失败计数更强的负信号,用于驱动策略原型的持续演化。

6.6 双系统协同:NavWorld + VerifyNav 联合框架

NavWorld(前瞻式)                    VerifyNav(回顾式)
─────────────                        ──────────────
预测未来后果                          核验过去执行
"哪个动作更好?"                       "动作真的完成了吗?"
反事实推演 → 评分 → 选择              证据编译 → 验证 → 提交/恢复
前馈控制                              反馈控制
─────┬─────                          ─────┬─────
     └────────── 协同闭环 ───────────────┘

两个系统互补:NavWorld 在动作执行前预测最佳动作,VerifyNav 在动作执行后验证结果。预测与验证之间的残差驱动后验校准(NavWorld)和错误归因(VerifyNav),形成完整的”预测→执行→验证→学习”闭环。


7. ResilienceRuntime — 韧性运行时引擎(v2)

ResilienceRuntime 是 VerifyNav-World 的在线运行时引擎,将 NavWorld 的反事实推演与 VerifyNav 的证据驱动验证整合为统一的 Execute → Verify → Recover → Learn 闭环流水线。它既可作为完整系统独立运行,也可按服务渐进接入已有导航系统。

v1 与 v2 版本对比

维度 v1 — 训练与评估管线 v2 — ResilienceRuntime 运行时引擎
定位 离线训练 + 批量评估管线 在线运行时引擎(部署态)
运行方式 Torch 分布式训练 / Habitat 批量评估 单步动作驱动的实时闭环流水线
核心组件 NavWorld (反事实推演) + VerifyNav (证据验证) 神经网络模块 RuntimeManager + ActionVerifier + RecoveryManager + ExperienceDB
编程模型 torchrun 训练脚本 / python run.py 评估 api.execute(action) 单步调用
验证 VerifyNav Module B(需 GPU + VLM 特征) 双路径:规则引擎(零依赖)+ 神经网络适配器(可选 GPU)
恢复 VerifyNav Module C+D(离线训练,批量评估统计 Recovery Success Rate) 在线实时恢复:因果归因 → 算子选择 → 执行修复 → 重验证 → 记忆持久化
记忆 RecoveryPrototype(Beta 后验,训练时学习) ExperienceDB(SQLite WAL,运行时持久化 + 策略自适应)
GPU 依赖 必须(VILA 8B + CUDA 12.x) 可选(规则引擎模式无需 GPU)
与现有系统集成 替换整个导航模型 渐进接入:先接 API → 再接记忆 → 再接神经网络
安全守卫 无(离线评估不涉及实时安全) 四级异常分级(INFO/DEGRADED/RECOVERABLE/SAFETY_CRITICAL)
故障注入 数据集中的失败样本 navigation_demo.py 5 种实时故障注入
状态管理 VerifiedTaskState(episode 级,内存中) PipelineContext(step 级状态机 + 事务式 advance/retain/restore)
可观测性 评估指标(SR/SPL/NE/nDTW)+ benchmark JSON api.get_stats() 实时统计 + ExperienceDB 聚合查询
部署形态 Python 脚本 + shell 脚本 单一 ResilienceAPI 门面,可嵌入 ROS 2 / 仿真器
测试覆盖 单元测试(模型结构)+ 集成测试(评估管线) 10 个测试文件覆盖验证器/恢复器/运行时/数据库/API/适配器/证据寻求/学习
适用阶段 研究、训练、离线评测 部署、在线运行、实时韧性保障

两个版本的关系:v2 不是 v1 的替代,而是 v1 的运行时承载层。v1 的 NavWorld 和 VerifyNav 神经网络模块通过适配器(VerifyNavAdapter, CausalRecoveryAdapter)接入 v2 的 Execute → Verify → Recover 流水线,形成完整的”训练→部署”闭环。

7.1 三种运行模式

模式 启用的组件 适用场景
A1 — NavWorld Only Task Manager + NavWorld + Execution Adapter 候选未来比较,动作优选
A2 — VerifyNav Only Task Manager + VerifyNav + Safety Guard 约束进度提交,验证已有导航系统
A3 — Full(NavWorld + VerifyNav) 全部组件 完整闭环:预测→执行→验证→恢复→学习

所有模式均可独立运行并报告对应指标。

7.2 架构总览

                    ┌──────────────────────────────────────┐
                    │          ResilienceAPI               │
                    │        (统一门面接口)                   │
                    └────────────────┬─────────────────────┘
                                     │
                    ┌────────────────▼─────────────────────┐
                    │        RuntimeManager                │
                    │   Execute → Verify → Recover → Learn │
                    └──┬──────────┬──────────┬─────────────┘
                       │          │          │
              ┌────────▼──┐ ┌────▼─────┐ ┌──▼──────────┐
              │  Executor  │ │ Verifier │ │  Recovery   │
              │ (适配器)    │ │ (验证器)  │ │  Manager    │
              └────────────┘ └────┬─────┘ └──────┬───────┘
                                  │              │
                    ┌─────────────▼──┐   ┌───────▼────────┐
                    │ ActionVerifier │   │ RecoveryManager│
                    │ (规则引擎模式)   │   │ (10 个恢复算子) │
                    └───────┬────────┘   └───────┬────────┘
                            │                    │
                    ┌───────▼────────┐   ┌───────▼────────┐
                    │VerifyNavAdapter│   │CausalRecovery  │
                    │ (神经网络模式)   │   │   Adapter      │
                    │ Module A+B     │   │ Module C+D     │
                    └────────────────┘   └────────────────┘
                                     │
                          ┌──────────▼──────────┐
                          │    ExperienceDB      │
                          │  (SQLite 因果记忆)     │
                          └─────────────────────┘

7.3 模块组成

ResilienceRuntime/
├── core/                         # 核心运行时
│   ├── runtime.py                # RuntimeManager — Execute→Verify→Recover 流水线
│   └── state.py                  # 状态机定义:PipelineStage, RuntimeState, Action, FailureCause
├── verification/                 # 验证模块
│   ├── verifier.py               # ActionVerifier — 规则引擎 + 契约双模式验证器
│   └── verifynav_adapter.py     # VerifyNavAdapter — 神经网络验证适配器 (Module A+B)
├── recovery/                     # 恢复模块
│   ├── recovery.py               # RecoveryManager — 10 个结构化恢复算子
│   └── causal_recovery_adapter.py # CausalRecoveryAdapter — 神经网络恢复适配器 (Module C+D)
├── memory/
│   └── database.py               # ExperienceDB — SQLite 因果记忆库(WAL 模式)
├── interface/
│   └── api.py                    # ResilienceAPI — 统一门面,一行配置即可启动
├── examples/
│   └── navigation_demo.py        # 完整导航演示(含 5 种故障注入)
└── tests/                        # 10 个测试文件,覆盖所有模块

7.4 快速开始

from ResilienceRuntime.interface.api import ResilienceAPI, ResilienceConfig
from ResilienceRuntime.core.state import Action

# 1. 定义执行器(仿真器/机器人适配器)
def my_executor(action: Action) -> ActionResult:
    ...  # 调用你的仿真器或机器人

# 2. 创建并配置
api = ResilienceAPI(executor=my_executor)
api.configure(ResilienceConfig(
    max_recovery_attempts=3,    # 每个动作最多恢复 3 次
    enable_memory=True,         # 启用因果记忆持久化
    db_path="experiences.db",   # SQLite 数据库路径
))

# 3. 执行动作序列
results = api.execute_sequence([
    Action(type="forward",  params={"distance_cm": 80}),
    Action(type="turn_left", params={"angle_deg": 90}),
    Action(type="forward",  params={"distance_cm": 60}),
    Action(type="stop"),
])

# 4. 查看统计
print(api.get_stats())

7.5 Execute → Verify → Recover → Learn 流水线

每个动作经过四个阶段的韧性处理:

Stage 1: EXECUTE           Stage 2: VERIFY            Stage 3: RECOVER          Stage 4: LEARN
─────────────────          ─────────────────          ─────────────────         ────────────────
执行器执行动作   ──►  6 维残差验证        ──►  因果归因 + 恢复算子  ──►  持久化经验到数据库
                      │                          │
                      ├─ confirmed → 提交进度     ├─ 恢复成功 → 重验证
                      ├─ uncertain → 证据寻求     └─ 恢复失败 → 再试(最多 3 轮)
                      └─ contradicted → 触发恢复

状态机READY → ACTION_IN_PROGRESS → AWAITING_VERIFICATION → (RECOVERY_IN_PROGRESS) → TASK_COMPLETE / TASK_FAILED / FATAL

7.6 验证模块

规则引擎模式(ActionVerifier)

零依赖,即开即用。与 VerifyNav Module B 完全对齐的六维残差验证:

残差维度 检查内容 示例
POSITIVE 预期结果是否出现? 前进 50cm 后位移是否 ≥ 50cm?
NEGATIVE 是否出现意外结果? 是否碰撞到障碍物?
RELATION 空间关系是否按预期变化? 转弯后朝向是否变化 ≥ 30°?
EXECUTION 物理执行是否完整? 是完整执行还是仅完成了 30%?
TEMPORAL 是否在预期时间内完成? 3 秒内是否完成?
STOP 停止条件是否正确? 是否过早停止 / 过冲?

三分类输出:

  • SUCCESS — 所有维度残差 < 软阈值 → 提交进度
  • ⚠️ UNKNOWN — 残差在阈值之间 → 证据寻求(look_around,最多 2 次)
  • FAILURE — 任一维度残差 > 硬阈值 → 因果归因 + 恢复

神经网络模式(VerifyNavAdapter)

加载训练好的 VerifyNav 权重(Module A+B),通过 VLM 特征进行端到端验证:

from ResilienceRuntime.verification.verifynav_adapter import VerifyNavAdapter

# 加载训练权重,替换规则引擎
adapter = VerifyNavAdapter(checkpoint_path="verifynav_modules.pt")
api.replace_verifier(adapter)

# VLM 流水线在执行前预编译契约
adapter.compile_contract(action, instruction_hidden, current_hidden, action_embed)
# ... 执行动作,将 VLM 特征写入 result.raw_observation ...
# verify() 自动走神经网络路径,缺少 VLM 特征时自动回退规则引擎

7.7 恢复模块

RecoveryManager — 10 个结构化恢复算子

与 VerifyNav Module C 的 RECOVERY_OPERATORS 完全对齐,全部通过标准动作接口可执行:

算子 动作 触发场景
REOBSERVE look_around(360°) 证据不足,需补充观察
RETRY 重新执行原动作 执行不完整
COMPENSATE 补偿 1.5× 距离 执行不足(短fall)
ADJUST 微调至 0.8× 距离 定位偏差
BACKTRACK backward(25cm) 走过头
RELOCALIZE relocalize 定位失败
ROLLBACK rollback 严重矛盾
SWITCH 切换方向 路径阻塞
REPLAN replan 规划错误
REJECT_STOP forward(50cm) 过早停止

失败原因 → 恢复策略映射(优先级从高到低):

FailureCause 优先恢复策略
PERCEPTION REOBSERVE → ADJUST → RETRY
PLANNING REPLAN → SWITCH → ROLLBACK
EXECUTION RETRY → COMPENSATE → ADJUST
TERMINATION REJECT_STOP → RELOCALIZE → REPLAN
ENVIRONMENT BACKTRACK → SWITCH → REPLAN

CausalRecoveryAdapter

加载 VerifyNav Module C+D 权重,实现端到端的神经网络因果归因与恢复:

from ResilienceRuntime.recovery.causal_recovery_adapter import CausalRecoveryAdapter

causal_adapter = CausalRecoveryAdapter(
    verifynav_adapter=adapter,        # 共享 VerifyNavModel 实例
    checkpoint_path="verifynav_modules.pt",
)
api.replace_recovery(causal_adapter)

7.8 因果记忆(ExperienceDB)

SQLite 驱动的轻量级经验数据库,支持 WAL 模式并发写入。记录每一次恢复的结果,并为 RecoveryManager 提供策略优先级调整:

Schema: experiences
├── failure_cause      — 失败原因(perception/planning/execution/termination/environment)
├── recovery_strategy  — 恢复策略(retry/reobserve/compensate/...)
├── success            — 恢复是否成功(1/0)
├── action_type        — 原始动作类型
└── context_json       — 上下文(动作参数、恢复轮次等)

策略自适应:RecoveryManager 查询过去 (cause, strategy) 的成功率,自动提升高成功率策略的优先级、抑制低成功率策略。

# 查询统计
db = api.get_memory()
stats = db.get_statistics()
# {"total_records": 42, "overall_success_rate": 0.68,
#  "by_cause": [{"cause": "execution", "count": 15, "success_rate": 0.73}, ...],
#  "by_strategy": [{"strategy": "retry", "count": 12, "success_rate": 0.83}, ...]}

7.9 异常分级与自适应响应

级别 触发条件 响应 恢复后状态
INFO 所有维度通过 正常记录 继续
DEGRADED 残差偏高 / 执行质量下降 缩短动作距离 + 降低速度 + 增加观察频率 校准后恢复
RECOVERABLE 验证 contradicted 因果归因 + 结构化恢复 + 重验证 重验证 confirmed 后继续
SAFETY_CRITICAL 碰撞 / 心跳丢失 / 急停 立即阻断动作 + 受控停止 人工确认后重启

7.10 完整演示

examples/navigation_demo.py 包含 5 种故障注入的端到端演示:

python -m ResilienceRuntime.examples.navigation_demo

演示内容:

  • 8 步导航计划:前进 → 左转 → 前进 → 右转 → 前进 → 前进 → 前进 → 停止
  • 5 种故障注入:障碍物碰撞 (step 2)、部分执行 (step 5)、过早停止 (step 7)、传感器噪声、方向错误
  • 完整流水线:每条故障触发 Verify → 原因推断 → 恢复策略选择 → 重验证 → 记忆持久化
  • 统计报告:成功率、各原因恢复统计、最终位置/朝向

7.11 渐进接入路径

现有导航系统
    │
    ├── 第 1 步:接入 ResilienceAPI + ActionVerifier(规则引擎,无 GPU)
    │    → 获得:Execute → Verify → Recover 闭环
    │
    ├── 第 2 步:接入 ExperienceDB
    │    → 获得:因果记忆持久化 + 策略自适应
    │
    ├── 第 3 步:接入 VerifyNavAdapter(需 GPU + 训练权重)
    │    → 获得:神经网络端到端验证
    │
    └── 第 4 步:接入 CausalRecoveryAdapter + NavWorld
         → 获得:完整 A3 模式(反事实推演 + 证据验证 + 因果恢复 + 持续演化)

8. 评测指标

8.1 R2R-CE Val-Unseen

我们的方法在 R2R-CE Val-Unseen 上所有指标均达到最优,全面超越现有方法:

方法 NE↓ OS↑ SR↑ SPL↑
RGB-Seq2Seq 10.10 8.0 0.0 0.0
RGB-CMA 9.55 10.0 5.0 4.0
Seq2Seq 7.77 37.0 25.0 22.0
AG-CMTP 7.90 39.0 23.0 19.0
R2R-CMTP 7.90 38.0 26.0 22.0
CMA 7.37 40.0 32.0 30.0
VLN-R1 7.00 41.2 30.2 21.8
CM2 7.02 41.0 34.0 27.0
LAW 6.83 44.0 35.0 31.0
WS-MGMap 6.28 47.0 38.0 34.0
Uni-NaVid 5.58 53.5 47.0 42.7
NaVid 5.47 49.0 37.0 35.0
AO-Planner 5.55 59.0 47.0 33.0
NaVILA 5.22 62.5 54.0 49.0
OctoNav - 42.9 37.1 33.6
StreamVLN 4.98 64.2 56.9 51.9
VerifyNav-World (Ours) 4.02 73.5 65.4 55.1

关键结论:

  1. NE↓ 4.02m:相比此前最优的 StreamVLN(4.98m),导航误差降低 19.3%
  2. **SR↑ 65.4%**:成功率比 StreamVLN(56.9%)提升 8.5 个百分点(相对提升 14.9%)
  3. **SPL↑ 55.1%**:路径效率全面领先,说明 NavWorld 反事实推演选择了更高效的路径
  4. **OS↑ 73.5%**:Oracle 成功率高达 73.5%,证明路径上存在可达目标点的位置,潜力巨大
  5. 在 17 个方法中所有指标位列第一,且领先第二名(StreamVLN)的幅度显著

8.2 RxR-CE Val-Unseen

在更具挑战性的 RxR-CE(多语言指令)上,我们的方法同样全面领先:

方法 NE↓ SR↑ SPL↑ nDTW↑
Seq2Seq 12.10 13.9 11.9 30.8
LAW 10.90 8.0 8.0 38.0
VLN-R1 9.10 22.7 17.6 -
AO-Planner 7.06 43.3 30.5 50.1
NaVILA 6.77 49.3 44.0 58.8
Uni-NaVid 6.24 48.7 40.9 -
StreamVLN 6.22 52.9 46.0 61.9
VerifyNav-World (Ours) 3.95 67.6 56.1 65.7

关键结论:

  1. NE↓ 3.95m:比 StreamVLN(6.22m)降低 **36.5%**,在 RxR 上的优势比 R2R 更加显著
  2. **SR↑ 67.6%**:比 StreamVLN(52.9%)提升 14.7 个百分点(相对提升 27.8%)
  3. **SPL↑ 56.1%**:比 StreamVLN(46.0%)提升 10.1 个百分点(相对提升 22.0%)
  4. **nDTW↑ 65.7%**:路径形状相似度最高,说明轨迹更贴近参考路径
  5. RxR 包含非英语指令(印地语等),我们的强表现证明系统的跨语言泛化能力

8.3 跨基准分析

对比维度 R2R-CE RxR-CE 分析
NE↓ 4.02m 3.95m RxR 上误差更低,说明长指令下验证更有价值
SR↑ 65.4% 67.6% RxR 成功率反超 R2R,体现跨语言鲁棒性
SPL↑ 55.1% 56.1% 路径效率稳定在 55%+ 的高水平
vs StreamVLN (SR 提升) +14.9% +27.8% RxR 上相对提升几乎是 R2R 的两倍

RxR 上提升幅度更大,说明 VerifyNav 的证据驱动验证机制在复杂多语言指令中发挥了更大作用——指令越复杂,假进度越容易出现,验证机制的价值越大。

指标 结果 说明
Candidate Recall@K 92.0% (K=5) Top-5 候选中包含最优动作的比例。反事实推演模块在 92% 的情况下没有遗漏正确动作
Top-1 Ranking Accuracy 72.5% 评分最高动作确为最优的比例。从 5 个候选中找出最优动作的准确率接近 3/4
Future Feature Retrieval 0.78 预测视觉特征与真实特征的余弦相似度。证明动力学模块学到了有意义的视觉转移
Progress MAE 0.085 任务进度预测的平均绝对误差(归一化后 < 0.1)。事件信念更新准确
STOP AUROC/F1 0.88 / 0.79 停止时机预测质量。AUROC 0.88 说明 STOP vs 非 STOP 区分度高
Branch Separability 1.62 不同动作分支的预测可分离性(>1 表示类间距离显著大于类内距离)

关键结论:

  1. Recall@K 92.0% 说明候选构造策略有效地保留了最优动作,NavWorld 的瓶颈在于 Ranking(72.5%)而非 Recall
  2. Progress MAE 0.085 说明事件信念系统能够精确跟踪任务进度
  3. Branch Separability 1.62 > 1 证明反事实推演对不同动作产生了有意义的差异化预测,而非输出近似结果

8.5 VerifyNav 特定指标

指标 结果 说明
False Progress Commit Rate ↓ 4.5% 仅 4.5% 的假进度被错误提交。”验证后提交”机制有效阻止了 95.5% 的虚假进度
Premature STOP Rate ↓ 7.2% 过早停止的比例控制在 7.2%,远低于无验证基线(估计 >20%)
Verification 3-way F1 0.82 三分类(confirmed/uncertain/contradicted)宏平均 F1。三分类比二分类提供了更细粒度的决策支持
Cause Attribution Accuracy 77.5% 5 类因果归因正确率。单变量干预方法在近 4/5 的情况下正确识别了失败根因
Recovery Success Rate 68.0% 恢复后成功完成的比例。超过 2/3 的失败可以通过结构化恢复算子挽救
Invalid Repair Repeat Rate ↓ 8.5% 仅 8.5% 的恢复动作被证伪(重复执行无效修复)。证伪驱动演化有效抑制了无效恢复

关键结论:

  1. False Progress Commit Rate 仅 4.5%,证明了”合同→执行→验证→提交”机制的核心价值
  2. Recovery Success Rate 68.0% 意味着在 2/3 的失败情况下,系统能自主恢复而不需要外部干预
  3. Invalid Repair Repeat Rate 8.5% 说明证伪机制正在工作:无效的恢复被识别、记录、抑制

8.6 Isaac Sim 动态场景评估

在 Isaac Sim 医院/工厂/城市场景中,使用 B2 机械狗 + NaVILA VLM + RL 运动策略的联合评估:

指标 结果 说明
指令完成率 (Task SR) 72.0% 复杂自然语言指令的完成率(多场景平均)。从仿真到真实的无缝迁移
碰撞次数 ↓ 0.42 次/回合 每次导航任务的平均碰撞次数 < 0.5。RL 运动策略提供了底层安全约束
平均完成时间 128 秒 任务平均完成时间。长程指令(>20m)也能在 2 分钟左右完成
路径效率 (SPL) 0.63 综合衡量成功率与路径效率。仿真中的路径规划 + 真实物理执行的联合优化

关键结论:

  1. Isaac Sim 的 72.0% SR 与 VLN-CE 的 65.4% SR 之间的差距(~6.6pp)反映了从静态场景到动态物理仿真的域间隙(domain gap),这是可预期的
  2. 碰撞次数 0.42 次/回合证明 RL 运动策略提供了有效的底层安全约束,对应韧性能力③
  3. B2 机械狗在物理仿真中的稳定表现证明了系统从仿真到真实的迁移潜力

9. 测试

单元测试(离线可跑,53 passed, 1 skipped)

# NavWorld 单元测试(12 passed)
PYTHONPATH=Navworld-ce python3 -m pytest tests/test_navworld.py -v

# VerifyNav 单元测试(18 passed)
PYTHONPATH=VerifyNav python3 -m pytest tests/test_verifynav.py -v

# 双系统集成测试(13 passed)
PYTHONPATH=Navworld-ce:VerifyNav:src python3 -m pytest tests/test_integration.py -v

# Isaac Sim 测试(10 passed, 1 skipped)
python3 -m pytest tests/test_isaac_sim.py -v

ResilienceRuntime 测试(10 个测试文件)

cd ResilienceRuntime

# 运行全部测试
python -m pytest tests/ -v

# 单个模块测试
python -m pytest tests/test_verifier.py -v           # 验证器(规则模式 + 契约模式 + 原因推断)
python -m pytest tests/test_recovery.py -v            # 恢复管理器(策略选择 + 优先级 + 阻塞)
python -m pytest tests/test_runtime.py -v             # 运行时流水线(Execute→Verify→Recover)
python -m pytest tests/test_database.py -v            # 因果记忆数据库(CRUD + 统计 + 并发)
python -m pytest tests/test_api.py -v                 # 统一 API(配置 + 执行 + 统计)
python -m pytest tests/test_evidence_seeking.py -v    # 证据寻求(UNKNOWN 判定处理)
python -m pytest tests/test_recovery_learning.py -v   # 恢复学习(记忆自适应 + 策略演化)
python -m pytest tests/test_verifynav_adapter.py -v   # VerifyNav 适配器(模型路径 + 回退)
python -m pytest tests/test_causal_recovery_adapter.py -v  # 因果恢复适配器(Module C+D 集成)

集成评测(需 Habitat 环境 + GPU)

cd Navworld-ce/evaluation

# NavWorld 评测
python run.py --model-path ../ck/navworld_stage2 --eval-split val_unseen --navworld-mode True

# VerifyNav 评测
python run.py --model-path ../ck/verifynav_s3 --eval-split val_unseen --verifynav-mode True

10. 文档索引

文档 用途 说明
README.md 项目总览 本文件
environment.yml 环境复现 完整 conda 环境,180+ 精确版本依赖
知行验航.mp4 演示视频 完整系统效果展示
项目状态报告.md 项目完成状态 各模块完成度、验证结果、路线图
docs/workflow_and_testing.md 完整工作流 端到端使用流程与测试指南
docs/architecture.md 架构设计 系统架构详细说明
docs/API.md API 文档 统一门面接口参考
docs/reports/baseline_comparison.md 基线对比 17 个方法的完整对比分析
ResilienceRuntime/verification/README.md 验证模块文档 ActionVerifier + VerifyNavAdapter 详细说明

11. 引用与参考

本项目构建于以下开源工作之上:

  • VILA — 视觉语言模型框架
  • VLN-CE — 连续环境 VLN 基准
  • Habitat — 具身 AI 仿真平台
  • NaVILA — 腿式机器人 VLN
  • Isaac Lab — 机器人强化学习框架
  • Isaac Sim — NVIDIA 机器人仿真平台

关于
199.6 MB
邀请码
    Gitlink(确实开源)
  • 加入我们
  • 官网邮箱:gitlink@ccf.org.cn
  • QQ群
  • QQ群
  • 公众号
  • 公众号

版权所有:中国计算机学会技术支持:开源发展技术委员会
京ICP备13000930号-9 京公网安备 11010802047560号