Upload JanusVLN code with parquet training support

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+train_r2r_rxr_parquet.json filter=lfs diff=lfs merge=lfs -text

LoRA/README.md

@@ -0,0 +1,209 @@
+# JanusVLN LoRA 训练说明
+
+本目录提供一套可直接运行的 LoRA 微调方案，目标是把 JanusVLN 的 VLM 从全量微调改成参数高效微调，显著降低显存占用。
+
+本方案是**目录隔离实现**：
+- 不改动原有全量微调入口（`src/qwen_vl/train/train_qwen.py` 与 `src/qwen_vl/train/argument.py`）。
+- LoRA 所需逻辑全部放在 `LoRA/` 目录。
+
+## 文件说明
+
+- `LoRA/train_lora.sh`
+  - 一键训练脚本。
+  - 默认策略：冻结 VGGT，冻结 VLM 主干参数，只训练 LoRA Adapter，并继续训练 JanusVLN 特有的 `merger`（可关）。
+  - 会优先读取 `LoRA/lora_config.env`（若存在），也支持命令行临时环境变量覆盖。
+
+- `LoRA/train_qwen_lora.py`
+  - LoRA 专用训练入口。
+  - 基于原训练流程复用数据管道与模型加载，但仅在此文件里执行 LoRA 注入（PEFT）。
+  - 训练完成后自动导出 `output_dir/lora_adapter/`。
+
+- `LoRA/argument_lora.py`
+  - LoRA 专用参数定义。
+  - 在原参数基础上增加 LoRA 参数（`lora_r`、`lora_alpha`、`lora_dropout`、`lora_target_modules` 等）。
+
+- `LoRA/lora_config.env.example`
+  - LoRA 配置模板（推荐复制为 `LoRA/lora_config.env` 后修改）。
+  - 集中管理精度、batch size、学习率、LoRA 超参。
+
+- `LoRA/zero2_lora.json`
+  - DeepSpeed ZeRO-2 配置。
+  - 相比 ZeRO-3，ZeRO-2 在 LoRA 场景更简单稳定，通信与保存开销更低，适合先快速跑通。
+
+- `output_dir/lora_adapter/`（训练后自动生成）
+  - 仅保存 LoRA adapter 权重与 tokenizer/processor。
+  - 用于轻量部署或与基座模型合并。
+
+## 和全量微调的核心差别
+
+1. 可训练参数规模
+- 全量微调：更新 LLM 全部参数，参数量最大。
+- LoRA 微调：仅更新低秩矩阵（以及你显式开启的模块），参数量通常降到全量的 <1%-5%。
+
+2. 显存占用
+- 全量微调：优化器状态 + 梯度 + 参数副本占用高。
+- LoRA 微调：只为少量可训练参数维护优化器状态，显存通常显著下降。
+
+3. 训练速度
+- LoRA 常见情况是单步更快或相当；如果总步数不变，wall-time 往往更友好。
+
+4. 模型效果
+- 全量微调上限通常更高，尤其当数据域偏移很大时。
+- LoRA 在中小数据场景经常具备更好的性价比；若 rank 配置过小，可能上限受限。
+
+## 如何启动
+
+在项目根目录执行：
+
+```bash
+chmod +x LoRA/train_lora.sh
+./LoRA/train_lora.sh
+```
+
+如果需要固定配置，先复制模板：
+
+```bash
+cp LoRA/lora_config.env.example LoRA/lora_config.env
+# 然后按你的 GPU 与任务修改 LoRA/lora_config.env
+./LoRA/train_lora.sh
+```
+
+也可按需覆盖参数：
+
+```bash
+MODEL_PATH=Qwen/Qwen2.5-VL-7B-Instruct \
+OUTPUT_DIR=./JanusVLN_LoRA_Base_r32 \
+LORA_R=32 \
+LORA_ALPHA=64 \
+LORA_DROPOUT=0.05 \
+PER_DEVICE_BATCH_SIZE=1 \
+GRAD_ACC_STEPS=8 \
+LEARNING_RATE=1e-4 \
+./LoRA/train_lora.sh
+```
+
+训练日志：`$OUTPUT_DIR/train_lora.log`。
+
+## LoRA/训练配置可选项与影响
+
+以下均可在执行前通过环境变量覆盖。
+
+### 1) LoRA 结构相关
+
+- `LORA_R`（默认 `16`）
+  - 作用：低秩分解的秩，决定 LoRA 容量。
+  - 显存影响：`r` 越大，显存与优化器开销线性上升。
+  - 性能影响：`r` 越大通常上限更高；过小可能欠拟合。
+  - 建议：`8/16/32` 先做网格试验。
+
+- `LORA_ALPHA`（默认 `32`）
+  - 作用：LoRA 缩放系数（有效更新幅度约与 `alpha/r` 相关）。
+  - 显存影响：几乎无直接影响。
+  - 性能影响：过小学习慢，过大可能不稳定。
+  - 建议：常用配比 `alpha=2r` 或 `alpha=r`。
+
+- `LORA_DROPOUT`（默认 `0.05`）
+  - 作用：LoRA 分支 dropout。
+  - 显存影响：几乎无。
+  - 性能影响：
+    - 小数据集：适当增大（0.05-0.1）可抗过拟合。
+    - 大数据集：可减小到 0-0.05 提升拟合。
+
+- `LORA_TARGET_MODULES`
+  - 默认：`q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj`
+  - 作用：指定在哪些线性层挂 LoRA。
+  - 显存影响：目标层越多，显存越高。
+  - 性能影响：
+    - 仅注意力（q/k/v/o）：更省显存、效果稳定。
+    - 加 MLP（gate/up/down）：适配能力更强，但显存与过拟合风险上升。
+
+### 2) 精度相关
+
+- `--bf16`（脚本默认开启）
+  - 作用：bfloat16 训练。
+  - 显存影响：低于 fp32；通常与 fp16 相近。
+  - 稳定性：通常比 fp16 更稳（需硬件支持 BF16）。
+
+- 若显卡不支持 BF16
+  - 可改成 fp16（需要修改脚本中的 `--bf16` 参数策略）。
+  - 经验上：fp16 可能更容易出现数值不稳定，需要配合 loss scale。
+
+### 3) Batch 与梯度累积
+
+- `PER_DEVICE_BATCH_SIZE`（默认 `1`）
+  - 显存影响：最敏感，线性增长。
+  - 性能影响：太小会增大梯度噪声；太大可能 OOM。
+
+- `GRAD_ACC_STEPS`（默认 `8`）
+  - 作用：在不增加显存的前提下增大全局 batch。
+  - 显存影响：基本不增加激活显存。
+  - 性能影响：更稳定，但 step 时间变长。
+
+- 全局 batch 计算
+  - `global_batch = PER_DEVICE_BATCH_SIZE * GRAD_ACC_STEPS * GPU_NUM`
+
+### 4) 学习率相关
+
+- `LEARNING_RATE`（默认 `2e-4`，LoRA 常用较大全局 LR）
+  - 性能影响：
+    - 过大：震荡或遗忘。
+    - 过小：收敛慢、欠拟合。
+  - 建议：LoRA 先试 `1e-4 ~ 3e-4`。
+
+- `MM_PROJECTOR_LR`（默认 `1e-5`）
+  - 作用：给 Janus 的 projector/merger 分组学习率。
+  - 影响：适度提高可加快跨模态对齐，但过大会破坏已有能力。
+
+- `VISION_TOWER_LR`（默认 `1e-6`）
+  - 当前脚本 `--tune_mm_vision False`，实际不更新视觉主干，通常影响有限。
+
+### 5) 是否训练 Janus 特有模块
+
+- 脚本默认 `--lora_train_merger True`
+  - 作用：除 LoRA 外继续训练 Janus 的 `merger`。
+  - 显存影响：小幅增加。
+  - 性能影响：通常对 VLN 任务更友好（保留任务特化能力）。
+
+- `--lora_train_lm_head False`（默认）
+  - 作用：默认不训练 `lm_head`，更稳更省。
+  - 何时开启：数据规模较大且词表分布变化明显时可尝试开启。
+
+## 常见显存-性能策略
+
+1. 24GB 单卡优先跑通
+- `LORA_R=8`
+- 仅注意力层：`LORA_TARGET_MODULES=q_proj,k_proj,v_proj,o_proj`
+- `PER_DEVICE_BATCH_SIZE=1`
+- `GRAD_ACC_STEPS=16`
+
+2. 多卡追求更高上限
+- `LORA_R=16 or 32`
+- 注意力+MLP 全开
+- 在稳定前提下提高 `global_batch`
+
+3. 数据少、过拟合明显
+- 提高 `LORA_DROPOUT` 到 `0.1`
+- 减小 `LORA_R`
+- 缩短 epoch 或增加早停
+
+## 代码改动摘要（为了让脚本可执行）
+
+为支持本目录脚本，LoRA 功能全部在 `LoRA/` 目录独立实现：
+
+- `LoRA/argument_lora.py`
+  - 定义 LoRA 专用训练参数。
+
+- `LoRA/train_qwen_lora.py`
+  - 注入 LoRA 并执行训练。
+  - 导出 `lora_adapter`。
+
+- `LoRA/train_lora.sh`
+  - 统一读取配置并启动分布式训练。
+
+原全量微调入口保持不变，可继续使用原脚本直接跑全量训练。
+
+## 与全量微调如何选
+
+- 显存受限、需要快速迭代：优先 LoRA。
+- 训练数据非常大且追求绝对上限：可考虑全量微调。
+- 实务建议：先 LoRA 验证数据与任务配置，再决定是否做全量微调。

LoRA/argument_lora.py

@@ -0,0 +1,60 @@
+import transformers
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: Optional[str] = field(default="Qwen/Qwen2.5-VL-3B-Instruct")
+    tune_mm_llm: bool = field(default=False)
+    tune_mm_mlp: bool = field(default=False)
+    tune_mm_vision: bool = field(default=False)
+
+    # LoRA-specific arguments.
+    use_lora: bool = field(default=True)
+    lora_r: int = field(default=16)
+    lora_alpha: int = field(default=32)
+    lora_dropout: float = field(default=0.05)
+    lora_target_modules: str = field(
+        default="q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj"
+    )
+    lora_bias: str = field(default="none")
+    lora_task_type: str = field(default="CAUSAL_LM")
+    lora_modules_to_save: str = field(default="")
+    lora_train_merger: bool = field(default=True)
+    lora_train_lm_head: bool = field(default=False)
+
+    vggt_model_path: str = field(default="facebook/VGGT-1B/")
+    lam: float = field(default=0.2)
+    distill_loss_weight: float = field(default=1.0)
+    reference_frame: str = field(default="last")
+
+
+@dataclass
+class DataArguments:
+    dataset_use: str = field(default="")
+    video_max_frames: Optional[int] = field(default=8)
+    video_min_frames: Optional[int] = field(default=4)
+    data_flatten: bool = field(default=False)
+    base_interval: int = field(default=2)
+    max_pixels: int = field(default=28 * 28 * 576)
+    min_pixels: int = field(default=28 * 28 * 16)
+    video_max_frame_pixels: int = field(default=32 * 28 * 28)
+    video_min_frame_pixels: int = field(default=4 * 28 * 28)
+    max_samples: int = field(default=-1)
+    shuffle: bool = field(default=True)
+
+
+@dataclass
+class TrainingArguments(transformers.TrainingArguments):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    model_max_length: int = field(
+        default=512,
+        metadata={
+            "help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+        },
+    )
+    mm_projector_lr: Optional[float] = None
+    vision_tower_lr: Optional[float] = None
+    group_by_modality_length: bool = field(default=False)

LoRA/lora_config.env.example

@@ -0,0 +1,29 @@
+# Copy this file to LoRA/lora_config.env and edit as needed.
+
+# Distributed settings
+MASTER_ADDR=127.0.0.1
+# MASTER_PORT is optional; train_lora.sh will auto-pick a random free-ish port if not set.
+# MASTER_PORT=24567
+# NPROC_PER_NODE is optional; by default, number of visible GPUs from nvidia-smi is used.
+# NPROC_PER_NODE=4
+
+# Model/data/output
+MODEL_PATH=Qwen/Qwen2.5-VL-7B-Instruct
+VGGT_MODEL_PATH=facebook/VGGT-1B
+OUTPUT_DIR=./JanusVLN_LoRA_Base
+CACHE_DIR=./cache
+DATASETS=train_r2r_rxr
+
+# LoRA core settings
+LORA_R=16
+LORA_ALPHA=32
+LORA_DROPOUT=0.05
+LORA_TARGET_MODULES=q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj
+
+# Training settings
+# If GPU memory is tight, keep PER_DEVICE_BATCH_SIZE=1 and increase GRAD_ACC_STEPS.
+PER_DEVICE_BATCH_SIZE=1
+GRAD_ACC_STEPS=8
+LEARNING_RATE=2e-4
+MM_PROJECTOR_LR=1e-5
+VISION_TOWER_LR=1e-6

LoRA/train_lora.sh

@@ -0,0 +1,110 @@
+#!/bin/bash
+set -euo pipefail
+
+# Run from project root regardless of where the script is invoked.
+cd "$(dirname "$0")/.."
+
+# Optional user config. Copy LoRA/lora_config.env.example to LoRA/lora_config.env and edit values.
+if [[ -f "LoRA/lora_config.env" ]]; then
+  # shellcheck disable=SC1091
+  source "LoRA/lora_config.env"
+fi
+
+# Launcher selection: prefer explicit TORCHRUN_BIN, then PATH torchrun,
+# then JanusVLN conda torchrun, finally python -m torch.distributed.run.
+if [[ -n "${TORCHRUN_BIN:-}" ]]; then
+  LAUNCHER=("$TORCHRUN_BIN")
+elif command -v torchrun >/dev/null 2>&1; then
+  LAUNCHER=("$(command -v torchrun)")
+elif [[ -x "/home/catlab/anaconda3/envs/JanusVLN/bin/torchrun" ]]; then
+  LAUNCHER=("/home/catlab/anaconda3/envs/JanusVLN/bin/torchrun")
+else
+  PYTHON_BIN="${PYTHON_BIN:-python3}"
+  LAUNCHER=("$PYTHON_BIN" -m torch.distributed.run)
+fi
+
+MASTER_ADDR="${MASTER_ADDR:-127.0.0.1}"
+MASTER_PORT="${MASTER_PORT:-$(shuf -i 20000-29999 -n 1)}"
+NPROC_PER_NODE="${NPROC_PER_NODE:-$(nvidia-smi --list-gpus | wc -l)}"
+
+MODEL_PATH="${MODEL_PATH:-Qwen/Qwen2.5-VL-7B-Instruct}"
+VGGT_MODEL_PATH="${VGGT_MODEL_PATH:-facebook/VGGT-1B}"
+OUTPUT_DIR="${OUTPUT_DIR:-./JanusVLN_LoRA_Base}"
+CACHE_DIR="${CACHE_DIR:-./cache}"
+DATASETS="${DATASETS:-train_r2r_rxr}"
+
+# LoRA defaults (override by exporting env vars before running).
+LORA_R="${LORA_R:-16}"
+LORA_ALPHA="${LORA_ALPHA:-32}"
+LORA_DROPOUT="${LORA_DROPOUT:-0.05}"
+LORA_TARGET_MODULES="${LORA_TARGET_MODULES:-q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj}"
+
+# Training defaults (safe for 24G-class cards with multi-GPU + accumulation).
+PER_DEVICE_BATCH_SIZE="${PER_DEVICE_BATCH_SIZE:-1}"
+GRAD_ACC_STEPS="${GRAD_ACC_STEPS:-8}"
+LEARNING_RATE="${LEARNING_RATE:-2e-4}"
+MM_PROJECTOR_LR="${MM_PROJECTOR_LR:-1e-5}"
+VISION_TOWER_LR="${VISION_TOWER_LR:-1e-6}"
+
+mkdir -p "$OUTPUT_DIR"
+LOG_FILE="$OUTPUT_DIR/train_lora.log"
+
+export NCCL_NVLS_ENABLE=0
+
+# Checkpoint policy: save every 1000 steps and keep all checkpoints.
+# Original setting deleted old checkpoints with: --save_total_limit 1
+
+"${LAUNCHER[@]}" --nproc_per_node="$NPROC_PER_NODE" \
+  --master_addr="$MASTER_ADDR" \
+  --master_port="$MASTER_PORT" \
+  LoRA/train_qwen_lora.py \
+  --model_name_or_path "$MODEL_PATH" \
+  --vggt_model_path "$VGGT_MODEL_PATH" \
+  --tune_mm_llm False \
+  --tune_mm_vision False \
+  --tune_mm_mlp True \
+  --use_lora True \
+  --lora_r "$LORA_R" \
+  --lora_alpha "$LORA_ALPHA" \
+  --lora_dropout "$LORA_DROPOUT" \
+  --lora_target_modules "$LORA_TARGET_MODULES" \
+  --lora_bias none \
+  --lora_task_type CAUSAL_LM \
+  --lora_train_merger True \
+  --lora_train_lm_head False \
+  --dataset_use "$DATASETS" \
+  --output_dir "$OUTPUT_DIR" \
+  --cache_dir "$CACHE_DIR" \
+  --bf16 \
+  --per_device_train_batch_size "$PER_DEVICE_BATCH_SIZE" \
+  --gradient_accumulation_steps "$GRAD_ACC_STEPS" \
+  --learning_rate "$LEARNING_RATE" \
+  --mm_projector_lr "$MM_PROJECTOR_LR" \
+  --vision_tower_lr "$VISION_TOWER_LR" \
+  --optim adamw_torch \
+  --model_max_length 163840 \
+  --data_flatten False \
+  --max_pixels $((576 * 28 * 28)) \
+  --min_pixels $((16 * 28 * 28)) \
+  --base_interval 2 \
+  --video_max_frames 8 \
+  --video_min_frames 4 \
+  --video_max_frame_pixels $((1664 * 28 * 28)) \
+  --video_min_frame_pixels $((256 * 28 * 28)) \
+  --num_train_epochs 1 \
+  --warmup_ratio 0.03 \
+  --lr_scheduler_type cosine \
+  --weight_decay 0.01 \
+  --logging_steps 10 \
+  --disable_tqdm False \
+  --save_steps 1000 \
+  --deepspeed "LoRA/zero2_lora.json" \
+  --gradient_checkpointing \
+  --dataloader_num_workers 8 \
+  --group_by_modality_length true \
+  --seed 42 \
+  --report_to none \
+  --reference_frame first \
+  2>&1 | tee "$LOG_FILE"
+
+echo "LoRA training finished. Log: $LOG_FILE"

LoRA/train_lora_parquet.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -euo pipefail
+
+# LoRA entrypoint for parquet-backed trajectory annotations.
+# Original PNG-backed script: LoRA/train_lora.sh with DATASETS="train_r2r_rxr".
+
+cd "$(dirname "$0")/.."
+
+export DATASETS="${DATASETS:-train_r2r_rxr_parquet}"
+export OUTPUT_DIR="${OUTPUT_DIR:-./JanusVLN_LoRA_Base_Parquet}"
+
+exec bash LoRA/train_lora.sh
+

LoRA/train_qwen_lora.py

@@ -0,0 +1,262 @@
+# LoRA-only training entrypoint for JanusVLN.
+# This file is isolated under LoRA/ and does not modify the original full-finetuning scripts.
+
+import os
+import logging
+import pathlib
+import shutil
+import sys
+from pathlib import Path
+from typing import List
+
+import torch
+import transformers
+from peft import LoraConfig, TaskType, get_peft_model
+
+project_root = Path(__file__).resolve().parent.parent
+sys.path.append(str(project_root))
+sys.path.append(str(project_root / "src"))
+
+import qwen_vl.train.trainer  # noqa: F401  # keep monkey patches from trainer side effects
+import qwen_vl.train.sampler  # noqa: F401
+from qwen_vl.train.trainer import replace_qwen2_vl_attention_class
+
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+)
+from qwen_vl.data.data_qwen import make_supervised_data_module
+from argument_lora import (
+    ModelArguments,
+    DataArguments,
+    TrainingArguments,
+)
+from transformers import AutoProcessor, Qwen2VLImageProcessor, Trainer, AutoConfig, set_seed
+
+local_rank = None
+
+
+def rank0_print(*args):
+    if local_rank == 0:
+        print(*args)
+
+
+def is_rank0() -> bool:
+    if not torch.distributed.is_available() or not torch.distributed.is_initialized():
+        return True
+    return torch.distributed.get_rank() == 0
+
+
+def _parse_csv_list(csv_value: str) -> List[str]:
+    if not csv_value:
+        return []
+    return [x.strip() for x in csv_value.split(",") if x.strip()]
+
+
+def _get_lora_task_type(task_type_name: str) -> TaskType:
+    normalized = (task_type_name or "CAUSAL_LM").upper()
+    if not hasattr(TaskType, normalized):
+        raise ValueError(
+            f"Unsupported lora_task_type: {task_type_name}. "
+            f"Supported values: {[x.name for x in TaskType]}"
+        )
+    return getattr(TaskType, normalized)
+
+
+def _unwrap_module(model):
+    while hasattr(model, "module"):
+        model = model.module
+    return model
+
+
+def safe_save_model_for_hf_trainer(trainer: transformers.Trainer, output_dir: str):
+    if trainer.deepspeed:
+        torch.cuda.synchronize()
+        trainer.save_model(output_dir)
+        return
+
+    state_dict = trainer.model.state_dict()
+    if trainer.args.should_save:
+        cpu_state_dict = {key: value.cpu() for key, value in state_dict.items()}
+        del state_dict
+        trainer._save(output_dir, state_dict=cpu_state_dict)
+
+
+def set_lora_training_policy(model_args, model):
+    if model_args.tune_mm_vision and hasattr(model, "visual"):
+        for _, p in model.visual.named_parameters():
+            p.requires_grad = True
+    elif hasattr(model, "visual"):
+        for _, p in model.visual.named_parameters():
+            p.requires_grad = False
+
+    if model_args.tune_mm_mlp and hasattr(model, "visual") and hasattr(model.visual, "merger"):
+        for _, p in model.visual.merger.named_parameters():
+            p.requires_grad = True
+    elif hasattr(model, "visual") and hasattr(model.visual, "merger"):
+        for _, p in model.visual.merger.named_parameters():
+            p.requires_grad = False
+
+    # Freeze the base LLM and only train LoRA adapters.
+    if hasattr(model, "model"):
+        for _, p in model.model.named_parameters():
+            p.requires_grad = False
+
+    if hasattr(model, "lm_head"):
+        model.lm_head.requires_grad = model_args.lora_train_lm_head
+
+    # Keep VGGT frozen.
+    if hasattr(model, "vggt"):
+        for _, p in model.vggt.named_parameters():
+            p.requires_grad = False
+
+    # Janus-specific 3D merger can be optionally trainable under LoRA.
+    if hasattr(model, "merger"):
+        for _, p in model.merger.named_parameters():
+            p.requires_grad = model_args.lora_train_merger
+
+
+def apply_lora_to_llm(model_args, model):
+    target_modules = _parse_csv_list(model_args.lora_target_modules)
+    if not target_modules:
+        raise ValueError("lora_target_modules is empty. Please provide at least one target module name.")
+
+    modules_to_save = _parse_csv_list(model_args.lora_modules_to_save)
+
+    lora_config = LoraConfig(
+        task_type=_get_lora_task_type(model_args.lora_task_type),
+        r=model_args.lora_r,
+        lora_alpha=model_args.lora_alpha,
+        lora_dropout=model_args.lora_dropout,
+        target_modules=target_modules,
+        bias=model_args.lora_bias,
+        modules_to_save=(modules_to_save if modules_to_save else None),
+    )
+
+    # Wrap the top-level Janus model so Trainer can still pass labels to forward().
+    # Wrapping only model.model breaks forward signature and causes labels mismatch.
+    return get_peft_model(model, lora_config)
+
+
+def save_lora_adapter(model, tokenizer, image_processor, output_dir: str):
+    if not is_rank0():
+        return
+
+    lora_output_dir = os.path.join(output_dir, "lora_adapter")
+    os.makedirs(lora_output_dir, exist_ok=True)
+
+    core_model = _unwrap_module(model)
+    if hasattr(core_model, "save_pretrained"):
+        core_model.save_pretrained(lora_output_dir)
+    elif hasattr(core_model, "model") and hasattr(core_model.model, "save_pretrained"):
+        core_model.model.save_pretrained(lora_output_dir)
+    else:
+        raise RuntimeError("Cannot find LoRA adapter model to save.")
+    tokenizer.save_pretrained(lora_output_dir)
+    image_processor.save_pretrained(lora_output_dir)
+    rank0_print(f"LoRA adapter has been saved to {lora_output_dir}")
+
+
+def train(attn_implementation="flash_attention_2"):
+    global local_rank
+
+    parser = transformers.HfArgumentParser(
+        (ModelArguments, DataArguments, TrainingArguments)
+    )
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    if not model_args.use_lora:
+        raise ValueError("This entrypoint is LoRA-only. Please set --use_lora True.")
+
+    set_seed(training_args.seed)
+    local_rank = training_args.local_rank
+    os.makedirs(training_args.output_dir, exist_ok=True)
+
+    # For local/offline checkpoints that already contain Janus weights,
+    # allow bypassing external VGGT.from_pretrained() fetch.
+    vggt_model_path = model_args.vggt_model_path
+    if vggt_model_path in ("", "__SKIP__", "none", "None", None):
+        vggt_model_path = None
+
+    config = AutoConfig.from_pretrained(model_args.model_name_or_path)
+    model_type = getattr(config, "model_type", "")
+    is_qwen2_5 = "qwen2_5" in model_type or "qwen2.5" in model_type
+
+    if not is_qwen2_5:
+        raise ValueError(
+            f"LoRA entrypoint currently supports qwen2.5-vl only, but got model_type={model_type}. "
+            "Please use a Qwen2.5-VL / JanusVLN checkpoint."
+        )
+
+    from qwen_vl.model.modeling_qwen2_5_vl import Qwen2_5_VLForConditionalGenerationForJanusVLN
+
+    setattr(config, "lam", model_args.lam)
+
+    model = Qwen2_5_VLForConditionalGenerationForJanusVLN.from_pretrained(
+        pretrained_model_name_or_path=model_args.model_name_or_path,
+        config=config,
+        cache_dir=training_args.cache_dir,
+        attn_implementation=attn_implementation,
+        torch_dtype=(torch.bfloat16 if training_args.bf16 else None),
+        vggt_model_path=vggt_model_path,
+    )
+
+    data_args.image_processor = AutoProcessor.from_pretrained(
+        model_args.model_name_or_path,
+    ).image_processor
+    data_args.model_type = "qwen2.5vl"
+
+    if data_args.data_flatten:
+        replace_qwen2_vl_attention_class()
+    model.config.use_cache = False
+
+    if training_args.gradient_checkpointing:
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        else:
+            def make_inputs_require_grad(module, input_, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+    tokenizer = transformers.AutoTokenizer.from_pretrained(
+        model_args.model_name_or_path,
+        cache_dir=training_args.cache_dir,
+        model_max_length=training_args.model_max_length,
+        padding_side="right",
+        use_fast=False,
+    )
+
+    set_lora_training_policy(model_args, model)
+    model = apply_lora_to_llm(model_args, model)
+
+    if is_rank0() and hasattr(model, "print_trainable_parameters"):
+        model.print_trainable_parameters()
+
+    data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)
+    trainer = Trainer(
+        model=model, processing_class=tokenizer, args=training_args, **data_module
+    )
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        logging.info("checkpoint found, resume training")
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+
+    trainer.save_state()
+    data_args.image_processor.save_pretrained(training_args.output_dir)
+
+    source_path = os.path.join(model_args.model_name_or_path, "chat_template.json")
+    template_path = os.path.join(training_args.output_dir, "chat_template.json")
+    if os.path.exists(source_path):
+        shutil.copy2(source_path, template_path)
+
+    model.config.use_cache = True
+    save_lora_adapter(model=trainer.model, tokenizer=tokenizer, image_processor=data_args.image_processor, output_dir=training_args.output_dir)
+
+    # Keep compatibility with existing checkpoint expectations.
+    safe_save_model_for_hf_trainer(trainer=trainer, output_dir=training_args.output_dir)
+
+
+if __name__ == "__main__":
+    train(attn_implementation="flash_attention_2")

LoRA/zero2_lora.json

@@ -0,0 +1,24 @@
+{
+  "train_batch_size": "auto",
+  "train_micro_batch_size_per_gpu": "auto",
+  "gradient_accumulation_steps": "auto",
+  "gradient_clipping": "auto",
+  "zero_allow_untested_optimizer": true,
+  "fp16": {
+    "enabled": "auto",
+    "loss_scale": 0,
+    "loss_scale_window": 1000,
+    "initial_scale_power": 16,
+    "hysteresis": 2,
+    "min_loss_scale": 1
+  },
+  "bf16": {
+    "enabled": "auto"
+  },
+  "zero_optimization": {
+    "stage": 2,
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "reduce_bucket_size": "auto"
+  }
+}

PARQUET_AND_ORIGINAL_TRAINING_USAGE.md

@@ -0,0 +1,291 @@
+# JanusVLN 数据格式与训练使用说明
+
+本文说明如何分别使用原始 PNG 图片数据和 parquet 图片数据进行 JanusVLN 的全量微调或 LoRA 微调。
+
+## 1. 数据文件约定
+
+### 原始 PNG 数据
+
+原始代码默认使用 PNG 图片目录：
+
+```text
+data/trajectory_data/R2R/train/<episode_id>/step_*.png
+data/trajectory_data/RxR/train/<episode_id>/step_*.png
+```
+
+对应的训练 annotation 文件是：
+
+```text
+train_r2r_rxr.json
+```
+
+对应的数据集名是：
+
+```text
+train_r2r_rxr
+```
+
+### Parquet 数据
+
+parquet 版本使用你已经生成的 annotation 文件：
+
+```text
+train_r2r_rxr_parquet.json
+```
+
+对应的数据集名是：
+
+```text
+train_r2r_rxr_parquet
+```
+
+该 annotation 中的 `images` 字段不是 PNG 路径，而是 parquet 引用，例如：
+
+```text
+parquet:data/trajectory_data/R2R/r2r_train_full.parquet|trajectory_id=1|image_index=0|filename=step_0000_TURN_RIGHT.png
+```
+
+训练代码会自动识别 `parquet:` 前缀，并从 parquet 中读取图片。
+
+parquet 文件默认路径：
+
+```text
+data/trajectory_data/R2R/r2r_train_full.parquet
+data/trajectory_data/RxR/rxr_train_full.parquet
+```
+
+如果存在分片目录，代码会优先读取分片，避免直接扫描超大的完整 parquet 文件：
+
+```text
+data/trajectory_data/R2R/r2r_train_full_shards/data/*.parquet
+data/trajectory_data/RxR/rxr_train_full_shards/data/*.parquet
+```
+
+为了提升训练启动和读取速度，建议同时保留 manifest 文件：
+
+```text
+data/trajectory_data/R2R/r2r_train_full_shards/trajectory_manifest.json
+data/trajectory_data/RxR/rxr_train_full_shards/trajectory_manifest.json
+```
+
+manifest 会记录每个 `trajectory_id` 位于哪个 shard、哪个 row group、哪一行。训练时会优先读取 manifest，因此不需要每个 dataloader worker 启动时重新扫描所有分片。
+
+## 2. 环境依赖
+
+parquet 训练需要 `pyarrow`：
+
+```bash
+pip install pyarrow
+```
+
+当前项目的 `requirements.txt` 已加入：
+
+```text
+pyarrow
+```
+
+如果使用本机 JanusVLN conda 环境，可以先确认：
+
+```bash
+/home/catlab/anaconda3/envs/JanusVLN/bin/python -c "import pyarrow; print(pyarrow.__version__)"
+```
+
+## 3. 生成 parquet annotation
+
+如果还没有 `train_r2r_rxr_parquet.json`，可运行：
+
+```bash
+/home/catlab/anaconda3/bin/python create_data/create_data_parquet.py \
+  --output_path train_r2r_rxr_parquet.json
+```
+
+小规模测试并和原 PNG 逻辑对齐：
+
+```bash
+/home/catlab/anaconda3/bin/python create_data/create_data_parquet.py \
+  --max_episodes 5 \
+  --output_path train_r2r_rxr_parquet_test.json \
+  --compare_png
+```
+
+## 4. 生成 parquet shards manifest
+
+如果你使用的是分片 parquet，建议先生成 manifest：
+
+```bash
+/home/catlab/anaconda3/bin/python data/trajectory_data/generate_parquet_manifest.py \
+  --source-parquet data/trajectory_data/R2R/r2r_train_full.parquet \
+  --overwrite
+
+/home/catlab/anaconda3/bin/python data/trajectory_data/generate_parquet_manifest.py \
+  --source-parquet data/trajectory_data/RxR/rxr_train_full.parquet \
+  --overwrite
+```
+
+生成后会得到：
+
+```text
+data/trajectory_data/R2R/r2r_train_full_shards/trajectory_manifest.json
+data/trajectory_data/RxR/rxr_train_full_shards/trajectory_manifest.json
+```
+
+训练读取优先级：
+
+```text
+manifest -> shards/data/*.parquet -> full parquet
+```
+
+## 5. 使用原始 PNG 数据训练
+
+### 全量微调
+
+使用原始脚本：
+
+```bash
+bash scripts/train.sh
+```
+
+该脚本内部使用：
+
+```bash
+DATASETS="train_r2r_rxr"
+```
+
+也就是读取 `train_r2r_rxr.json` 和原始 PNG 图片目录。
+
+### LoRA 微调
+
+使用原始 LoRA 脚本：
+
+```bash
+bash LoRA/train_lora.sh
+```
+
+该脚本默认使用：
+
+```bash
+DATASETS="train_r2r_rxr"
+```
+
+也可以显式指定：
+
+```bash
+DATASETS=train_r2r_rxr bash LoRA/train_lora.sh
+```
+
+## 6. 使用 parquet 数据训练
+
+### 全量微调
+
+使用新增 parquet 脚本：
+
+```bash
+bash scripts/train_parquet.sh
+```
+
+该脚本内部使用：
+
+```bash
+DATASETS="train_r2r_rxr_parquet"
+```
+
+也就是读取 `train_r2r_rxr_parquet.json`，并通过 parquet 引用读取图片。
+
+### LoRA 微调
+
+使用新增 parquet LoRA 脚本：
+
+```bash
+bash LoRA/train_lora_parquet.sh
+```
+
+该脚本会设置：
+
+```bash
+DATASETS="train_r2r_rxr_parquet"
+OUTPUT_DIR="./JanusVLN_LoRA_Base_Parquet"
+```
+
+也可以复用原 LoRA 脚本并显式指定 parquet 数据集：
+
+```bash
+DATASETS=train_r2r_rxr_parquet \
+OUTPUT_DIR=./JanusVLN_LoRA_Base_Parquet \
+bash LoRA/train_lora.sh
+```
+
+## 7. 快速验证 parquet 是否可读取
+
+可以用下面命令验证 parquet annotation 中的图片引用能否被训练代码读取：
+
+```bash
+/home/catlab/anaconda3/envs/JanusVLN/bin/python - <<'PY'
+import json
+from pathlib import Path
+import sys
+
+root = Path("/home/catlab/Project/JanusVLN-main")
+sys.path.insert(0, str(root / "src"))
+
+from qwen_vl.data.parquet_image_reader import ParquetImageReader
+
+with open(root / "train_r2r_rxr_parquet.json", "r", encoding="utf-8") as f:
+    sample = json.load(f)[0]
+
+img = ParquetImageReader(project_root=root).read_image(sample["images"][0])
+print(img.mode, img.size)
+PY
+```
+
+正常输出类似：
+
+```text
+RGB (640, 480)
+```
+
+## 8. 文件对应关系
+
+原始 PNG 训练：
+
+```text
+scripts/train.sh
+LoRA/train_lora.sh
+train_r2r_rxr.json
+dataset_use=train_r2r_rxr
+```
+
+parquet 训练：
+
+```text
+scripts/train_parquet.sh
+LoRA/train_lora_parquet.sh
+train_r2r_rxr_parquet.json
+dataset_use=train_r2r_rxr_parquet
+```
+
+核心适配代码：
+
+```text
+src/qwen_vl/data/parquet_image_reader.py
+src/qwen_vl/data/data_qwen.py
+src/qwen_vl/data/__init__.py
+data/trajectory_data/generate_parquet_manifest.py
+```
+
+## 9. Checkpoint 保存策略
+
+当前训练脚本均设置为每 1000 个 optimizer step 保存一次：
+
+```bash
+--save_steps 1000
+```
+
+旧配置曾使用：
+
+```bash
+--save_total_limit 1
+```
+
+这会删除旧 checkpoint，只保留最新的 1 个。现在该限制已移除，因此会保留所有每 1000 step 保存下来的 checkpoint。
+
+

README.md

@@ -0,0 +1,253 @@
+<div align="center">
+<img src="assets/logo.png" alt="JanusVLN Logo" width="100"/>
+
+<h1>JanusVLN: Decoupling Semantics and Spatiality with Dual Implicit Memory for Vision-Language Navigation</h1>
+
+<h1 align="center"><strong>🎉🎉ICLR 2026🎉🎉</strong></h1>
+
+[Shuang Zeng](https://scholar.google.com/citations?user=91lbdPcAAAAJ&hl=zh-CN)<sup>1,2</sup>,
+[Dekang Qi](https://scholar.google.com/citations?user=fOU1xMAAAAAJ&hl=zh-CN&oi=ao)<sup>1</sup>,
+[Xinyuan Chang](https://scholar.google.com.hk/citations?user=5OnPBVYAAAAJ&hl=zh-CN)<sup>1</sup>,
+[Feng Xiong](https://scholar.google.com/citations?hl=zh-CN&user=_X4MQ-gAAAAJ)<sup>1</sup>,
+Shichao Xie<sup>1</sup>,
+Xiaolong Wu<sup>1</sup>,
+Shiyi Liang<sup>1,2</sup>,
+Mu Xu<sup>1</sup>,
+[Xing Wei](https://scholar.google.com.hk/citations?user=KNyC5EUAAAAJ&hl=zh-CN&oi=ao/)<sup>2</sup>
+
+
+<sup>1</sup>Amap, Alibaba Group,
+<sup>2</sup>Xi’an Jiaotong University
+
+[![arXiv](https://img.shields.io/badge/arXiv-2509.22548-red)](https://arxiv.org/abs/2509.22548)
+[![Website](https://img.shields.io/badge/🌐-Website-green)](https://miv-xjtu.github.io/JanusVLN.github.io/)
+[![Video](https://img.shields.io/badge/🎥-Live_Demo-purple)](https://www.youtube.com/watch?v=SfrkZks_XE8)
+[![HuggingFace](https://img.shields.io/badge/🚀-Model_Base-yellow)](https://www.modelscope.cn/models/misstl/JanusVLN_Base)
+[![HuggingFace](https://img.shields.io/badge/🏆-Model_Extra-yellow)](https://www.modelscope.cn/models/misstl/JanusVLN_Extra)
+[![HF Demo](https://img.shields.io/badge/💾-Data-orange)](https://www.modelscope.cn/datasets/misstl/JanusVLN_Trajectory_Data)
+
+https://github.com/user-attachments/assets/bc477e20-2dd2-4927-b382-f483f578f3e1
+
+</div>
+
+
+
+## 💡 Introduction
+**JanusVLN** is a novel VLN framework and the first to feature a **dual implicit memory**. Inspired by the implicit scene representation in human navigation, which integrates left-brain semantic understanding with right-brain spatial cognition, JanusVLN constructs two complementary, fixed-size, compact neural memory. JanusVLN steers VLN research from 2D semantics-dominant toward 3D spatial-semantisynergy, a critical direction for developing next-generation spatial embodied agents.
+
+
+<div style="text-align: center;">
+  <img src="assets/overview.jpg" alt="JanusVLN" width="888"/>
+</div>
+
+## 📢 News
+[2026-1-26] JanusVLN has been accepted by ICLR 2026! 🎉🎉
+
+[2025-11-06] Due to the previous upload of incorrect weights for the `JanusVLN_Extra` model, if you need to directly infer, please download the correct weights from [JanusVLN_Extra](https://www.modelscope.cn/models/misstl/JanusVLN_Extra) again.
+
+## Table of Contents
+- [🛠️ Installation](#-Installation)
+- [📦 Data Preparation](#-Data-Preparation)
+- [🏆 Model Zoo](#-Model-Zoo)
+- [🚀 Training](#-Training)
+- [📈 Evaluation](#-Evaluation)
+- [📜 Citing](#-Citing)
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+## 🛠️ Installation
+
+Create the required environment through the following steps:
+
+```bash
+git clone https://github.com/MIV-XJTU/JanusVLN.git && cd JanusVLN
+
+conda create -n janusvln python=3.9 -y && conda activate janusvln
+
+conda install habitat-sim==0.2.4 withbullet headless -c conda-forge -c aihabitat
+
+git clone --branch v0.2.4 https://github.com/facebookresearch/habitat-lab.git
+cd habitat-lab
+pip install -e habitat-lab
+pip install -e habitat-baselines
+cd ..
+
+# CUDA 12.4
+pip install torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu124
+
+pip install -r requirements.txt
+# Install JanusVLN
+pip install -e .
+```
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+## 📦 Data Preparation
+
+1、**Scene Datasets**
+- For **R2R**, **RxR**: Download the MP3D scenes from the [official project page](https://niessner.github.io/Matterport/), and place them under `data/scene_datasets/mp3d/`.
+- For **ScaleVLN**: Download the HM3D scenes from the [official github page](https://github.com/matterport/habitat-matterport-3dresearch), and place the `train` split under `data/scene_datasets/hm3d/`.
+
+2、**VLN-CE Episodes**  
+   Download the VLN-CE episodes and extract them into the `data/datasets/` directory:
+   - [r2r](https://drive.google.com/file/d/1fo8F4NKgZDH-bPSdVU3cONAkt5EW-tyr/view) (Rename `R2R_VLNCE_v1-3_preprocessed/` -> `r2r/`)
+   - [rxr](https://drive.google.com/file/d/145xzLjxBaNTbVgBfQ8e9EsBAV8W-SM0t/view) (Rename `RxR_VLNCE_v0/` -> `rxr/`)
+   - [scalevln](https://huggingface.co/datasets/cywan/StreamVLN-Trajectory-Data/blob/main/ScaleVLN/scalevln_subset_150k.json.gz) (Follow the StreamVLN to convert a subset of the ScaleVLN dataset into the VLN-CE format.)
+
+3、**Collected Trajectory Data**
+
+We provide pre-collected observation-action trajectory data for training. R2R and RxR are collected following VLN-CE. ScaleVLN is collected following StreamVLN. DAgger data is collected using [JanusVLN_Base](https://www.modelscope.cn/models/misstl/JanusVLN_Base). Note: It is best to collect DAgger data using your own base model. Download the collected trajectory data from [ModelScope](https://www.modelscope.cn/datasets/misstl/JanusVLN_Trajectory_Data) and extract it to the `data/trajectory_data/` and `data/dagger_data/` directory.
+
+Your final folder structure should look like this:
+```bash
+data/
+├── datasets/
+│   ├── r2r/
+│   │   ├── train/
+│   │   ├── val_seen/
+│   │   │   └── val_seen.json.gz
+│   │   └── val_unseen/
+│   │       └── val_unseen.json.gz
+│   ├── rxr/
+│   │   ├── train/
+│   │   ├── val_seen/
+│   │   │   ├── val_seen_guide.json.gz
+│   │   │   └── ...
+│   │   └── val_unseen/
+│   │       ├── val_unseen_guide.json.gz
+│   │       └── ...
+│   └── scalevln/
+│       └── scalevln_subset_150k.json.gz
+├── scene_datasets/
+│   ├── hm3d/
+│   │   ├── 00000-kfPV7w3FaU5/
+│   │   ├── 00001-UVdNNRcVyV1/
+│   │   └── ...
+│   └── mp3d/
+│       ├── 17DRP5sb8fy/
+│       ├── 1LXtFkjw3qL/
+│       └── ...
+├── trajectory_data/
+│   ├── R2R-CE-640x480/
+│   │   └── images/   
+│   ├── RxR-CE-640x480/
+│   │   └── images/ 
+│   └── ScaleVLN/
+│       ├── images/
+│       └── annotations.json
+└── dagger_data/
+    ├── R2R/
+    │   ├── images/
+    │   └── annotations.json
+    └── RxR/
+        ├── images/
+        └── annotations.json
+```
+
+
+4、**Build Datasets**
+
+Construct a base dataset that only includes R2R-CE and RxR-CE:
+
+```bash
+python create_data/create_data.py
+```
+
+Finally, the dataset information needs to be configured in the file `src/qwen_vl/data/__init__.py`.
+
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+## 🏆 Model Zoo
+We have separately provided two sets of JanusVLN model weights to distinguish whether additional data is used or not:
+
+<table border="0">
+    <tr>
+        <th>Model</th>
+        <th>Data</th>
+        <th>Name</th>
+    </tr>
+    <hr style="border: 2px solid black;">
+    <tr>
+        <td rowspan="3"><b>JanusVLN</b></td>
+        <td>R2R-CE,RxR-CE</td>
+        <td><a href="https://www.modelscope.cn/models/misstl/JanusVLN_Base">JanusVLN_Base</a></td>
+    </tr>
+    <tr>
+        <td>R2R-CE,RxR-CE,DAgger,ScaleVLN</td>
+        <td><a href="https://www.modelscope.cn/models/misstl/JanusVLN_Extra">JanusVLN_Extra</a></td>
+    </tr>
+</table>
+
+
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+## 🚀 Training
+
+1. **Base Training**
+
+    Use the base data to train the base model:
+
+    ```bash
+    bash scripts/train.sh
+    ```
+2. **Dagger Collection**
+
+    Collecting DAgger data using the base model:
+
+    ```bash
+    bash scripts/dagger.sh
+    ```
+
+    Construct extra dataset:
+    
+    ```bash
+    python create_data/create_data.py --use_extra_data
+    ```
+
+    It is also necessary to configure the dataset information in the file `src/qwen_vl/data/__init__.py`.
+2. **Extra Training**
+
+    Continue training on extra data on top of the base model:
+
+    ```bash
+    bash scripts/train_extra.sh
+    ```
+
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+## 📈 Evaluation
+Use multiple GPUs to infer the model for evaluation:
+
+```bash
+bash scripts/evaluation.sh
+```
+
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+
+
+
+## 📜 Citing
+
+If you find FSDrive is useful in your research or applications, please consider giving us a star 🌟 and citing it by the following BibTeX entry:
+
+```
+@article{zeng2025janusvln,
+            title={JanusVLN: Decoupling Semantics and Spatiality with Dual Implicit Memory for Vision-Language Navigation},
+            author={Zeng, Shuang and Qi, Dekang and Chang, Xinyuan and Xiong, Feng and Xie, Shichao and Wu, Xiaolong and Liang, Shiyi and Xu, Mu and Wei, Xing},
+            journal={arXiv preprint arXiv:2509.22548},
+            year={2025}
+            }
+```
+<p align="right"><a href="#readme-top"><img src=https://img.shields.io/badge/back%20to%20top-red?style=flat
+></a></p>
+
+
+
+## 🙏 Acknowledgement
+Our work is primarily based on the following codebases:[Qwen2.5-VL](https://github.com/QwenLM/Qwen3-VL), [VGGT](https://github.com/facebookresearch/vggt), [StreamVLN](https://github.com/InternRobotics/StreamVLN), [VG-LLM](https://github.com/LaVi-Lab/VG-LLM). We are sincerely grateful for their work.
+

config/vln_dagger.yaml

@@ -0,0 +1,58 @@
+# @package _global_
+
+defaults:
+  - /habitat: habitat_config_base
+  - /habitat/task: vln_r2r
+  - /habitat/simulator/agents@habitat.simulator.agents.main_agent: rgbd_agent
+  - /habitat/dataset/vln: mp3d_r2r
+  - /habitat/task/lab_sensors:
+    - gps_sensor
+    - compass_sensor
+  - _self_
+
+habitat:
+  environment:
+    max_episode_steps: 500
+    iterator_options:
+      max_scene_repeat_steps: 50000
+      shuffle: False
+  simulator:
+    agents:
+      main_agent:
+        sim_sensors:
+          rgb_sensor:
+            width: 640
+            height: 480
+            hfov: 79
+          depth_sensor:
+            width: 640
+            height: 480
+            hfov: 79
+            min_depth: 0.0
+            max_depth: 10.0
+    forward_step_size: 0.25
+    turn_angle: 15
+    habitat_sim_v0:
+      gpu_device_id: 0
+  task:
+    measurements:
+      distance_to_goal:
+        type: DistanceToGoal
+        distance_to: POINT
+      success:
+        type: Success
+        success_distance: 3.0
+      spl:
+        type: SPL
+      oracle_success:
+        type: OracleSuccess
+      oracle_navigation_error:
+        type: OracleNavigationError
+      pl:
+        type: PL
+        
+  dataset:
+    type: R2RVLN-v1
+    split: train
+    scenes_dir: data/scene_datasets/
+    data_path: data/datasets/r2r/{split}/{split}.json.gz

config/vln_r2r.yaml

@@ -0,0 +1,56 @@
+# @package _global_
+
+defaults:
+  - /habitat: habitat_config_base
+  - /habitat/task: vln_r2r
+  - /habitat/simulator/agents@habitat.simulator.agents.main_agent: rgbd_agent
+  - /habitat/dataset/vln: mp3d_r2r
+  - /habitat/task/lab_sensors:
+    - gps_sensor
+    - compass_sensor
+  - _self_
+
+habitat:
+  environment:
+    max_episode_steps: 100000
+    iterator_options:
+      max_scene_repeat_steps: 50000
+      shuffle: False
+  simulator:
+    agents:
+      main_agent:
+        sim_sensors:
+          rgb_sensor:
+            width: 640
+            height: 480
+            hfov: 79
+          depth_sensor:
+            width: 640
+            height: 480
+            hfov: 79
+            min_depth: 0.0
+            max_depth: 10.0
+    forward_step_size: 0.25
+    turn_angle: 15
+    habitat_sim_v0:
+      gpu_device_id: 0
+  task:
+    measurements:
+      distance_to_goal:
+        type: DistanceToGoal
+        distance_to: POINT
+      success:
+        type: Success
+        success_distance: 3.0
+      spl:
+        type: SPL
+      oracle_success:
+        type: OracleSuccess
+      oracle_navigation_error:
+        type: OracleNavigationError
+        
+  dataset:
+    type: R2RVLN-v1
+    split: val_seen
+    scenes_dir: data/scene_datasets/
+    data_path: data/datasets/r2r/{split}/{split}.json.gz

create_data/create_data.py

@@ -0,0 +1,335 @@
+import argparse
+import concurrent.futures
+import glob
+import gzip
+import json
+import os
+from functools import partial
+
+import numpy as np
+from tqdm import tqdm
+
+max_history_images = 8
+RxR
+
+class JsonArrayWriter:
+    def __init__(self, output_path):
+        self.output_path = output_path
+        self.file = None
+        self.first = True
+        self.count = 0
+
+    def __enter__(self):
+        self.file = open(self.output_path, "w", encoding="utf-8")
+        self.file.write("[\n")
+        return self
+
+    def append_many(self, items):
+        for item in items:
+            if not self.first:
+                self.file.write(",\n")
+            json.dump(item, self.file, ensure_ascii=False)
+            self.first = False
+            self.count += 1
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.file is not None:
+            self.file.write("\n]\n")
+            self.file.close()
+        return False
+
+
+def process_episode_scalevln(ep, img_root, act_map):
+    episode_results = []
+    episode_id = str(ep["id"])
+    instruction = ep["instructions"][0]
+    name = ep["video"].split("/")[1]
+    img_dir = os.path.join(img_root, name, "rgb")
+    missing_images_count = 0
+
+    img_files = sorted(glob.glob(os.path.join(img_dir, "*.jpg")))
+    if not img_files:
+        return []
+
+    num_images = len(img_files)
+    for i in range(num_images):
+        if i <= max_history_images:
+            idxs = list(range(i + 1))
+        else:
+            idxs = np.linspace(0, i, 9, dtype=int).tolist()
+        sampled_imgs = [img_files[j] for j in idxs]
+
+        original_len = len(sampled_imgs)
+        sampled_imgs = [img_path for img_path in sampled_imgs if os.path.exists(img_path)]
+
+        num_missing = original_len - len(sampled_imgs)
+        if num_missing > 0:
+            missing_images_count += num_missing
+
+        if not sampled_imgs:
+            continue
+
+        his_img_tags = "<image>" * (len(sampled_imgs) - 1)
+
+        if i == num_images - 1:
+            action = "STOP"
+        else:
+            action = act_map[ep["actions"][i + 1]]
+
+        conversations = [
+            {
+                "from": "human",
+                "value": f"You are a visual language navigation model, and your should go to the locations to complete the given task. Compare the observation and instruction to infer your current progress, and then select the correct direction from the candidates to go to the target location and finish the task.\n This is your historical observation:{his_img_tags}\n This is your current observation:<image>\n Your task is to {instruction}\n You should take one of the following actions:\n MOVE_FORWARD\n TURN_LEFT\n TURN_RIGHT\n STOP.",
+            },
+            {"from": "gpt", "value": action},
+        ]
+
+        sample_dict = {
+            "id": f"{episode_id}/{os.path.basename(img_files[i])}",
+            "conversations": conversations,
+            "images": sampled_imgs,
+        }
+
+        episode_results.append(sample_dict)
+
+    if missing_images_count != 0:
+        print("miss:", missing_images_count)
+
+    return episode_results
+
+
+def process_episode_vlnce(ep, img_root):
+    episode_results = []
+    episode_id = str(ep["episode_id"])
+    instruction = ep["instruction"]["instruction_text"].strip()
+    img_dir = os.path.join(img_root, episode_id)
+
+    img_files = sorted(glob.glob(os.path.join(img_dir, "*.png")))
+    if not img_files:
+        return []
+
+    for i in range(len(img_files)):
+        if i <= max_history_images:
+            idxs = list(range(i + 1))
+        else:
+            idxs = np.linspace(0, i, 9, dtype=int).tolist()
+        sampled_imgs = [img_files[j] for j in idxs]
+
+        his_img_tags = "<image>" * (len(sampled_imgs) - 1)
+        name_parts = os.path.basename(img_files[i]).replace(".png", "").split("_")
+        if len(name_parts) > 3:
+            action = f"{name_parts[-2].upper()}_{name_parts[-1].upper()}"
+        else:
+            action = name_parts[-1].upper()
+
+        conversations = [
+            {
+                "from": "human",
+                "value": f"You are a visual language navigation model, and your should go to the locations to complete the given task. Compare the observation and instruction to infer your current progress, and then select the correct direction from the candidates to go to the target location and finish the task.\n This is your historical observation:{his_img_tags}\n This is your current observation:<image>\n Your task is to {instruction}\n You should take one of the following actions:\n MOVE_FORWARD\n TURN_LEFT\n TURN_RIGHT\n STOP.",
+            },
+            {"from": "gpt", "value": action},
+        ]
+
+        sample_dict = {
+            "id": f"{episode_id}/{os.path.basename(img_files[i])}",
+            "conversations": conversations,
+            "images": sampled_imgs,
+        }
+
+        episode_results.append(sample_dict)
+
+    return episode_results
+
+
+def process_dataset_streaming(dataset_name, episodes, worker_fn, executor, writer, max_in_flight):
+    total_episodes = len(episodes)
+    print(f"\nProcessing {dataset_name}...")
+    if total_episodes == 0:
+        print(f"Skipping {dataset_name}: no episodes found.")
+        return
+
+    ep_iter = iter(episodes)
+    in_flight = set()
+    initial = min(max_in_flight, total_episodes)
+
+    for _ in range(initial):
+        in_flight.add(executor.submit(worker_fn, next(ep_iter)))
+
+    pbar = tqdm(total=total_episodes)
+    while in_flight:
+        done, in_flight = concurrent.futures.wait(
+            in_flight,
+            return_when=concurrent.futures.FIRST_COMPLETED,
+        )
+
+        for fut in done:
+            episode_res = fut.result()
+            writer.append_many(episode_res)
+            pbar.update(1)
+
+            try:
+                in_flight.add(executor.submit(worker_fn, next(ep_iter)))
+            except StopIteration:
+                pass
+
+    pbar.close()
+    print(f"Finished {dataset_name}. Total samples so far: {writer.count}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Process VLN datasets for training.")
+    parser.add_argument(
+        "--use_extra_data",
+        action="store_true",
+        help="Include extra datasets (ScaleVLN, DAgger R2R, DAgger RxR) in the processing.",
+    )
+    parser.add_argument(
+        "--num_workers",
+        type=int,
+        default=min(16, os.cpu_count() or 8),
+        help="Number of workers for data processing.",
+    )
+    parser.add_argument(
+        "--executor",
+        type=str,
+        default="thread",
+        choices=["thread", "process"],
+        help="Parallel executor type. Use thread for better stability on large RxR runs.",
+    )
+    parser.add_argument(
+        "--max_in_flight",
+        type=int,
+        default=64,
+        help="Maximum number of submitted-but-unfinished tasks.",
+    )
+    args = parser.parse_args()
+
+    # --- ScaleVLN Dataset ---
+    img_root_scalevln = "data/trajectory_data/ScaleVLN/images"
+    json_path_scalevln = "data/trajectory_data/ScaleVLN/annotations.json"
+    act_map_scalevln = ["STOP", "MOVE_FORWARD", "TURN_LEFT", "TURN_RIGHT"]
+
+    # --- DAgger Dataset ---
+    img_root_dagger_r2r = "data/dagger_data/R2R/images"
+    json_path_dagger_r2r = "data/dagger_data/R2R/annotations.json"
+    act_map_dagger_r2r = ["STOP", "MOVE_FORWARD", "TURN_LEFT", "TURN_RIGHT"]
+
+    img_root_dagger_rxr = "data/dagger_data/RxR/images"
+    json_path_dagger_rxr = "data/dagger_data/RxR/annotations.json"
+    act_map_dagger_rxr = ["STOP", "MOVE_FORWARD", "TURN_LEFT", "TURN_RIGHT"]
+
+    # --- R2R Dataset ---
+    img_root_r2r = "data/trajectory_data/R2R/train"
+    json_path_r2r = "data/datasets/r2r/train/train.json.gz"
+
+    # --- RxR Dataset ---
+    img_root_rxr = "data/trajectory_data/RxR/train"
+    json_path_rxr = "data/datasets/rxr/train/train_guide.json.gz"
+
+    print("Loading JSON data...")
+
+    if args.use_extra_data:
+        with open(json_path_scalevln, "r", encoding="utf-8") as f:
+            data_scalevln = json.load(f)
+
+        with open(json_path_dagger_r2r, "r", encoding="utf-8") as f:
+            data_dagger_r2r = json.load(f)
+
+        with open(json_path_dagger_rxr, "r", encoding="utf-8") as f:
+            data_dagger_rxr = json.load(f)
+
+    with gzip.open(json_path_r2r, "rt", encoding="utf-8") as f:
+        data_r2r = json.load(f)
+
+    with gzip.open(json_path_rxr, "rt", encoding="utf-8") as f:
+        data_rxr = json.load(f)
+
+    print("JSON data loaded.")
+
+    if args.use_extra_data:
+        output_path = "train_r2r_rxr_extra.json"
+    else:
+        output_path = "train_r2r_rxr.json"
+
+    executor_cls = (
+        concurrent.futures.ThreadPoolExecutor
+        if args.executor == "thread"
+        else concurrent.futures.ProcessPoolExecutor
+    )
+
+    print(
+        f"Using executor={args.executor}, num_workers={args.num_workers}, max_in_flight={args.max_in_flight}"
+    )
+    print(f"Streaming output to {output_path}")
+
+    with JsonArrayWriter(output_path) as writer:
+        with executor_cls(max_workers=args.num_workers) as executor:
+            if args.use_extra_data:
+                p_process_scalevln = partial(
+                    process_episode_scalevln,
+                    img_root=img_root_scalevln,
+                    act_map=act_map_scalevln,
+                )
+                process_dataset_streaming(
+                    dataset_name="ScaleVLN dataset",
+                    episodes=data_scalevln,
+                    worker_fn=p_process_scalevln,
+                    executor=executor,
+                    writer=writer,
+                    max_in_flight=args.max_in_flight,
+                )
+
+                p_process_dagger_r2r = partial(
+                    process_episode_scalevln,
+                    img_root=img_root_dagger_r2r,
+                    act_map=act_map_dagger_r2r,
+                )
+                process_dataset_streaming(
+                    dataset_name="DAgger R2R dataset",
+                    episodes=data_dagger_r2r,
+                    worker_fn=p_process_dagger_r2r,
+                    executor=executor,
+                    writer=writer,
+                    max_in_flight=args.max_in_flight,
+                )
+
+                p_process_dagger_rxr = partial(
+                    process_episode_scalevln,
+                    img_root=img_root_dagger_rxr,
+                    act_map=act_map_dagger_rxr,
+                )
+                process_dataset_streaming(
+                    dataset_name="DAgger RxR dataset",
+                    episodes=data_dagger_rxr,
+                    worker_fn=p_process_dagger_rxr,
+                    executor=executor,
+                    writer=writer,
+                    max_in_flight=args.max_in_flight,
+                )
+
+            p_process_r2r = partial(process_episode_vlnce, img_root=img_root_r2r)
+            process_dataset_streaming(
+                dataset_name="R2R dataset",
+                episodes=data_r2r["episodes"],
+                worker_fn=p_process_r2r,
+                executor=executor,
+                writer=writer,
+                max_in_flight=args.max_in_flight,
+            )
+
+            p_process_rxr = partial(process_episode_vlnce, img_root=img_root_rxr)
+            process_dataset_streaming(
+                dataset_name="RxR dataset",
+                episodes=data_rxr["episodes"],
+                worker_fn=p_process_rxr,
+                executor=executor,
+                writer=writer,
+                max_in_flight=args.max_in_flight,
+            )
+
+    print(f"\nAll processing finished. Saved {writer.count} samples to {output_path}.")
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

create_data/create_data_parquet.py

@@ -0,0 +1,464 @@
+#!/usr/bin/env python3
+"""
+Create JanusVLN training annotations from trajectory parquet files.
+
+注意需要在JanusVLN-main目录下运行，否则会报错。
+
+Terminal usage:
+1) Use a Python environment with pyarrow, numpy, and tqdm installed.
+   On this machine, the base conda Python has the needed packages:
+   /home/catlab/anaconda3/bin/python create_data/create_data_parquet.py
+
+2) Generate a small R2R/RxR parquet-based test annotation and compare it with
+   the original PNG-folder logic:
+   /home/catlab/anaconda3/bin/python create_data/create_data_parquet.py \
+       --max_episodes 5 \
+       --output_path train_r2r_rxr_parquet_test.json \
+       --compare_png
+
+3) Generate the full parquet-based annotation:
+   /home/catlab/anaconda3/bin/python create_data/create_data_parquet.py \
+       --output_path train_r2r_rxr_parquet.json
+
+Notes:
+- The generated JSON keeps the same top-level sample shape as create_data.py:
+  id / conversations / images.
+- Since images now live inside parquet files, each item in "images" is a compact
+  parquet reference string instead of a PNG file path. The LoRA/full-finetune
+  data loader should later parse these references and read the image bytes from
+  parquet on demand.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+
+MAX_HISTORY_IMAGES = 8
+PROMPT_TEMPLATE = (
+    "You are a visual language navigation model, and your should go to the "
+    "locations to complete the given task. Compare the observation and "
+    "instruction to infer your current progress, and then select the correct "
+    "direction from the candidates to go to the target location and finish the "
+    "task.\n This is your historical observation:{history_image_tags}\n This is "
+    "your current observation:<image>\n Your task is to {instruction}\n You "
+    "should take one of the following actions:\n MOVE_FORWARD\n TURN_LEFT\n "
+    "TURN_RIGHT\n STOP."
+)
+
+
+class JsonArrayWriter:
+    def __init__(self, output_path: Path):
+        self.output_path = output_path
+        self.file = None
+        self.first = True
+        self.count = 0
+
+    def __enter__(self) -> "JsonArrayWriter":
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        self.file = open(self.output_path, "w", encoding="utf-8")
+        self.file.write("[\n")
+        return self
+
+    def append_many(self, items: list[dict]) -> None:
+        if self.file is None:
+            raise RuntimeError("Writer is not open.")
+        for item in items:
+            if not self.first:
+                self.file.write(",\n")
+            json.dump(item, self.file, ensure_ascii=False)
+            self.first = False
+            self.count += 1
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        if self.file is not None:
+            self.file.write("\n]\n")
+            self.file.close()
+        return False
+
+
+class ParquetTrajectoryIndex:
+    """Lightweight trajectory metadata index built without loading image bytes."""
+
+    def __init__(self, parquet_path: Path, project_root: Path):
+        self.parquet_path = parquet_path
+        self.project_root = project_root
+        self.steps_by_episode_id: dict[str, list[str]] = {}
+
+    @property
+    def reference_path(self) -> str:
+        try:
+            return str(self.parquet_path.relative_to(self.project_root))
+        except ValueError:
+            return str(self.parquet_path)
+
+    def load(self, batch_size: int) -> None:
+        if not self.parquet_path.is_file():
+            raise FileNotFoundError(f"Parquet file not found: {self.parquet_path}")
+
+        parquet_file = pq.ParquetFile(self.parquet_path)
+        total_rows = parquet_file.metadata.num_rows
+        required_columns = {"trajectory_id", "steps", "images"}
+        schema_columns = set(parquet_file.schema_arrow.names)
+        missing_columns = required_columns - schema_columns
+        if missing_columns:
+            raise ValueError(
+                f"{self.parquet_path} is missing required columns: {sorted(missing_columns)}"
+            )
+
+        print(f"Indexing parquet metadata: {self.parquet_path}")
+        with tqdm(total=total_rows, desc=f"Index {self.parquet_path.name}", unit="traj") as pbar:
+            for batch in parquet_file.iter_batches(
+                batch_size=batch_size,
+                columns=["trajectory_id", "steps"],
+                use_threads=True,
+            ):
+                data = batch.to_pydict()
+                for trajectory_id, steps in zip(data["trajectory_id"], data["steps"]):
+                    key = str(trajectory_id)
+                    if key in self.steps_by_episode_id:
+                        raise ValueError(
+                            f"Duplicate trajectory_id '{key}' in {self.parquet_path}"
+                        )
+                    self.steps_by_episode_id[key] = list(steps)
+                pbar.update(batch.num_rows)
+
+    def get_steps(self, episode_id: str) -> list[str] | None:
+        return self.steps_by_episode_id.get(str(episode_id))
+
+    def image_reference(self, episode_id: str, image_index: int, step: str) -> str:
+        filename = step_to_filename(step)
+        return (
+            f"parquet:{self.reference_path}"
+            f"|trajectory_id={episode_id}"
+            f"|image_index={image_index}"
+            f"|filename={filename}"
+        )
+
+
+def step_to_filename(step: str) -> str:
+    return f"step_{step}.png"
+
+
+def action_from_step(step: str) -> str:
+    name_parts = step_to_filename(step).replace(".png", "").split("_")
+    if len(name_parts) > 3:
+        return f"{name_parts[-2].upper()}_{name_parts[-1].upper()}"
+    return name_parts[-1].upper()
+
+
+def sampled_indices(current_index: int) -> list[int]:
+    if current_index <= MAX_HISTORY_IMAGES:
+        return list(range(current_index + 1))
+    return np.linspace(0, current_index, 9, dtype=int).tolist()
+
+
+def build_sample(
+    episode_id: str,
+    instruction: str,
+    steps: list[str],
+    current_index: int,
+    parquet_index: ParquetTrajectoryIndex,
+) -> dict:
+    idxs = sampled_indices(current_index)
+    sampled_images = [
+        parquet_index.image_reference(episode_id, image_index, steps[image_index])
+        for image_index in idxs
+    ]
+    history_image_tags = "<image>" * (len(sampled_images) - 1)
+    action = action_from_step(steps[current_index])
+    filename = step_to_filename(steps[current_index])
+
+    conversations = [
+        {
+            "from": "human",
+            "value": PROMPT_TEMPLATE.format(
+                history_image_tags=history_image_tags,
+                instruction=instruction,
+            ),
+        },
+        {"from": "gpt", "value": action},
+    ]
+
+    return {
+        "id": f"{episode_id}/{filename}",
+        "conversations": conversations,
+        "images": sampled_images,
+    }
+
+
+def process_episode_vlnce_parquet(ep: dict, parquet_index: ParquetTrajectoryIndex) -> list[dict]:
+    episode_id = str(ep["episode_id"])
+    instruction = ep["instruction"]["instruction_text"].strip()
+    steps = parquet_index.get_steps(episode_id)
+    if not steps:
+        return []
+
+    return [
+        build_sample(
+            episode_id=episode_id,
+            instruction=instruction,
+            steps=steps,
+            current_index=i,
+            parquet_index=parquet_index,
+        )
+        for i in range(len(steps))
+    ]
+
+
+def process_episode_vlnce_png(ep: dict, img_root: Path) -> list[dict]:
+    """Original PNG-folder logic, used only for local consistency checks."""
+    episode_id = str(ep["episode_id"])
+    instruction = ep["instruction"]["instruction_text"].strip()
+    img_dir = img_root / episode_id
+    if not img_dir.is_dir():
+        return []
+
+    img_files = sorted(str(img_dir / name) for name in os.listdir(img_dir) if name.endswith(".png"))
+    if not img_files:
+        return []
+
+    results = []
+    for i, img_file in enumerate(img_files):
+        idxs = sampled_indices(i)
+        sampled_imgs = [img_files[j] for j in idxs]
+        history_image_tags = "<image>" * (len(sampled_imgs) - 1)
+        name_parts = os.path.basename(img_file).replace(".png", "").split("_")
+        if len(name_parts) > 3:
+            action = f"{name_parts[-2].upper()}_{name_parts[-1].upper()}"
+        else:
+            action = name_parts[-1].upper()
+        results.append(
+            {
+                "id": f"{episode_id}/{os.path.basename(img_file)}",
+                "conversations": [
+                    {
+                        "from": "human",
+                        "value": PROMPT_TEMPLATE.format(
+                            history_image_tags=history_image_tags,
+                            instruction=instruction,
+                        ),
+                    },
+                    {"from": "gpt", "value": action},
+                ],
+                "images": sampled_imgs,
+            }
+        )
+    return results
+
+
+def load_episodes(json_gz_path: Path) -> list[dict]:
+    if not json_gz_path.is_file():
+        raise FileNotFoundError(f"Dataset json not found: {json_gz_path}")
+    with gzip.open(json_gz_path, "rt", encoding="utf-8") as f:
+        data = json.load(f)
+    return data["episodes"]
+
+
+def truncate_episodes(episodes: list[dict], max_episodes: int | None) -> list[dict]:
+    if max_episodes is None:
+        return episodes
+    return episodes[:max_episodes]
+
+
+def compare_with_png(
+    dataset_name: str,
+    episodes: list[dict],
+    parquet_index: ParquetTrajectoryIndex,
+    png_root: Path,
+) -> None:
+    compared_samples = 0
+    compared_episodes = 0
+    for ep in tqdm(episodes, desc=f"Compare {dataset_name}", unit="episode"):
+        parquet_samples = process_episode_vlnce_parquet(ep, parquet_index)
+        png_samples = process_episode_vlnce_png(ep, png_root)
+        if not parquet_samples and not png_samples:
+            continue
+        if len(parquet_samples) != len(png_samples):
+            raise AssertionError(
+                f"{dataset_name} episode {ep['episode_id']} sample count mismatch: "
+                f"parquet={len(parquet_samples)}, png={len(png_samples)}"
+            )
+        for parquet_sample, png_sample in zip(parquet_samples, png_samples):
+            if parquet_sample["id"] != png_sample["id"]:
+                raise AssertionError(
+                    f"{dataset_name} id mismatch: {parquet_sample['id']} != {png_sample['id']}"
+                )
+            if parquet_sample["conversations"] != png_sample["conversations"]:
+                raise AssertionError(
+                    f"{dataset_name} conversation mismatch for {parquet_sample['id']}"
+                )
+            parquet_filenames = [
+                ref.split("|filename=", 1)[1] for ref in parquet_sample["images"]
+            ]
+            png_filenames = [os.path.basename(path) for path in png_sample["images"]]
+            if parquet_filenames != png_filenames:
+                raise AssertionError(
+                    f"{dataset_name} image history mismatch for {parquet_sample['id']}"
+                )
+            compared_samples += 1
+        compared_episodes += 1
+
+    print(
+        f"{dataset_name} comparison passed: "
+        f"{compared_episodes} episodes, {compared_samples} samples."
+    )
+
+
+def write_dataset(
+    dataset_name: str,
+    episodes: list[dict],
+    parquet_index: ParquetTrajectoryIndex,
+    writer: JsonArrayWriter,
+) -> None:
+    print(f"\nProcessing {dataset_name} from parquet...")
+    missing_episodes = 0
+    for ep in tqdm(episodes, desc=dataset_name, unit="episode"):
+        samples = process_episode_vlnce_parquet(ep, parquet_index)
+        if not samples:
+            missing_episodes += 1
+            continue
+        writer.append_many(samples)
+    if missing_episodes:
+        print(f"{dataset_name}: skipped {missing_episodes} episodes without parquet images.")
+    print(f"Finished {dataset_name}. Total samples so far: {writer.count}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--output_path",
+        default="train_r2r_rxr_parquet.json",
+        type=Path,
+        help="Output annotation JSON path.",
+    )
+    parser.add_argument(
+        "--datasets",
+        nargs="+",
+        choices=["r2r", "rxr"],
+        default=["r2r", "rxr"],
+        help="Datasets to process.",
+    )
+    parser.add_argument(
+        "--max_episodes",
+        default=None,
+        type=int,
+        help="Debug mode: process only the first N episodes from each selected dataset.",
+    )
+    parser.add_argument(
+        "--index_batch_size",
+        default=1024,
+        type=int,
+        help="Batch size for reading parquet metadata columns.",
+    )
+    parser.add_argument(
+        "--r2r_parquet",
+        default=Path("data/trajectory_data/R2R/r2r_train_full.parquet"),
+        type=Path,
+        help="R2R trajectory parquet file.",
+    )
+    parser.add_argument(
+        "--rxr_parquet",
+        default=Path("data/trajectory_data/RxR/rxr_train_full.parquet"),
+        type=Path,
+        help="RxR trajectory parquet file.",
+    )
+    parser.add_argument(
+        "--r2r_json",
+        default=Path("data/datasets/r2r/train/train.json.gz"),
+        type=Path,
+        help="R2R annotation json.gz.",
+    )
+    parser.add_argument(
+        "--rxr_json",
+        default=Path("data/datasets/rxr/train/train_guide.json.gz"),
+        type=Path,
+        help="RxR annotation json.gz.",
+    )
+    parser.add_argument(
+        "--compare_png",
+        action="store_true",
+        help="Compare generated metadata with the original PNG-folder logic.",
+    )
+    return parser.parse_args()
+
+
+def resolve_project_path(project_root: Path, path: Path) -> Path:
+    if path.is_absolute():
+        return path
+    return project_root / path
+
+
+def main() -> None:
+    args = parse_args()
+    project_root = Path(__file__).resolve().parents[1]
+    output_path = resolve_project_path(project_root, args.output_path)
+
+    config = {
+        "r2r": {
+            "name": "R2R dataset",
+            "json": resolve_project_path(project_root, args.r2r_json),
+            "parquet": resolve_project_path(project_root, args.r2r_parquet),
+            "png_root": project_root / "data/trajectory_data/R2R/train",
+        },
+        "rxr": {
+            "name": "RxR dataset",
+            "json": resolve_project_path(project_root, args.rxr_json),
+            "parquet": resolve_project_path(project_root, args.rxr_parquet),
+            "png_root": project_root / "data/trajectory_data/RxR/train",
+        },
+    }
+
+    print(f"Project root: {project_root}")
+    print(f"Output path: {output_path}")
+    print(f"Selected datasets: {', '.join(args.datasets)}")
+    if args.max_episodes is not None:
+        print(f"Debug mode: first {args.max_episodes} episodes per dataset")
+
+    loaded = {}
+    for key in args.datasets:
+        dataset_config = config[key]
+        episodes = truncate_episodes(
+            load_episodes(dataset_config["json"]),
+            args.max_episodes,
+        )
+        parquet_index = ParquetTrajectoryIndex(
+            parquet_path=dataset_config["parquet"],
+            project_root=project_root,
+        )
+        parquet_index.load(batch_size=args.index_batch_size)
+        loaded[key] = (episodes, parquet_index)
+
+        if args.compare_png:
+            compare_with_png(
+                dataset_name=dataset_config["name"],
+                episodes=episodes,
+                parquet_index=parquet_index,
+                png_root=dataset_config["png_root"],
+            )
+
+    with JsonArrayWriter(output_path) as writer:
+        for key in args.datasets:
+            episodes, parquet_index = loaded[key]
+            write_dataset(
+                dataset_name=config[key]["name"],
+                episodes=episodes,
+                parquet_index=parquet_index,
+                writer=writer,
+            )
+
+    print(f"\nAll processing finished. Saved {writer.count} samples to {output_path}.")
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()
+

data/trajectory_data/generate_parquet_manifest.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Generate a trajectory manifest for parquet shards.
+
+Terminal usage:
+1) Generate R2R manifest:
+   /home/catlab/anaconda3/bin/python /home/catlab/Project/JanusVLN-main/data/trajectory_data/generate_parquet_manifest.py \
+       --source-parquet /home/catlab/Project/JanusVLN-main/data/trajectory_data/R2R/r2r_train_full.parquet
+
+2) Generate RxR manifest:
+   /home/catlab/anaconda3/bin/python /home/catlab/Project/JanusVLN-main/data/trajectory_data/generate_parquet_manifest.py \
+       --source-parquet /home/catlab/Project/JanusVLN-main/data/trajectory_data/RxR/rxr_train_full.parquet
+
+The output is written next to the shard directory:
+  <source_stem>_shards/trajectory_manifest.json
+
+The training reader uses this file to map:
+  trajectory_id -> shard parquet file + row_group + row_index
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+
+def default_shards_dir(source_parquet: Path) -> Path:
+    return source_parquet.with_name(f"{source_parquet.stem}_shards")
+
+
+def relative_to_manifest(manifest_path: Path, shard_path: Path) -> str:
+    try:
+        return str(shard_path.relative_to(manifest_path.parent))
+    except ValueError:
+        return str(shard_path)
+
+
+def build_manifest(
+    source_parquet: Path,
+    shards_dir: Path,
+    manifest_path: Path,
+    batch_size: int,
+) -> dict:
+    data_dir = shards_dir / "data"
+    if not data_dir.is_dir():
+        raise FileNotFoundError(f"Shard data directory not found: {data_dir}")
+
+    shard_paths = sorted(data_dir.glob("*.parquet"))
+    if not shard_paths:
+        raise FileNotFoundError(f"No parquet shards found in {data_dir}")
+
+    entries: dict[str, dict] = {}
+    total_rows = 0
+
+    for shard_path in tqdm(shard_paths, desc=f"Index {shards_dir.name}", unit="shard"):
+        parquet_file = pq.ParquetFile(shard_path)
+        if "trajectory_id" not in parquet_file.schema_arrow.names:
+            raise ValueError(f"Missing trajectory_id column: {shard_path}")
+
+        for row_group_index in range(parquet_file.metadata.num_row_groups):
+            row_index_in_group = 0
+            for batch in parquet_file.iter_batches(
+                batch_size=batch_size,
+                row_groups=[row_group_index],
+                columns=["trajectory_id"],
+                use_threads=True,
+            ):
+                for trajectory_id in batch.column("trajectory_id").to_pylist():
+                    trajectory_id = str(trajectory_id)
+                    if trajectory_id in entries:
+                        raise ValueError(
+                            f"Duplicate trajectory_id={trajectory_id} in {shards_dir}"
+                        )
+                    entries[trajectory_id] = {
+                        "file": relative_to_manifest(manifest_path, shard_path),
+                        "row_group": row_group_index,
+                        "row_index": row_index_in_group,
+                    }
+                    row_index_in_group += 1
+                    total_rows += 1
+
+    return {
+        "version": 1,
+        "source_parquet": str(source_parquet),
+        "shards_dir": str(shards_dir),
+        "data_dir": str(data_dir),
+        "total_trajectories": total_rows,
+        "num_shards": len(shard_paths),
+        "entries": entries,
+    }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--source-parquet",
+        required=True,
+        type=Path,
+        help="Original full parquet path referenced by train_r2r_rxr_parquet.json.",
+    )
+    parser.add_argument(
+        "--shards-dir",
+        default=None,
+        type=Path,
+        help="Shard directory. Defaults to <source_stem>_shards next to source parquet.",
+    )
+    parser.add_argument(
+        "--manifest-path",
+        default=None,
+        type=Path,
+        help="Output manifest path. Defaults to <shards_dir>/trajectory_manifest.json.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        default=4096,
+        type=int,
+        help="Batch size for scanning the lightweight trajectory_id column.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite existing manifest.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    source_parquet = args.source_parquet.resolve()
+    shards_dir = (args.shards_dir or default_shards_dir(source_parquet)).resolve()
+    manifest_path = (args.manifest_path or (shards_dir / "trajectory_manifest.json")).resolve()
+
+    if manifest_path.exists() and not args.overwrite:
+        raise FileExistsError(f"Manifest already exists: {manifest_path}")
+
+    manifest = build_manifest(
+        source_parquet=source_parquet,
+        shards_dir=shards_dir,
+        manifest_path=manifest_path,
+        batch_size=args.batch_size,
+    )
+
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(manifest_path, "w", encoding="utf-8") as f:
+        json.dump(manifest, f, ensure_ascii=False, indent=2)
+
+    print(f"Manifest saved: {manifest_path}")
+    print(f"Shards: {manifest['num_shards']}")
+    print(f"Trajectories: {manifest['total_trajectories']}")
+
+
+if __name__ == "__main__":
+    main()
+

data/trajectory_data/img2parquet.py

@@ -0,0 +1,126 @@
+import os
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm import tqdm
+import subprocess
+import gc  # 引入垃圾回收机制
+
+def get_inode_count(path):
+    """获取指定路径下的 inode 使用数 (仅限 Linux/macOS)"""
+    try:
+        count = subprocess.check_output(['find', path, '-printf', 'i'], stderr=subprocess.DEVNULL)
+        return len(count)
+    except:
+        return "无法获取 (可能非类Unix系统)"
+
+def convert_trajectory_dataset(src_root, output_parquet, max_samples=None, chunk_size=500):
+    initial_inodes = get_inode_count(src_root)
+    print(f"[*] 初始路径: {src_root}")
+    print(f"[*] 原始目录估算占用 Inodes: {initial_inodes}")
+
+    # 获取所有轨迹文件夹
+    traj_folders = [f for f in os.listdir(src_root) if os.path.isdir(os.path.join(src_root, f))]
+    
+    # 对文件夹进行排序
+    traj_folders.sort(key=lambda x: int(x) if x.isdigit() else x)
+    
+    # 切片逻辑
+    if max_samples is not None:
+        traj_folders = traj_folders[:max_samples]
+        print(f"[*] ⚠️ 测试模式开启: 仅处理前 {max_samples} 个轨迹文件夹")
+    else:
+        print(f"[*] 🚀 全量模式开启: 准备处理全部 {len(traj_folders)} 个轨迹...")
+
+    # ================= 修改核心区域 =================
+    writer = None
+    chunk_data = []
+
+    print(f"[*] 采用流式写入，每 {chunk_size} 个轨迹刷新一次内存...")
+    
+    for i, traj_id in enumerate(tqdm(traj_folders)):
+        traj_path = os.path.join(src_root, traj_id)
+        img_files = sorted([f for f in os.listdir(traj_path) if f.endswith('.png')])
+        
+        images_binary = []
+        instructions = []
+        
+        for img_name in img_files:
+            img_path = os.path.join(traj_path, img_name)
+            with open(img_path, 'rb') as f:
+                images_binary.append(f.read())
+            
+            instruction = img_name.replace('step_', '').replace('.png', '')
+            instructions.append(instruction)
+        
+        chunk_data.append({
+            'trajectory_id': traj_id,
+            'steps': instructions,
+            'images': images_binary
+        })
+
+        # 当达到 chunk_size 或者遍历到最后一个文件夹时，触发写入
+        is_last_item = (i + 1) == len(traj_folders)
+        if (i + 1) % chunk_size == 0 or is_last_item:
+            # 1. 转换为 DataFrame 和 PyArrow Table
+            df_chunk = pd.DataFrame(chunk_data)
+            table = pa.Table.from_pandas(df_chunk)
+
+            # 2. 如果是第一批数据，初始化 ParquetWriter (需要依赖第一批数据的 schema)
+            if writer is None:
+                writer = pq.ParquetWriter(output_parquet, table.schema, compression='snappy')
+
+            # 3. 将这一块数据追加写入 Parquet 文件
+            writer.write_table(table)
+
+            # 4. 彻底清空本轮数据，释放内存 (核心操作)
+            del chunk_data
+            del df_chunk
+            del table
+            chunk_data = []
+            gc.collect()  # 强制进行垃圾回收
+            
+    # 循环结束后，关闭文件写入器
+    if writer is not None:
+        writer.close()
+    # ================================================
+    
+    print(f"\n[+] 转换完成! 文件已保存至: {output_parquet}")
+    print(f"[*] 当前 Parquet 文件占用 Inode: 1")
+    
+    # 估算节省的 Inode
+    if isinstance(initial_inodes, int) and max_samples is None:
+        print(f"[!] 全量转换理论节省 Inode 数量: {initial_inodes - 1}")
+    elif max_samples is not None:
+        estimated_saved = sum([len(os.listdir(os.path.join(src_root, d))) for d in traj_folders]) + len(traj_folders)
+        print(f"[!] 本次测试批次理论节省 Inode 数量: {estimated_saved} (包括文件夹与文件)")
+
+if __name__ == "__main__":
+    source_directory = "/home/catlab/Project/JanusVLN-main/data/trajectory_data/R2R-CE-640x480/train" 
+    
+    # 将输出文件放到和 train 平级的目录
+    output_dir = os.path.dirname(source_directory)
+    
+    # ---------------------------------------------------------
+    # 【配置区】
+    # ---------------------------------------------------------
+    TEST_BATCH_SIZE = None   # None 表示跑全量。你可以先设为 200 测试一下内存占用
+    CHUNK_SIZE = 500         # 【新增】每次读入内存的轨迹数量。64GB 内存设为 500 甚至 1000 都毫无压力
+    
+    if TEST_BATCH_SIZE is not None:
+        output_filename = f"r2r_train_test_{TEST_BATCH_SIZE}.parquet"
+    else:
+        output_filename = "r2r_train_full.parquet"
+        
+    output_filepath = os.path.join(output_dir, output_filename)
+        
+    if os.path.exists(source_directory):
+        print(f"[*] 计划将文件输出至: {output_filepath}")
+        convert_trajectory_dataset(
+            source_directory, 
+            output_filepath, 
+            max_samples=TEST_BATCH_SIZE, 
+            chunk_size=CHUNK_SIZE
+        )
+    else:
+        print(f"错误: 找不到源路径 {source_directory}，请检查当前工作目录。")

data/trajectory_data/merge_parquet_shards.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Merge parquet shards back into one parquet file.
+
+Terminal usage:
+1) Install dependencies:
+   pip3 install pyarrow tqdm
+
+2) Merge R2R shards:
+   python3 /home/catlab/Project/JanusVLN-main/data/trajectory_data/merge_parquet_shards.py \
+       --input-dir /home/catlab/Project/JanusVLN-main/data/trajectory_data/R2R/r2r_train_full_shards/data \
+       --output-file /home/catlab/Project/JanusVLN-main/data/trajectory_data/R2R/r2r_train_full.parquet
+
+3) Merge RxR shards:
+   python3 /home/catlab/Project/JanusVLN-main/data/trajectory_data/merge_parquet_shards.py \
+       --input-dir /home/catlab/Project/JanusVLN-main/data/trajectory_data/RxR/rxr_train_full_shards/data \
+       --output-file /home/catlab/Project/JanusVLN-main/data/trajectory_data/RxR/rxr_train_full.parquet
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input-dir",
+        required=True,
+        type=Path,
+        help="Directory containing parquet shards (for example: .../r2r_train_full_shards/data).",
+    )
+    parser.add_argument(
+        "--output-file",
+        required=True,
+        type=Path,
+        help="Output merged parquet file path.",
+    )
+    parser.add_argument(
+        "--pattern",
+        default="*.parquet",
+        help="Glob pattern used to select shard files in input directory.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        default=65536,
+        type=int,
+        help="Rows per batch while streaming data from shards.",
+    )
+    parser.add_argument(
+        "--compression",
+        default="snappy",
+        help="Compression codec for the merged parquet file (snappy, gzip, zstd, ...).",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite output file if it already exists.",
+    )
+    return parser.parse_args()
+
+
+def collect_shards(input_dir: Path, pattern: str) -> list[Path]:
+    if not input_dir.is_dir():
+        raise FileNotFoundError(f"Input directory does not exist: {input_dir}")
+    shards = sorted(input_dir.glob(pattern))
+    if not shards:
+        raise FileNotFoundError(
+            f"No shard files found in {input_dir} with pattern '{pattern}'"
+        )
+    return shards
+
+
+def merge_shards(
+    shards: list[Path],
+    output_file: Path,
+    batch_size: int,
+    compression: str,
+) -> int:
+    first_file = pq.ParquetFile(shards[0])
+    schema = first_file.schema_arrow
+
+    total_rows = 0
+    for shard in shards:
+        total_rows += pq.ParquetFile(shard).metadata.num_rows
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    rows_written = 0
+
+    with pq.ParquetWriter(output_file, schema=schema, compression=compression) as writer:
+        with tqdm(total=len(shards), desc="Shards", unit="file") as shard_bar:
+            with tqdm(total=total_rows, desc="Rows", unit="row") as row_bar:
+                for shard in shards:
+                    parquet_file = pq.ParquetFile(shard)
+                    shard_schema = parquet_file.schema_arrow
+                    if not shard_schema.equals(schema):
+                        raise ValueError(f"Schema mismatch in shard: {shard}")
+
+                    for batch in parquet_file.iter_batches(
+                        batch_size=batch_size,
+                        use_threads=True,
+                    ):
+                        table = pa.Table.from_batches([batch], schema=schema)
+                        writer.write_table(table)
+                        batch_rows = table.num_rows
+                        rows_written += batch_rows
+                        row_bar.update(batch_rows)
+                    shard_bar.update(1)
+
+    return rows_written
+
+
+def main() -> None:
+    args = parse_args()
+    shards = collect_shards(args.input_dir, args.pattern)
+
+    if args.output_file.exists() and not args.overwrite:
+        raise FileExistsError(
+            f"Output file already exists: {args.output_file}. "
+            "Use --overwrite to replace it."
+        )
+    if args.output_file.exists() and args.overwrite:
+        args.output_file.unlink()
+
+    print(f"Found shards: {len(shards)}")
+    print(f"Input dir: {args.input_dir}")
+    print(f"Output file: {args.output_file}")
+    print(f"Compression: {args.compression}")
+    print(f"Batch size: {args.batch_size}")
+
+    rows_written = merge_shards(
+        shards=shards,
+        output_file=args.output_file,
+        batch_size=args.batch_size,
+        compression=args.compression,
+    )
+
+    merged_metadata = pq.ParquetFile(args.output_file).metadata
+    merged_rows = merged_metadata.num_rows
+    merged_row_groups = merged_metadata.num_row_groups
+
+    print("Merge completed.")
+    print(f"Rows written: {rows_written}")
+    print(f"Merged file rows: {merged_rows}")
+    print(f"Merged file row groups: {merged_row_groups}")
+    print(f"Output size bytes: {args.output_file.stat().st_size}")
+
+    if rows_written != merged_rows:
+        raise RuntimeError(
+            f"Row count mismatch: wrote {rows_written}, merged file reports {merged_rows}"
+        )
+
+
+if __name__ == "__main__":
+    main()
+

data/trajectory_data/split_parquet_shards.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Split a large parquet file into smaller parquet shards."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+def parse_size(value: str) -> int:
+    units = {
+        "b": 1,
+        "kb": 1024,
+        "mb": 1024**2,
+        "gb": 1024**3,
+        "tb": 1024**4,
+    }
+    text = value.strip().lower()
+    for suffix, multiplier in sorted(units.items(), key=lambda item: len(item[0]), reverse=True):
+        if text.endswith(suffix):
+            number = float(text[: -len(suffix)].strip())
+            return int(number * multiplier)
+    return int(float(text))
+
+
+def shard_name(index: int) -> str:
+    return f"train-{index:05d}.parquet"
+
+
+def split_parquet(
+    source: Path,
+    output_dir: Path,
+    target_size: int,
+    batch_size: int,
+    compression: str,
+) -> None:
+    data_dir = output_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=False)
+
+    parquet_file = pq.ParquetFile(source)
+    schema = parquet_file.schema_arrow
+    source_rows = parquet_file.metadata.num_rows
+    source_row_groups = parquet_file.metadata.num_row_groups
+
+    print(f"source={source}", flush=True)
+    print(f"source_rows={source_rows}", flush=True)
+    print(f"source_row_groups={source_row_groups}", flush=True)
+    print(f"target_size_bytes={target_size}", flush=True)
+    print(f"batch_size={batch_size}", flush=True)
+
+    writer: pq.ParquetWriter | None = None
+    current_path: Path | None = None
+    shard_index = 0
+    shard_rows = 0
+    total_rows = 0
+
+    def open_writer() -> None:
+        nonlocal writer, current_path, shard_rows, shard_index
+        current_path = data_dir / shard_name(shard_index)
+        writer = pq.ParquetWriter(current_path, schema=schema, compression=compression)
+        shard_rows = 0
+        print(f"opened_shard={current_path}", flush=True)
+
+    def close_writer() -> None:
+        nonlocal writer, current_path, shard_rows, shard_index
+        if writer is None or current_path is None:
+            return
+        writer.close()
+        size = current_path.stat().st_size
+        print(
+            f"closed_shard={current_path} rows={shard_rows} size_bytes={size}",
+            flush=True,
+        )
+        writer = None
+        current_path = None
+        shard_index += 1
+        shard_rows = 0
+
+    try:
+        open_writer()
+        for row_group_index in range(source_row_groups):
+            for batch in parquet_file.iter_batches(
+                batch_size=batch_size,
+                row_groups=[row_group_index],
+                use_threads=True,
+            ):
+                if writer is None:
+                    open_writer()
+
+                table = pa.Table.from_batches([batch], schema=schema)
+                writer.write_table(table)
+                rows = table.num_rows
+                shard_rows += rows
+                total_rows += rows
+
+                if current_path is not None and current_path.exists():
+                    current_size = current_path.stat().st_size
+                    print(
+                        "progress "
+                        f"row_group={row_group_index + 1}/{source_row_groups} "
+                        f"total_rows={total_rows}/{source_rows} "
+                        f"current_shard={current_path.name} "
+                        f"current_size_bytes={current_size}",
+                        flush=True,
+                    )
+                    if current_size >= target_size:
+                        close_writer()
+
+        close_writer()
+    except Exception:
+        if writer is not None:
+            writer.close()
+        raise
+
+    print(f"completed total_rows={total_rows} shards={shard_index}", flush=True)
+    if total_rows != source_rows:
+        raise RuntimeError(f"row count mismatch: wrote {total_rows}, expected {source_rows}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", required=True, type=Path)
+    parser.add_argument("--output-dir", required=True, type=Path)
+    parser.add_argument("--target-size", default="10GB")
+    parser.add_argument("--batch-size", default=8, type=int)
+    parser.add_argument("--compression", default="snappy")
+    args = parser.parse_args()
+
+    if not args.source.is_file():
+        raise FileNotFoundError(args.source)
+    if args.output_dir.exists():
+        raise FileExistsError(f"Output directory already exists: {args.output_dir}")
+
+    split_parquet(
+        source=args.source,
+        output_dir=args.output_dir,
+        target_size=parse_size(args.target_size),
+        batch_size=args.batch_size,
+        compression=args.compression,
+    )
+
+
+if __name__ == "__main__":
+    main()

habitat-lab/.circleci/config.yml

@@ -0,0 +1,454 @@
+version: 2.1
+gpu: &gpu
+  machine:
+    image: ubuntu-2004-cuda-11.4:202110-01
+  resource_class: gpu.nvidia.medium
+  environment:
+    FPS_THRESHOLD: 900
+
+orbs:
+  codecov: codecov/codecov@3.2.3
+
+jobs:
+  python_lint:
+    docker:
+      - image: cimg/python:3.9.16
+    steps:
+      - checkout
+      - run:
+          name: setup
+          command: |
+              pip install black==23.1.0 --progress-bar off
+              pip install "isort[pyproject]" numpy --progress-bar off
+              pip install mypy==0.991 types-mock types-Pillow types-tqdm types-PyYAML --progress-bar off
+              pip install -r habitat-lab/requirements.txt --progress-bar off
+      - run:
+          name: run black
+          command: |
+              black --exclude '/(\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|_build|buck-out|build|dist)|examples/tutorials/(colabs|nb_python)' habitat-lab/. habitat-baselines/. examples/. test/. --diff
+              black --exclude '/(\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|_build|buck-out|build|dist)|examples/tutorials/(colabs|nb_python)' habitat-lab/. habitat-baselines/. examples/. test/. --check
+      - run:
+          name: run isort
+          command: |
+              isort --version
+              isort habitat-lab/. habitat-baselines/. examples/. test/.  --diff
+              isort habitat-lab/. habitat-baselines/. examples/. test/.  --check-only
+      - run:
+          name: run mypy
+          command: |
+              mypy --version
+              mypy --exclude="^docs/|setup.py$"
+      - run:
+          name: run assert no files in habitat and habitat_baselines
+          command: |
+              if test -d  habitat ;           then  echo "folder habitat should not exist";           exit 1; fi
+              if test -d  habitat_baselines ; then  echo "folder habitat_baselines should not exist"; exit 1; fi
+  pre-commit:
+    docker:
+      - image: cimg/python:3.9.16
+    working_directory: ~/repo/
+
+    steps:
+      - checkout
+      - run:
+          name: Combine precommit config and python versions for caching
+          command: |
+            cat .pre-commit-config.yaml > pre-commit-deps.txt
+            python -VV >> pre-commit-deps.txt
+      - restore_cache:
+          keys:
+          - v1-precommit-deps-{{ checksum "pre-commit-deps.txt" }}
+
+      - run:
+          name: Install Dependencies
+          command: |
+            pip install -U pip setuptools pre-commit
+            # Install the hooks now so that they'll be cached
+            pre-commit install-hooks
+      - save_cache:
+          paths:
+            - ~/.cache/pre-commit
+          key: v1-precommit-deps-{{ checksum "pre-commit-deps.txt" }}
+
+      - run:
+          name: Check Code Style using pre-commit
+          command: |
+            SKIP=clang-format,eslint pre-commit run --show-diff-on-failure --all-files
+  install_and_test_ubuntu:
+    <<: *gpu
+    steps:
+      - checkout:
+          path: ./habitat-lab
+      - run:
+          name: Install cmake
+          no_output_timeout: 5m
+          command: |
+              echo $(git ls-remote https://github.com/facebookresearch/habitat-sim.git HEAD | awk '{ print $1}') > ./hsim_sha
+              wget https://github.com/Kitware/CMake/releases/download/v3.13.4/cmake-3.13.4-Linux-x86_64.sh
+              sudo mkdir /opt/cmake
+              sudo sh ./cmake-3.13.4-Linux-x86_64.sh --prefix=/opt/cmake --skip-license
+              sudo ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake
+      - run:
+          name: Install dependencies
+          no_output_timeout: 20m
+          command: |
+              sudo apt-get update || true
+              sudo apt-get install -y --no-install-recommends \
+                  build-essential \
+                  git \
+                  curl \
+                  vim \
+                  ca-certificates \
+                  libjpeg-dev \
+                  libglm-dev \
+                  libegl1-mesa-dev \
+                  ninja-build \
+                  xorg-dev \
+                  freeglut3-dev \
+                  pkg-config \
+                  wget \
+                  zip \
+                  lcov\
+                  libhdf5-dev \
+                  libomp-dev \
+                  unzip || true
+              sudo apt install --allow-change-held-packages \
+                  texlive-base \
+                  texlive-latex-extra \
+                  texlive-fonts-extra \
+                  texlive-fonts-recommended
+      - run:
+          name: Check CUDA
+          no_output_timeout: 20m
+          background: true
+          command: nvidia-smi
+      # Restore Conda cache
+      - restore_cache:
+          keys:
+            - conda-{{ checksum "habitat-lab/.circleci/config.yml" }}
+      - run:
+          name: Install conda and dependencies
+          no_output_timeout: 20m
+          command: |
+              if [ ! -d ~/miniconda ]
+              then
+                curl -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
+                chmod +x ~/miniconda.sh
+                bash ~/miniconda.sh -b -p $HOME/miniconda
+                rm ~/miniconda.sh
+                export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+                conda create -y -n habitat python=3.9
+                . activate habitat
+                conda install -q -y -c conda-forge ninja ccache
+                pip install pytest-sugar>=0.9.6 mock cython pygame flaky pytest pytest-mock pytest-cov psutil
+              fi
+      - run:
+          name: Install pytorch
+          no_output_timeout: 20m
+          background: true
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat;
+              if [ ! -f ~/miniconda/pytorch_installed ]
+              then
+                # For whatever reason we have to install pytorch first. If it isn't
+                # it installs the 1.4 cpuonly version. Which is no good.
+                echo "Installing pytorch"
+                conda install -y pytorch==1.12.1=py3.9_cuda11.3_cudnn8.3.2_0 torchvision==0.13.1=py39_cu113 cudatoolkit=11.3 -c pytorch -c nvidia
+              fi
+              touch ~/miniconda/pytorch_installed
+              python -c 'import torch; print("Has cuda?", torch.cuda.is_available()); print("torch version:", torch.__version__);'
+      - restore_cache:
+          keys:
+            - v1-habitat-sim-{{ checksum "./hsim_sha" }}
+      - restore_cache:
+          keys:
+            - ccache-{{ arch }}-main
+          paths:
+            - /home/circleci/.ccache
+      - run:
+          name: CCache initialization
+          command: |
+            export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+            . activate habitat;
+            ccache --show-stats
+            ccache --zero-stats
+            ccache --max-size=10.0G
+      - run:
+          name: Build and install habitat-sim
+          no_output_timeout: 30m
+          command: |
+              if [ ! -d ./habitat-sim ]
+              then
+                git clone https://github.com/facebookresearch/habitat-sim.git --recursive
+              fi
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat;
+              cd habitat-sim
+              pip install -r requirements.txt --progress-bar off
+              pip install imageio imageio-ffmpeg
+              python -u setup.py install --headless --with-cuda --bullet
+      - run:
+          name: Ccache stats
+          when: always
+          command: |
+            export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+            . activate habitat;
+            ccache --show-stats
+      - run:
+          name: Download test data
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat
+              if [ ! -f ./habitat-sim/data/scene_datasets/habitat-test-scenes/van-gogh-room.glb ]
+              then
+                cd habitat-sim
+                wget http://dl.fbaipublicfiles.com/habitat/habitat-test-scenes.zip
+                unzip habitat-test-scenes.zip
+                rm habitat-test-scenes.zip
+                cd -
+              fi
+              if [ ! -f ./habitat-sim/data/robots/franka_panda/panda_arm.urdf ]
+              then
+                python -m habitat_sim.utils.datasets_download --uids franka_panda --data-path habitat-sim/data/
+              fi
+              if [ ! -f ./habitat-sim/data/robots/hab_spot_arm/urdf/hab_spot_arm.urdf ]
+              then
+                python -m habitat_sim.utils.datasets_download --uids hab_spot_arm --data-path habitat-sim/data/ --replace
+              fi
+              if [ ! -f ./habitat-sim/data/robots/hab_stretch/urdf/hab_stretch.urdf ]
+              then
+                python -m habitat_sim.utils.datasets_download --uids hab_stretch --data-path habitat-sim/data/
+              fi
+      - run:
+          name: Download coda scene
+          command: |
+            if [ ! -f ./habitat-sim/data/scene_datasets/coda/coda.glb ]
+            then
+              cd habitat-sim
+              wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1Pc-J6pZzXEd8RSeLM94t3iwO8q_RQ853' -O coda.zip
+              unzip coda.zip -d data/scene_datasets
+              rm coda.zip
+            fi
+      - run:
+          name: Run sim benchmark
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-sim
+              python examples/example.py --scene data/scene_datasets/habitat-test-scenes/van-gogh-room.glb --silent --test_fps_regression $FPS_THRESHOLD
+      - save_cache:
+          key: v1-habitat-sim-{{ checksum "./hsim_sha" }}
+          background: true
+          paths:
+            - ./habitat-sim
+      - save_cache:
+          key: ccache-{{ arch }}-main
+          background: true
+          paths:
+            - /home/circleci/.ccache
+      - run:
+          name: Install api with baselines
+          no_output_timeout: 20m
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-lab
+              ln -s ../habitat-sim/data data
+              while [ ! -f ~/miniconda/pytorch_installed ]; do sleep 2; done # wait for Pytorch
+              pip install -e habitat-lab
+              pip install -e habitat-baselines
+      - save_cache:
+          key: conda-{{ checksum "habitat-lab/.circleci/config.yml" }}
+          background: true
+          paths:
+            - ~/miniconda
+      - run:
+          name: Run api tests
+          no_output_timeout: 120m
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-lab
+              export PYTHONPATH=.:$PYTHONPATH
+              export MULTI_PROC_OFFSET=0 && export MAGNUM_LOG=quiet && export HABITAT_SIM_LOG=quiet
+              python -m pytest --cov-report=xml --cov-report term  --cov=./
+      - codecov/upload
+      - run:
+          name: Run baseline training tests
+          no_output_timeout: 30m
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-lab
+              export PYTHONPATH=.:$PYTHONPATH
+              export MULTI_PROC_OFFSET=0 && export MAGNUM_LOG=quiet && export HABITAT_SIM_LOG=quiet
+              # This is a flag that enables test_test_baseline_training to work
+              export TEST_BASELINE_SMALL=1
+              python -m pytest  test/test_baseline_training.py -s
+      - run:
+          name: Run Hab2.0 benchmark
+          no_output_timeout: 30m
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-lab
+              python -m habitat_sim.utils.datasets_download --uids hab2_bench_assets
+              mkdir -p data/ep_datasets/
+              cp data/hab2_bench_assets/bench_scene.json.gz data/ep_datasets/
+              bash scripts/hab2_bench/bench_runner.sh
+              python scripts/hab2_bench/plot_bench.py
+              # Assert the SPS number are up to standard
+              python scripts/hab2_bench/assert_bench.py
+      - run:
+          name: Build api documentation
+          command: |
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate habitat; cd habitat-lab
+              # Download sim inventory for crosslinking (no need to build
+              # the whole sim docs for that)
+              # TODO: take it from github.com/facebookmicrosites/habitat-website
+              #   instead
+              mkdir -p ../habitat-sim/build/docs-public/habitat-sim
+              curl -s https://aihabitat.org/docs/habitat-sim/objects.inv > ../habitat-sim/build/docs-public/habitat-sim/objects.inv
+              cd docs
+              conda install -y -c conda-forge doxygen
+              conda install -y  jinja2 pygments docutils
+              mkdir -p ../build/docs
+              ./build-public.sh
+      - run:
+          name: Ensure non-editable mode works
+          command: |
+              cd habitat-lab
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              conda create -y -n non-editable-install python=3.9
+              . activate non-editable-install
+              conda install -y -c conda-forge -c aihabitat-nightly habitat-sim
+              pip install habitat-lab/
+              python -c 'import habitat; print("habitat version:", habitat.__version__)'
+              pip install habitat-baselines/
+              python -c 'import habitat_baselines; print("habitat_baselines version:", habitat_baselines.__version__)'
+      - run: &build_sdist_and_bdist
+          name: Build sdist and bdist
+          command: |
+              cd habitat-lab
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              conda create -y -n build-env python=3.9
+              . activate build-env
+              pip install --upgrade build
+              python -m build -s -w -C--global-option=egg_info -C--global-option=--tag-date habitat-lab/
+              python -m build -s -w -C--global-option=egg_info -C--global-option=--tag-date habitat-baselines/
+      - run:
+          name: Ensure sdist and bdist intall work
+          command: |
+              cd habitat-lab
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              conda create -y -n bdist-install python=3.9
+              . activate bdist-install
+              conda install -y -c conda-forge -c aihabitat-nightly habitat-sim
+              conda create -n sdist-install --clone bdist-install
+              # install from built distribution:
+              . activate bdist-install
+              pip install habitat-lab/dist/habitat_lab*.whl
+              python -c 'import habitat; print("habitat version:", habitat.__version__)'
+              pip install habitat-baselines/dist/habitat_baselines*.whl
+              python -c 'import habitat_baselines; print("habitat_baselines version:", habitat_baselines.__version__)'
+              # install from source distribution:
+              . activate sdist-install
+              pip install habitat-lab/dist/habitat-lab*.tar.gz
+              python -c 'import habitat; print("habitat version:", habitat.__version__)'
+              pip install habitat-baselines/dist/habitat-baselines*.tar.gz
+              python -c 'import habitat_baselines; print("habitat_baselines version:", habitat_baselines.__version__)'
+      - store_artifacts:
+          path: habitat-lab/data/profile  # This is the benchmark profile
+  pypi_deploy:
+    <<: *gpu
+    parameters:
+      username_env_var:
+        description: "Twine username environment variable name"
+        type: env_var_name
+        default: TESTPYPI_USERNAME
+      password_env_var:
+        description: "Twine password environment variable name"
+        type: env_var_name
+        default: TESTPYPI_PASSWORD
+      repository:
+        description: "Twine repository name (possible options: testpypi or pypi)"
+        type: string
+        default: "testpypi"
+    steps:
+      - checkout:
+          path: ./habitat-lab
+      - run:
+          name: Install conda
+          no_output_timeout: 20m
+          command: |
+              if [ ! -d ~/miniconda ]
+              then
+                curl -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
+                chmod +x ~/miniconda.sh
+                bash ~/miniconda.sh -b -p $HOME/miniconda
+                rm ~/miniconda.sh
+              fi
+      - run: *build_sdist_and_bdist
+      - run:
+          name: Deploy Habitat-Lab and Habitat-Baselines distributions to PyPI
+          command: |
+              cd habitat-lab
+              export PATH=$HOME/miniconda/bin:/usr/local/cuda/bin:$PATH
+              . activate build-env
+              pip install --upgrade twine
+              twine upload \
+                --username ${<< parameters.username_env_var >>} \
+                --password ${<< parameters.password_env_var >>} \
+                --repository << parameters.repository >> \
+                habitat-lab/dist/*
+              twine upload \
+                --username ${<< parameters.username_env_var >>} \
+                --password ${<< parameters.password_env_var >>} \
+                --repository << parameters.repository >> \
+                habitat-baselines/dist/*
+
+workflows:
+  version: 2
+  install_and_test:
+    jobs:
+      - pre-commit
+      - python_lint
+      - install_and_test_ubuntu
+  testpypi_nightly:
+    triggers:
+      - schedule:
+          cron: "0 7 * * *"
+          filters:
+            branches:
+              only: main
+    jobs:
+      - pre-commit
+      - python_lint
+      - install_and_test_ubuntu
+      - pypi_deploy:
+          requires:
+            - pre-commit
+            - python_lint
+            - install_and_test_ubuntu
+          context:
+            - pypi_context
+  version_pipy_release:
+    jobs:
+      - pre-commit:
+          filters: &version_filter
+            tags:
+              only: /^v[0-9]+(\.[0-9]+)*.*/ # v0.1.5-rc1
+            branches:
+              ignore: /.*/
+      - python_lint:
+          filters: *version_filter
+      - install_and_test_ubuntu:
+          filters: *version_filter
+      - pypi_deploy:
+          filters: *version_filter
+          username_env_var: PYPI_USERNAME
+          password_env_var: PYPI_PASSWORD
+          repository: "pypi"
+          requires:
+            - pre-commit
+            - python_lint
+            - install_and_test_ubuntu
+          context:
+            - pypi_context

habitat-lab/.editorconfig

@@ -0,0 +1,22 @@
+# See https://editorconfig.org/ for more info :)
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+# isort can't parse [*.{py, rst}], so specifying it separately
+# https://github.com/timothycrosley/isort/issues/830
+[*.rst]
+indent_size = 4
+[*.py]
+indent_size = 4
+max_line_length = 79
+multi_line_output = 3
+force_grid_wrap = false
+include_trailing_comma = true
+ensure_newline_before_comments=true
+use_parentheses = true
+known_first_party = habitat,habitat_sim,habitat_baselines,version

habitat-lab/.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,41 @@
+---
+name: "\U0001F41B Bug Report"
+about: Submit a bug report to help us improve Habitat
+
+---
+
+## Habitat-Lab and Habitat-Sim versions
+Habitat-Lab: vx.x.x or master?
+
+Habitat-Sim: vx.x.x or master?
+
+Habitat is under active development, and we advise users to restrict themselves to stable releases of [Habitat-Lab](https://github.com/facebookresearch/habitat-lab/releases) and [Habitat-Sim](https://github.com/facebookresearch/habitat-sim/releases). The bug you are about to report may already be fixed in the latest version.
+
+Master branch contains 'bleeding edge' code, but we do appreciate bug reports for it!
+
+
+## 🐛 Bug
+
+<!-- A clear and concise description of what the bug is. -->
+
+## Steps to Reproduce
+
+Steps to reproduce the behavior:
+
+<!-- If you were running a command, post the exact command that you were running -->
+
+1.
+2.
+3.
+
+Please note that without a minimal working example to reproduce the bug, we may not be able to help you.
+
+<!-- If you have a code sample, error messages, stack traces, please provide it here as well -->
+
+## Expected behavior
+
+<!-- A clear and concise description of what you expected to happen. -->
+
+## Additional context
+
+<!-- Add any other context about the problem here. -->

habitat-lab/.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,24 @@
+---
+name: "\U0001F680Feature Request"
+about: Submit a proposal/request for a new Habitat feature
+
+---
+
+## 🚀 Feature
+<!-- A clear and concise description of the feature proposal -->
+
+## Motivation
+
+<!-- Please outline the motivation for the proposal. Is your feature request related to a problem? e.g., I'm always frustrated when [...]. If this is related to another GitHub issue, please link here too -->
+
+## Pitch
+
+<!-- A clear and concise description of what you want to happen. -->
+
+## Alternatives
+
+<!-- A clear and concise description of any alternative solutions or features you've considered, if any. -->
+
+## Additional context
+
+<!-- Add any other context or screenshots about the feature request here. -->

habitat-lab/.github/ISSUE_TEMPLATE/questions-help-support.md

@@ -0,0 +1,23 @@
+---
+name: "❓Questions/Help/Support"
+about: Do you need support?
+
+---
+
+## Habitat-Lab and Habitat-Sim versions
+Habitat-Lab: vx.x.x or master?
+
+Habitat-Sim: vx.x.x or master?
+
+Habitat is under active development, and we advise users to restrict themselves to stable releases. Are you using the latest release versions of [Habitat-Lab](https://github.com/facebookresearch/habitat-lab/releases) and [Habitat-Sim](https://github.com/facebookresearch/habitat-sim/releases)? Your question may already be addressed in the latest versions. We may also not be able to help with problems in earlier versions because they sometimes lack the more verbose logging needed for debugging.
+
+Master branch contains 'bleeding edge' code and should be used at your own risk.
+
+## Docs and Tutorials
+Did you read the docs? https://aihabitat.org/docs/habitat-lab/
+
+Did you check out the tutorials? https://aihabitat.org/tutorial/2020/
+
+Perhaps your question is answered there. If not, carry on!
+
+## ❓ Questions and Help

habitat-lab/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,29 @@
+## Motivation and Context
+
+<!--- Why is this change required? What problem does it solve? -->
+<!--- Please link to an existing issue here if one exists. -->
+<!--- (we recommend to have an existing issue for each pull request) -->
+
+## How Has This Been Tested
+
+<!--- Please describe here how your modifications have been tested. -->
+
+## Types of changes
+
+<!--- What types of changes does your code introduce? Please mark the title of your pull request with one of the following -->
+- **\[Docs change\]** Addition or changes to the documentation
+- **\[Refactoring\]** Large changes to the code that improve its functionality or performance
+- **\[Dependency Upgrade\]** Upgrades one or several dependencies in habitat
+- **\[Bug Fix\]** (non-breaking change which fixes an issue)
+- **\[Development\]** A pull request that add new features to the [habitat-lab](/habitat-lab) task and environment codebase. Development Pull Requests must be small (less that 500 lines of code change), have unit testing, very extensive documentation and examples. These are typically new tasks, environments, sensors, etc... The review process for these Pull Request is longer because these changes will be maintained by our core team of developers, so make sure your changes are easy to understand!
+- **\[Experiment\]** A pull request that add new features to the [habitat-baselines](/habitat-baselines/) training codebase. Experiments Pull Requests can be any size, must have smoke/integration tests and be isolated from the rest of the code. Your code additions should not rely on other habitat-baselines code. This is to avoid dependencies between different parts of habitat-baselines. You must also include a README that will document how to use your new feature or trainer. **You** will be the maintainer of this code, if the code becomes stale or is not supported often enough, we will eventually remove it.
+
+## Checklist
+
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+- [ ] My code follows the code style of this project.
+- [ ] I have updated the documentation if required.
+- [ ] I have read the [**CONTRIBUTING**](/CONTRIBUTING.md) document.
+- [ ] I have completed my CLA (see **CONTRIBUTING**)
+- [ ] I have added tests to cover my changes if required.

habitat-lab/.gitignore

@@ -0,0 +1,102 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+*/env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Hydra
+outputs/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+examples/images
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# DotEnv configuration
+.env
+
+# Database
+*.db
+*.rdb
+
+# Pycharm
+.idea
+
+# VS Code
+.vscode/
+
+# Spyder
+.spyproject/
+
+# Jupyter NB Checkpoints
+.ipynb_checkpoints/
+
+# exclude data from source control by default
+data
+
+# Mac OS-specific storage files
+.DS_Store
+
+# mypy
+.mypy_cache/
+
+# vim
+*.swp
+
+# habitat_baselines outputs
+/videos
+/train_dir
+/tb
+
+# outputs from other libraries
+/sandbox
+/plots/outputs
+/wandb/

habitat-lab/.pre-commit-config.yaml

@@ -0,0 +1,113 @@
+exclude: 'build|src/deps|src/obsolete'
+
+default_language_version:
+    python: python3
+
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-added-large-files
+        args: ['--maxkb=2000']
+    -   id: end-of-file-fixer
+    -   id: debug-statements
+    -   id: check-case-conflict
+    -   id: check-docstring-first
+    -   id: check-executables-have-shebangs
+    -   id: check-merge-conflict
+    -   id: check-toml
+    -   id: check-yaml
+    -   id: mixed-line-ending
+        args: ['--fix=lf']
+
+-   repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    -   id: pretty-format-ini
+        args: [--autofix]
+    -   id: pretty-format-toml
+        args: [--autofix]
+        additional_dependencies:
+         - toml-sort==0.21.0
+
+-   repo: https://github.com/pre-commit/pygrep-hooks
+    rev: v1.9.0  # Use the ref you want to point at
+    hooks:
+    -   id: python-check-blanket-noqa
+    # TODO: Add blanket type ignore check as well
+
+-   repo: https://github.com/timothycrosley/isort
+    rev: 5.11.5
+    hooks:
+    -   id: isort
+        exclude: docs/|examples/tutorials/(colabs|nb_python)/(.*\.py|.*\.ipynb)$
+        additional_dependencies: [toml]
+
+-   repo: https://github.com/ambv/black
+    rev: 23.1.0
+    hooks:
+    - id: black
+      exclude: ^examples/tutorials/(nb_python|colabs)
+
+-   repo: https://github.com/myint/autoflake
+    rev: v1.4
+    hooks:
+    -   id: autoflake
+        args: ['--expand-star-imports', '--ignore-init-module-imports', '--in-place']
+        exclude: docs/
+
+-   repo: https://github.com/PyCQA/flake8
+    rev: 4.0.1
+    hooks:
+    -   id: flake8
+        exclude: docs/
+        additional_dependencies:
+        - flake8-bugbear==22.4.25
+        - flake8-builtins==1.5.3
+        - flake8-comprehensions==3.8.0
+        - flake8-return==1.1.3
+        - flake8-simplify==0.18.2
+
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.991
+    hooks:
+    -   id: mypy
+        # https://github.com/python/mypy/issues/4008
+        exclude: "^docs/|setup.py$"
+        additional_dependencies:
+         - attrs>=19.1.0
+         - hydra-core>=1.2.0
+         - numpy>=1.20.0
+         - omegaconf>=2.2.3
+         - types-mock
+         - types-Pillow
+         - types-tqdm
+         - types-PyYAML
+
+-   repo: https://github.com/kynan/nbstripout
+    rev: 0.5.0
+    hooks:
+    -   id: nbstripout
+        files: ".ipynb"
+
+-   repo: https://github.com/mwouts/jupytext
+    rev: v1.13.8
+    hooks:
+    -   id: jupytext
+        files: '^examples/tutorials/(colabs|nb_python)/(.*\.py|.*\.ipynb)$'
+        args: [--update-metadata, '{"jupytext":{"notebook_metadata_filter":"all", "cell_metadata_filter":"-all"}, "accelerator":"GPU"}', --set-formats, 'nb_python//py:percent,colabs//ipynb,', --pipe, black, --pipe, 'isort - --treat-comment-as-code "# %%"', --pipe-fmt, 'py:percent', --sync]
+        additional_dependencies:
+            - 'nbformat<=5.0.8'
+            - black==23.1.0
+            - isort
+
+-   repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.8.0.4
+    hooks:
+    -   id: shellcheck
+
+-   repo: https://github.com/AleksaC/circleci-cli-py
+    rev: v0.1.17183
+    hooks:
+    -   id: circle-ci-validator

habitat-lab/CODE_OF_CONDUCT.md

@@ -0,0 +1,5 @@
+# Code of Conduct
+
+Facebook has adopted a Code of Conduct that we expect project participants to adhere to.
+Please read the [full text](https://code.fb.com/codeofconduct/)
+so that you can understand what actions will and will not be tolerated.

habitat-lab/CONTRIBUTING.md

@@ -0,0 +1,70 @@
+# Contributing to habitat-lab
+We want to make contributing to this project as easy and transparent as
+possible.
+
+
+
+## Notes on Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `main`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. If you haven't already, complete the Contributor License Agreement ("CLA").
+7. We have adopted squash-and-merge as the policy for incorporating PRs into the `main` branch.
+8. We would rather have several smaller pull requests that a single large Pull Request since smaller self-contained changes are easier to review.
+
+We accept these types of Pull Requests. Make sure your Pull Requests are not a mix of different types since they have different review processes.
+
+**Docs change** which adds to or changes the documentation
+
+**Refactoring** that changes  the code to improve its functionality or performance
+
+**Dependency Upgrade** of one or several dependencies in habitat
+
+**Bug Fix** which are non-breaking change which fixes an issue
+
+**Development Pull Requests** that add new features to the [habitat-lab](/habitat-lab) task and environment codebase. Development Pull Requests must be small, have unit testing, very extensive documentation and examples. These are typically new tasks, environments, sensors, etc... The review process for these Pull Request is longer because these changes will be maintained by our core team of developers, so make sure your changes are easy to understand!
+
+**Experiments Pull Requests** that add new features to the [habitat-baselines](/habitat-baselines/) training codebase. Experiments Pull Requests can be any size, must have smoke/integration tests and be isolated from the rest of the code. Your code additions should not rely on other habitat-baselines code. This is to avoid dependencies between different parts of habitat-baselines. You must also include a README that will document how to use your new feature or trainer. **You** will be the maintainer of this code, if the code becomes stale and is not supported often enough, we will eventually remove it.
+
+__Note:__ Pull Requests are not the only way to share your work with habitat. You can extend the functionality of Habitat in your own code base by importing and using the Habitat Sim, Habitat Lab, and Habitat Baselines API. If you have a cool project that uses this API, let us know and we might link to your work in our documentation! We encourage using the Habitat-Lab API in your codebase instead of forking the entirety of Habitat-Lab.
+
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use [GitHub issues](../../issues) to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+## Test
+We use pytest testing framework and testing data that needs to be downloaded, please make sure that test are passing:
+```
+python -m pytest
+```
+
+## Check typing
+We use mypy to check Python typing and guard API consistency, please make sure next command doesn't complain prior to submission:
+```
+mypy . --ignore-missing-imports
+```
+
+## Coding Style
+  - We follow PEP8 and use [typing](https://docs.python.org/3/library/typing.html).
+  - Use `black` for style enforcement and linting. Install black through `pip install black`.
+
+  We also use pre-commit hooks to ensure linting and style enforcement. Install the pre-commit hooks with `pip install pre-commit && pre-commit install`.
+
+## Documentation
+- Our documentation style is based on Magnum / Corrade and uses [a similar build system](https://mcss.mosra.cz/documentation/doxygen/).
+- Documentation of PRs is required!
+
+## License
+By contributing to habitat-lab, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.

habitat-lab/DATASETS.md

@@ -0,0 +1,36 @@
+To make things easier we expect `data` folder of particular structure or symlink presented in habitat-lab working directory.
+
+### Scenes datasets
+
+| Scenes models | Extract path | Archive size |
+| --- | --- | --- |
+| [Habitat test scenes](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#habitat-test-scenes) | `data/scene_datasets/habitat-test-scenes/{scene}.glb` | 89 MB |
+| 🆕[ReplicaCAD](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#replicacad) | `data/scene_datasets/replica_cad/configs/scenes/{scene}.scene_instance.json` | 123 MB |
+| 🆕[HM3D](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#habitat-matterport-3d-research-dataset-hm3d) | `data/scene_datasets/hm3d/{split}/00\d\d\d-{scene}/{scene}.basis.glb` | 130 GB |
+| [Gibson](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#gibson-and-3dscenegraph-datasets) | `data/scene_datasets/gibson/{scene}.glb` | 1.5 GB |
+| [MatterPort3D](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#matterport3d-mp3d-dataset) | `data/scene_datasets/mp3d/{scene}/{scene}.glb` | 15 GB |
+
+These datasets can be downloaded follow the instructions [here](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md).
+
+### Task datasets
+
+| Task | Scenes | Link | Extract path | Config to use                                                                                                          | Archive size |
+| --- | --- | --- | --- |------------------------------------------------------------------------------------------------------------------------| --- |
+| 🆕[Rearrange Pick](https://arxiv.org/abs/2106.14405) | ReplicaCAD | [rearrange_pick_replica_cad_v0.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/rearrange_pick/replica_cad/v0/rearrange_pick_replica_cad_v0.zip) | `data/datasets/rearrange_pick/replica_cad/v0/` | [`datasets/rearrangepick/replica_cad.yaml`](habitat-lab/habitat/config/habitat/dataset/rearrangement/replica_cad.yaml) | 11 MB |
+| [Point goal navigation](https://arxiv.org/abs/1807.06757) | Gibson | [pointnav_gibson_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/gibson/v1/pointnav_gibson_v1.zip) | `data/datasets/pointnav/gibson/v1/` | [`datasets/pointnav/gibson.yaml`](habitat-lab/habitat/config/habitat/dataset/pointnav/gibson.yaml)                                 | 385 MB |
+| 🆕[Point goal navigation](https://arxiv.org/abs/1807.06757) | Gibson 0+ (train) | [pointnav_gibson_0_plus_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/gibson/v1/pointnav_gibson_0_plus_v1.zip) | `data/datasets/pointnav/gibson/v1/` | [`datasets/pointnav/gibson_0_plus.yaml`](habitat-lab/habitat/config/habitat/dataset/pointnav/gibson_0_plus.yaml)                   | 321 MB |
+| [Point goal navigation corresponding to Sim2LoCoBot experiment configuration](https://arxiv.org/abs/1912.06321) | Gibson | [pointnav_gibson_v2.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/gibson/v2/pointnav_gibson_v2.zip) | `data/datasets/pointnav/gibson/v2/` | [`datasets/pointnav/gibson_v2.yaml`](habitat-lab/habitat/config/habitat/dataset/pointnav/gibson_v2.yaml)                           | 274 MB |
+| [Point goal navigation](https://arxiv.org/abs/1807.06757) | MatterPort3D | [pointnav_mp3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/mp3d/v1/pointnav_mp3d_v1.zip) | `data/datasets/pointnav/mp3d/v1/` | [`datasets/pointnav/mp3d.yaml`](habitat-lab/habitat/config/habitat/dataset/pointnav/mp3d.yaml)                                     | 400 MB |
+| 🆕[Point goal navigation](https://arxiv.org/abs/1807.06757) | HM3D | [pointnav_hm3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/hm3d/v1/pointnav_hm3d_v1.zip) | `data/datasets/pointnav/hm3d/v1/` | [`datasets/pointnav/hm3d.yaml`](habitat-lab/habitat/config/habitat/dataset/pointnav/hm3d.yaml)                                     | 992 MB |
+| [Object goal navigation](https://arxiv.org/abs/2006.13171) | MatterPort3D | [objectnav_mp3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/objectnav/m3d/v1/objectnav_mp3d_v1.zip) | `data/datasets/objectnav/mp3d/v1/` | [`datasets/objectnav/mp3d.yaml`](habitat-lab/habitat/config/habitat/dataset/objectnav/mp3d.yaml)                                   | 170 MB |
+| 🆕[Object goal navigation](https://arxiv.org/abs/2006.13171) | HM3DSem-v0.1 | [objectnav_hm3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/objectnav/hm3d/v1/objectnav_hm3d_v1.zip) | `data/datasets/objectnav/hm3d/v1/` | [`datasets/objectnav/hm3d.yaml`](habitat-lab/habitat/config/habitat/dataset/objectnav/hm3d.yaml)                                    | 154 MB |
+| 🆕[Object goal navigation](https://arxiv.org/abs/2006.13171) | HM3DSem-v0.2 | [objectnav_hm3d_v2.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/objectnav/hm3d/v2/objectnav_hm3d_v2.zip) | `data/datasets/objectnav/hm3d/v2/` | [`datasets/objectnav/hm3d_v2.yaml`](habitat-lab/habitat/config/habitat/dataset/objectnav/hm3d_v2.yaml)                                    | 245 MB |
+| [Embodied Question Answering](https://embodiedqa.org/) | MatterPort3D | [eqa_mp3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/eqa/mp3d/v1/eqa_mp3d_v1.zip) | `data/datasets/eqa/mp3d/v1/` | [`datasets/eqa/mp3d.yaml`](habitat-lab/habitat/config/habitat/dataset/eqa/mp3d.yaml)                                               | 44 MB |
+| [Visual Language Navigation](https://bringmeaspoon.org/) | MatterPort3D | [vln_r2r_mp3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/vln/mp3d/r2r/v1/vln_r2r_mp3d_v1.zip) | `data/datasets/vln/mp3d/r2r/v1` | [`datasets/vln/mp3d_r2r.yaml`](habitat-lab/habitat/config/habitat/dataset/vln/mp3d_r2r.yaml)                                       | 2.7 MB |
+| [Instance image goal navigation](https://arxiv.org/abs/2211.15876) | HM3DSem-v0.1 | [instance_imagenav_hm3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/imagenav/hm3d/v1/instance_imagenav_hm3d_v1.zip) | `data/datasets/instance_imagenav/hm3d/v1/` |  [`datasets/instance_imagenav/hm3d_v1.yaml`](habitat-lab/habitat/config/habitat/dataset/instance_imagenav/hm3d_v1.yaml) | 303 MB |
+| [Instance image goal navigation](https://arxiv.org/abs/2211.15876) | HM3DSem-v0.2 | [instance_imagenav_hm3d_v2.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/imagenav/hm3d/v2/instance_imagenav_hm3d_v2.zip) | `data/datasets/instance_imagenav/hm3d/v2/` |  [`datasets/instance_imagenav/hm3d_v2.yaml`](habitat-lab/habitat/config/habitat/dataset/instance_imagenav/hm3d_v2.yaml) | 518 MB |
+| 🆕 [Instance image goal navigation](https://arxiv.org/abs/2211.15876) | HM3DSem-v0.2 | [instance_imagenav_hm3d_v3.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/imagenav/hm3d/v3/instance_imagenav_hm3d_v3.zip) | `data/datasets/instance_imagenav/hm3d/v3/` |  [`datasets/instance_imagenav/hm3d_v3.yaml`](habitat-lab/habitat/config/habitat/dataset/instance_imagenav/hm3d_v3.yaml) | 517 MB |
+| [Image goal navigation](https://github.com/facebookresearch/habitat-lab/pull/333) | Gibson | [pointnav_gibson_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/gibson/v1/pointnav_gibson_v1.zip) | `data/datasets/pointnav/gibson/v1/` | [`datasets/imagenav/gibson.yaml`](habitat-lab/habitat/config/habitat/dataset/imagenav/gibson.yaml)                                 | 385 MB |
+| [Image goal navigation](https://github.com/facebookresearch/habitat-lab/pull/333) | MatterPort3D | [pointnav_mp3d_v1.zip](https://dl.fbaipublicfiles.com/habitat/data/datasets/pointnav/mp3d/v1/pointnav_mp3d_v1.zip) | `data/datasets/pointnav/mp3d/v1/` | [`datasets/imagenav/mp3d.yaml`](habitat-lab/habitat/config/habitat/dataset/imagenav/mp3d.yaml)                                     | 400 MB |
+
+To use an episode dataset, provide the related config to the Env in [the example](examples/example.py) or use the config for [RL agent training](habitat-baselines/habitat_baselines/README.md#reinforcement-learning-rl).

habitat-lab/DETAILS.md

@@ -0,0 +1,21 @@
+## Details
+An important objective of Habitat-Lab is to make it easy for users to set up a variety of embodied agent tasks in 3D environments. The process of setting up a task involves using environment information provided by the simulator, connecting the information with a dataset (e.g. PointGoal targets, or question and answer pairs for Embodied QA) and providing observations which can be used by the agents. Keeping this primary objective in mind the core API defines the following key concepts as abstractions that can be extended:
+
+* `Env`: the fundamental environment concept for Habitat. All the information needed for working on embodied tasks with a simulator is abstracted inside an Env. This class acts as a base for other derived environment classes. Env consists of three major components: a Simulator, a Dataset (containing Episodes), and a Task, and it serves to connects all these three components together.
+
+* `Dataset`: contains a list of task-specific episodes from a particular data split and additional dataset-wide information. Handles loading and saving of a dataset to disk, getting a list of scenes, and getting a list of episodes for a particular scene.
+
+* `Episode`: a class for episode specification that includes the initial position and orientation of an Agent, a scene id, a goal position and optionally shortest paths to the goal. An episode is a description of one task instance for the agent.
+
+<p align="center">
+  <img src='res/img/habitat_lab_structure.png' alt="teaser results" width="100%"/>
+  <p align="center"><i>Architecture of Habitat-Lab</i></p>
+</p>
+
+* `Task`: this class builds on top of the simulator and dataset. The criteria of episode termination and measures of success are provided by the Task.
+
+* `Sensor`: a generalization of the physical Sensor concept provided by a Simulator, with the capability to provide Task-specific Observation data in a specified format.
+
+* `Observation`: data representing an observation from a Sensor. This can correspond to physical sensors on an Agent (e.g. RGB, depth, semantic segmentation masks, collision sensors) or more abstract sensors such as the current agent state.
+
+Note that the core functionality defines fundamental building blocks such as the API for interacting with the simulator backend, and receiving observations through Sensors. Concrete simulation backends, 3D datasets, and embodied agent baselines are implemented on top of the core API.

habitat-lab/Dockerfile

@@ -0,0 +1,53 @@
+# Base image
+FROM nvidia/cudagl:10.1-devel-ubuntu16.04
+
+# Setup basic packages
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    curl \
+    vim \
+    ca-certificates \
+    libjpeg-dev \
+    libpng-dev \
+    libglfw3-dev \
+    libglm-dev \
+    libx11-dev \
+    libomp-dev \
+    libegl1-mesa-dev \
+    pkg-config \
+    wget \
+    zip \
+    unzip &&\
+    rm -rf /var/lib/apt/lists/*
+
+# Install conda
+RUN curl -L -o ~/miniconda.sh -O  https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh  &&\
+    chmod +x ~/miniconda.sh &&\
+    ~/miniconda.sh -b -p /opt/conda &&\
+    rm ~/miniconda.sh &&\
+    /opt/conda/bin/conda install numpy pyyaml scipy ipython mkl mkl-include &&\
+    /opt/conda/bin/conda clean -ya
+ENV PATH /opt/conda/bin:$PATH
+
+# Install cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.sh
+RUN mkdir /opt/cmake
+RUN sh /cmake-3.14.0-Linux-x86_64.sh --prefix=/opt/cmake --skip-license
+RUN ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake
+RUN cmake --version
+
+# Conda environment
+RUN conda create -n habitat python=3.9 cmake=3.14.0
+
+# Setup habitat-sim
+RUN git clone --branch stable https://github.com/facebookresearch/habitat-sim.git
+RUN /bin/bash -c ". activate habitat; cd habitat-sim; pip install -r requirements.txt; python setup.py install --headless"
+
+# Install challenge specific habitat-lab
+RUN git clone --branch stable https://github.com/facebookresearch/habitat-lab.git
+RUN /bin/bash -c ". activate habitat; cd habitat-lab; pip install -e habitat-lab/"
+
+# Silence habitat-sim logs
+ENV GLOG_minloglevel=2
+ENV MAGNUM_LOG="quiet"

habitat-lab/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

habitat-lab/README.md

@@ -0,0 +1,202 @@
+[![CircleCI](https://circleci.com/gh/facebookresearch/habitat-lab.svg?style=shield)](https://circleci.com/gh/facebookresearch/habitat-lab)
+[![codecov](https://codecov.io/gh/facebookresearch/habitat-lab/branch/main/graph/badge.svg)](https://codecov.io/gh/facebookresearch/habitat-lab)
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/facebookresearch/habitat-lab/blob/main/LICENSE)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/facebookresearch/habitat-lab)](https://github.com/facebookresearch/habitat-lab/releases/latest)
+[![Supports Habitat_Sim](https://img.shields.io/static/v1?label=supports&message=Habitat%20Sim&color=informational&link=https://github.com/facebookresearch/habitat-sim)](https://github.com/facebookresearch/habitat-sim)
+[![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390/)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://timothycrosley.github.io/isort/)
+[![Twitter Follow](https://img.shields.io/twitter/follow/ai_habitat?style=social)](https://twitter.com/ai_habitat)
+
+Habitat-Lab
+==============================
+
+Habitat-Lab is a modular high-level library for end-to-end development in embodied AI --
+defining embodied AI tasks (e.g. navigation, rearrangement, instruction following, question answering), configuring embodied agents (physical form, sensors, capabilities), training these agents (via imitation or reinforcement learning, or no learning at all as in SensePlanAct pipelines), and benchmarking their performance on the defined tasks using standard metrics.
+
+Habitat-Lab uses [`Habitat-Sim`](https://github.com/facebookresearch/habitat-sim) as the core simulator. For documentation refer [here](https://aihabitat.org/docs/habitat-lab/).
+
+[![Habitat Demo](https://img.shields.io/static/v1?label=WebGL&message=Try%20AI%20Habitat%20In%20Your%20Browser%20&color=blue&logo=webgl&labelColor=%23990000&style=for-the-badge&link=https://aihabitat.org/demo)](https://aihabitat.org/demo)
+<p align="center">
+  <img src="res/img/habitat_compressed.gif"  height="400">
+</p>
+
+---
+
+## Table of contents
+   1. [Citing Habitat](#citing-habitat)
+   1. [Installation](#installation)
+   1. [Testing](#testing)
+   1. [Documentation](#documentation)
+   1. [Docker Setup](#docker-setup)
+   1. [Datasets](#datasets)
+   1. [Baselines](#baselines)
+   1. [License](#license)
+
+
+## Citing Habitat
+If you use the Habitat platform in your research, please cite the [Habitat 1.0](https://arxiv.org/abs/1904.01201) and [Habitat 2.0](https://arxiv.org/abs/2106.14405) papers:
+
+```
+@inproceedings{szot2021habitat,
+  title     =     {Habitat 2.0: Training Home Assistants to Rearrange their Habitat},
+  author    =     {Andrew Szot and Alex Clegg and Eric Undersander and Erik Wijmans and Yili Zhao and John Turner and Noah Maestre and Mustafa Mukadam and Devendra Chaplot and Oleksandr Maksymets and Aaron Gokaslan and Vladimir Vondrus and Sameer Dharur and Franziska Meier and Wojciech Galuba and Angel Chang and Zsolt Kira and Vladlen Koltun and Jitendra Malik and Manolis Savva and Dhruv Batra},
+  booktitle =     {Advances in Neural Information Processing Systems (NeurIPS)},
+  year      =     {2021}
+}
+
+@inproceedings{habitat19iccv,
+  title     =     {Habitat: {A} {P}latform for {E}mbodied {AI} {R}esearch},
+  author    =     {Manolis Savva and Abhishek Kadian and Oleksandr Maksymets and Yili Zhao and Erik Wijmans and Bhavana Jain and Julian Straub and Jia Liu and Vladlen Koltun and Jitendra Malik and Devi Parikh and Dhruv Batra},
+  booktitle =     {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+  year      =     {2019}
+}
+```
+
+## Installation
+
+1. **Preparing conda env**
+
+   Assuming you have [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) installed, let's prepare a conda env:
+   ```bash
+   # We require python>=3.9 and cmake>=3.14
+   conda create -n habitat python=3.9 cmake=3.14.0
+   conda activate habitat
+   ```
+
+1. **conda install habitat-sim**
+   - To install habitat-sim with bullet physics
+      ```
+      conda install habitat-sim withbullet -c conda-forge -c aihabitat
+      ```
+      See Habitat-Sim's [installation instructions](https://github.com/facebookresearch/habitat-sim#installation) for more details.
+
+1. **pip install habitat-lab stable version**.
+
+      ```bash
+      git clone --branch stable https://github.com/facebookresearch/habitat-lab.git
+      cd habitat-lab
+      pip install -e habitat-lab  # install habitat_lab
+      ```
+1. **Install habitat-baselines**.
+
+    The command above will install only core of Habitat-Lab. To include habitat_baselines along with all additional requirements, use the command below after installing habitat-lab:
+
+      ```bash
+      pip install -e habitat-baselines  # install habitat_baselines
+      ```
+
+## Testing
+
+1. Let's download some 3D assets using Habitat-Sim's python data download utility:
+   - Download (testing) 3D scenes:
+      ```bash
+      python -m habitat_sim.utils.datasets_download --uids habitat_test_scenes --data-path data/
+      ```
+      Note that these testing scenes do not provide semantic annotations.
+
+   - Download point-goal navigation episodes for the test scenes:
+      ```bash
+      python -m habitat_sim.utils.datasets_download --uids habitat_test_pointnav_dataset --data-path data/
+      ```
+
+1. **Non-interactive testing**: Test the Pick task: Run the example pick task script
+    <!--- Please, update `examples/example.py` if you update example. -->
+    ```bash
+    python examples/example.py
+    ```
+
+    which uses [`habitat-lab/habitat/config/benchmark/rearrange/pick.yaml`](habitat-lab/habitat/config/benchmark/rearrange/pick.yaml) for configuration of task and agent. The script roughly does this:
+
+    ```python
+    import gym
+    import habitat.gym
+
+    # Load embodied AI task (RearrangePick) and a pre-specified virtual robot
+    env = gym.make("HabitatRenderPick-v0")
+    observations = env.reset()
+
+    terminal = False
+
+    # Step through environment with random actions
+    while not terminal:
+        observations, reward, terminal, info = env.step(env.action_space.sample())
+    ```
+
+    To modify some of the configurations of the environment, you can also use the `habitat.gym.make_gym_from_config` method that allows you to create a habitat environment using a configuration.
+
+    ```python
+    config = habitat.get_config(
+      "benchmark/rearrange/pick.yaml",
+      overrides=["habitat.environment.max_episode_steps=20"]
+    )
+    env = habitat.gym.make_gym_from_config(config)
+    ```
+
+    If you want to know more about what the different configuration keys overrides do, you can use [this reference](habitat-lab/habitat/config/CONFIG_KEYS.md).
+
+    See [`examples/register_new_sensors_and_measures.py`](examples/register_new_sensors_and_measures.py) for an example of how to extend habitat-lab from _outside_ the source code.
+
+
+
+1. **Interactive testing**: Using you keyboard and mouse to control a Fetch robot in a ReplicaCAD environment:
+    ```bash
+    # Pygame for interactive visualization, pybullet for inverse kinematics
+    pip install pygame==2.0.1 pybullet==3.0.4
+
+    # Interactive play script
+    python examples/interactive_play.py --never-end
+    ```
+
+   Use I/J/K/L keys to move the robot base forward/left/backward/right and W/A/S/D to move the arm end-effector forward/left/backward/right and E/Q to move the arm up/down. The arm can be difficult to control via end-effector control. More details in documentation. Try to move the base and the arm to touch the red bowl on the table. Have fun!
+
+   Note: Interactive testing currently fails on Ubuntu 20.04 with an error: `X Error of failed request:  BadAccess (attempt to access private resource denied)`. We are working on fixing this, and will update instructions once we have a fix. The script works without errors on MacOS.
+
+## Debugging an environment issue
+
+Our vectorized environments are very fast, but they are not very verbose. When using `VectorEnv` some errors may be silenced, resulting in process hanging or multiprocessing errors that are hard to interpret. We recommend setting the environment variable `HABITAT_ENV_DEBUG` to 1 when debugging (`export HABITAT_ENV_DEBUG=1`) as this will use the slower, but more verbose `ThreadedVectorEnv` class. Do not forget to reset `HABITAT_ENV_DEBUG` (`unset HABITAT_ENV_DEBUG`) when you are done debugging since `VectorEnv` is much faster than `ThreadedVectorEnv`.
+
+## Documentation
+
+Browse the online [Habitat-Lab documentation](https://aihabitat.org/docs/habitat-lab/index.html) and the extensive [tutorial on how to train your agents with Habitat](https://aihabitat.org/tutorial/2020/). For Habitat 2.0, use this [quickstart guide](https://aihabitat.org/docs/habitat2/).
+
+
+## Docker Setup
+We provide docker containers for Habitat, updated approximately once per year for the [Habitat Challenge](https://github.com/facebookresearch/habitat-challenge). This works on machines with an NVIDIA GPU and requires users to install [nvidia-docker](https://github.com/NVIDIA/nvidia-docker). To setup the habitat stack using docker follow the below steps:
+
+1. Pull the habitat docker image: `docker pull fairembodied/habitat-challenge:testing_2022_habitat_base_docker`
+
+1. Start an interactive bash session inside the habitat docker: `docker run --runtime=nvidia -it fairembodied/habitat-challenge:testing_2022_habitat_base_docker`
+
+1. Activate the habitat conda environment: `conda init; source ~/.bashrc; source activate habitat`
+
+1. Run the testing scripts as above: `cd habitat-lab; python examples/example.py`. This should print out an output like:
+    ```bash
+    Agent acting inside environment.
+    Episode finished after 200 steps.
+    ```
+
+### Questions?
+Can't find the answer to your question? Try asking the developers and community on our [Discussions forum](https://github.com/facebookresearch/habitat-lab/discussions).
+
+## Datasets
+
+[Common task and episode datasets used with Habitat-Lab](DATASETS.md).
+
+## Baselines
+Habitat-Lab includes reinforcement learning (via PPO) baselines. For running PPO training on sample data and more details refer [habitat_baselines/README.md](habitat-baselines/habitat_baselines/README.md).
+
+## ROS-X-Habitat
+ROS-X-Habitat (https://github.com/ericchen321/ros_x_habitat) is a framework that bridges the AI Habitat platform (Habitat Lab + Habitat Sim) with other robotics resources via ROS. Compared with Habitat-PyRobot, ROS-X-Habitat places emphasis on 1) leveraging Habitat Sim v2's physics-based simulation capability and 2) allowing roboticists to access simulation assets from ROS. The work has also been made public as a [paper](https://arxiv.org/abs/2109.07703).
+
+Note that ROS-X-Habitat was developed, and is maintained by the Lab for Computational Intelligence at UBC; it has not yet been officially supported by the Habitat Lab team. Please refer to the framework's repository for docs and discussions.
+
+
+## License
+Habitat-Lab is MIT licensed. See the [LICENSE file](/LICENSE) for details.
+
+The trained models and the task datasets are considered data derived from the correspondent scene datasets.
+
+- Matterport3D based task datasets and trained models are distributed with [Matterport3D Terms of Use](http://kaldir.vc.in.tum.de/matterport/MP_TOS.pdf) and under [CC BY-NC-SA 3.0 US license](https://creativecommons.org/licenses/by-nc-sa/3.0/us/).
+- Gibson based task datasets, the code for generating such datasets, and trained models are distributed with [Gibson Terms of Use](https://storage.googleapis.com/gibson_material/Agreement%20GDS%2006-04-18.pdf) and under [CC BY-NC-SA 3.0 US license](https://creativecommons.org/licenses/by-nc-sa/3.0/us/).

habitat-lab/docs/.gitignore

@@ -0,0 +1 @@
+m.math.cache

habitat-lab/docs/build-public.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Meta Platforms, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Propagate failures properly
+set -e
+
+mcss_path=../../habitat-sim/docs/m.css
+
+# Regenerate the compiled CSS file (yes, in the sim repository, to allow fast
+# iterations from here as well)
+$mcss_path/css/postprocess.py \
+  ../../habitat-sim/docs/theme.css \
+  $mcss_path/css/m-grid.css \
+  $mcss_path/css/m-components.css \
+  $mcss_path/css/m-layout.css \
+  ../../habitat-sim/docs/pygments-pastie.css \
+  $mcss_path/css/pygments-console.css \
+  $mcss_path/css/m-documentation.css \
+  -o ../../habitat-sim/docs/theme.compiled.css
+
+$mcss_path/documentation/python.py conf-public.py
+
+# The file:// URLs are usually clickable in the terminal, directly opening a
+# browser
+echo "------------------------------------------------------------------------"
+echo "Public docs were successfully generated to the following location. Note"
+echo "that the search functionality requires a web server in this case."
+echo
+echo "file://$(pwd)/../../habitat-sim/build/docs-public/habitat-lab/index.html"

habitat-lab/docs/build.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Meta Platforms, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Propagate failures properly
+set -e
+
+if [[ $# -eq 1 ]]; then
+  export mcss_path=$1
+elif [[ $# -ne 0 ]]; then
+  echo "usage: ./build.sh [path-to-m.css]"
+  exit 1
+else
+  if [ ! -d ../../habitat-sim/docs/m.css ]; then
+    echo "m.css submodule not found in the sim repository, please run git submodule update --init there or specify the path to it"
+    exit 1
+  fi
+  mcss_path=../../habitat-sim/docs/m.css
+fi
+
+# Regenerate the compiled CSS file (yes, in the sim repository, to allow fast
+# iterations from here as well)
+$mcss_path/css/postprocess.py \
+  ../../habitat-sim/docs/theme.css \
+  $mcss_path/css/m-grid.css \
+  $mcss_path/css/m-components.css \
+  $mcss_path/css/m-layout.css \
+  ../../habitat-sim/docs/pygments-pastie.css \
+  $mcss_path/css/pygments-console.css \
+  $mcss_path/css/m-documentation.css \
+  -o ../../habitat-sim/docs/theme.compiled.css
+
+$mcss_path/documentation/python.py conf.py
+
+# The file:// URLs are usually clickable in the terminal, directly opening a
+# browser
+echo "------------------------------------------------------------------------"
+echo "Docs were successfully generated. Open the following link to view them:"
+echo
+echo "file://$(pwd)/../../habitat-sim/build/docs/habitat-lab/index.html"

habitat-lab/docs/conf-public.py

@@ -0,0 +1,38 @@
+# Copyright (c) Meta Platforms, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.realpath(__file__)))
+
+# Inherit everything from the local config
+from conf import *  # isort:skip
+
+OUTPUT = "../../habitat-sim/build/docs-public/habitat-lab/"
+
+SEARCH_DOWNLOAD_BINARY = "searchdata-v1.bin"
+SEARCH_BASE_URL = "https://aihabitat.org/docs/habitat-lab/"
+SEARCH_EXTERNAL_URL = "https://google.com/search?q=site:aihabitat.org+{query}"
+
+M_SPHINX_INVENTORIES = [
+    (
+        "../../habitat-sim/docs/python.inv",
+        "https://docs.python.org/3/",
+        [],
+        ["m-doc-external"],
+    ),
+    (
+        "../../habitat-sim/docs/numpy.inv",
+        "https://docs.scipy.org/doc/numpy/",
+        [],
+        ["m-doc-external"],
+    ),
+    (
+        "../../habitat-sim/build/docs-public/habitat-sim/objects.inv",
+        "../habitat-sim/",
+        [],
+        ["m-doc-external"],
+    ),
+]

habitat-lab/docs/conf.py

@@ -0,0 +1,127 @@
+# Copyright (c) Meta Platforms, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+import sys
+
+# TODO make this less brittle
+sys.path = [os.path.join(os.path.dirname(__file__), "../")] + sys.path
+
+import habitat  # isort:skip
+
+import gym  # isort:skip
+import typing  # isort:skip
+
+# Override the typing annotation of _np_random of gym.Env since the type provided is
+# "RandomNumberGenerator | None" and the "|" symbol for typing is not valid in Python <3.10
+# Remove when upgrading to Python 3.10
+gym.Env.__annotations__["_np_random"] = typing.Optional[
+    gym.utils.seeding.RandomNumberGenerator
+]
+
+
+# Overrides the __all__ as that one pulls everything into the root module
+# and doesn't expose any submodules
+habitat.__all__ = ["config", "core", "Agent", "Benchmark", "gym"]
+habitat.core.__all__ = [
+    "env",
+    "embodied_task",
+    "dataset",
+    "simulator",
+    "registry",
+    "vector_env",
+]
+
+PROJECT_TITLE = "Habitat"
+PROJECT_SUBTITLE = "Lab Docs"
+PROJECT_LOGO = "../../habitat-sim/docs/habitat.svg"
+FAVICON = "../../habitat-sim/docs/habitat-blue.png"
+MAIN_PROJECT_URL = "/"
+INPUT_MODULES = [habitat]
+INPUT_DOCS = ["docs.rst"]
+INPUT_PAGES = [
+    "pages/index.rst",
+    "pages/quickstart.rst",
+    "pages/habitat-lab-demo.rst",
+    "pages/habitat-lab-tdmap-viz.rst",
+    "pages/habitat2.rst",
+    "pages/view-transform-warp.rst",
+]
+
+PLUGINS = [
+    "m.abbr",
+    "m.code",
+    "m.components",
+    "m.dox",
+    "m.gh",
+    "m.htmlsanity",
+    "m.images",
+    "m.link",
+    "m.math",
+    "m.sphinx",
+]
+
+CLASS_INDEX_EXPAND_LEVELS = 2
+
+PYBIND11_COMPATIBILITY = True
+ATTRS_COMPATIBILITY = True
+
+# Putting output into the sim repository so relative linking works the same
+# way as on the website
+OUTPUT = "../../habitat-sim/build/docs/habitat-lab/"
+
+LINKS_NAVBAR1 = [
+    (
+        "Pages",
+        "pages",
+        [
+            ("Quickstart", "quickstart"),
+            ("Habitat Lab Demo", "habitat-lab-demo"),
+            ("Habitat Lab TopdownMap Visualization", "habitat-lab-tdmap-viz"),
+            ("Habitat 2.0 Overview", "habitat2"),
+            ("View, Transform and Warp", "view-transform-warp"),
+        ],
+    ),
+    ("Classes", "classes", []),
+]
+LINKS_NAVBAR2 = [
+    ("Sim Docs", "../habitat-sim/index.html", []),
+]
+
+FINE_PRINT = f"""
+| {PROJECT_TITLE} {PROJECT_SUBTITLE}. Copyright © 2021 Facebook AI Research.
+| `Terms of Use </terms-of-use>`_ `Data Policy </data-policy>`_ `Cookie Policy </cookie-policy>`_
+| Created with `m.css Python doc generator <https://mcss.mosra.cz/documentation/python/>`_."""
+
+STYLESHEETS = [
+    "https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600",
+    "../../habitat-sim/docs/theme.compiled.css",
+]
+
+M_SPHINX_INVENTORIES = [
+    (
+        "../../habitat-sim/docs/python.inv",
+        "https://docs.python.org/3/",
+        [],
+        ["m-doc-external"],
+    ),
+    (
+        "../../habitat-sim/docs/numpy.inv",
+        "https://docs.scipy.org/doc/numpy/",
+        [],
+        ["m-doc-external"],
+    ),
+    (
+        "../../habitat-sim/build/docs/habitat-sim/objects.inv",
+        "../habitat-sim/",
+        [],
+        ["m-doc-external"],
+    ),
+]
+M_SPHINX_INVENTORY_OUTPUT = "objects.inv"
+M_SPHINX_PARSE_DOCSTRINGS = True
+
+M_HTMLSANITY_SMART_QUOTES = True
+# Will people hate me if I enable this?
+# M_HTMLSANITY_HYPHENATION = True

habitat-lab/docs/docs.rst

@@ -0,0 +1,15 @@
+..
+    Stuff defined here gets set globally for everything else:
+
+    -   use :py:`code` for inline code with highlighted Python syntax
+..
+
+.. role:: py(code)
+    :language: py
+
+.. due to current limitations in m.css, all underscored members have to be
+    listed here in order to be visible, it's not enough to list them in a class
+    / module docstring. All underscored members are otherwise treated as
+    private and not exposed in the docs
+
+.. py:data:: habitat.core.embodied_task.Measure._metric