Upload H20 Qwen3.5 DriveLM code package

.env.example

@@ -0,0 +1,16 @@
+# Local company-server paths. Copy this file to .env only on the server.
+DATA_DIR=/data/vla_drive/data/drive_lm
+STUDENT_MODEL=/data/models/Qwen3.5-4B
+TEACHER_MODEL=/data/models/Qwen3.5-9B
+
+# Training outputs stay on the company server and are ignored by git/HF upload.
+OUTPUT_ROOT=outputs
+STUDENT_ADAPTER=outputs/student_sft/final_adapter
+TEACHER_ADAPTER=outputs/teacher_sft/final_adapter
+
+# Runtime defaults.
+HF_HUB_OFFLINE=1
+TRANSFORMERS_OFFLINE=1
+TOKENIZERS_PARALLELISM=false
+WANDB_MODE=offline
+

.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.venv/
+venv/
+.env
+
+# Never upload company data, model weights, checkpoints, or logs.
+data/
+models/
+outputs/
+logs/
+checkpoints/
+wandb/
+*.safetensors
+*.bin
+*.pt
+*.pth
+*.ckpt
+*.log
+

README.md

@@ -0,0 +1,229 @@
+---
+library_name: transformers
+tags:
+- qwen3.5
+- vision-language-model
+- drivelm
+- lora
+- online-distillation
+- rlhf
+---
+
+# Qwen3.5 DriveLM：H20 × 4 迁移运行包
+
+这是一个**只包含代码与配置**的独立迁移目录。它的用途是：在本地整理好后上传到私有 Hugging Face 仓库，再从公司的 H20 × 4 服务器拉取运行。默认使用公司服务器上已有的：
+
+- Student：`/data/models/Qwen3.5-4B`
+- Teacher：`/data/models/Qwen3.5-9B`
+- Student SFT：GPU 0、1、2、3
+- 在线 OPD：GPU 0 放 Teacher，GPU 1、2、3 运行 Student DDP
+
+模型、数据集、LoRA adapter、checkpoint、日志和 `.env` 都被排除在上传目录之外。**只有公司明确允许外传时才上传；必须使用私有仓库。**
+
+## 1. 上传这个目录
+
+推荐在本地直接上传整个 `h20_qwen35_drivelm` 文件夹。也可以安装并登录 Hugging Face CLI 后执行：
+
+```bash
+cd h20_qwen35_drivelm
+hf auth login
+bash scripts/06_upload_private_hf.sh YOUR_ACCOUNT/qwen35-drivelm-h20
+```
+
+上传脚本会拒绝包含 `.env` 或权重文件的目录。当前用户仓库是 Dataset 类型的 `huohuo0345/0716`，Windows PowerShell 可直接执行：
+
+```powershell
+py -m pip install -U huggingface_hub
+hf auth login
+Set-Location F:\VLA-Drive\h20_qwen35_drivelm
+.\scripts\06_upload_hf_dataset.ps1
+```
+
+脚本会先把仓库设置为 Private，再把本目录内容上传到仓库根目录。
+
+## 2. 公司服务器拉取与安装
+
+```bash
+cd /data/your_workspace
+hf download YOUR_ACCOUNT/qwen35-drivelm-h20 \
+  --repo-type model --local-dir h20_qwen35_drivelm
+cd h20_qwen35_drivelm
+
+# Python 3.12 可以直接使用。创建独立环境，不覆盖公司公共 Python。
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip
+
+# 优先使用公司已经验证过的内部 PyPI/torch wheel。
+# 没有内部环境时，可使用提供的 H20/CUDA 12.8 基线：
+python -m pip install torch==2.11.0 torchvision==0.26.0 \
+  --index-url https://download.pytorch.org/whl/cu128
+python -m pip install -r requirements-h20-py312.txt
+
+cp .env.example .env
+vim .env
+```
+
+必须修改 `.env` 中的 `DATA_DIR`。两个模型路径若和默认值一致则不用改。服务器无法联网时，默认的 `HF_HUB_OFFLINE=1` 和 `TRANSFORMERS_OFFLINE=1` 会确保只读取本地模型。
+
+Qwen3.5 必须使用能够导入 `AutoModelForMultimodalLM` 的较新 Transformers。若公司的稳定环境版本较旧，请另建环境，不要直接破坏公共环境。
+
+## 3. 数据格式
+
+`DATA_DIR` 下应有 `train.json` 和 `val.json`，每个文件是展平后的 JSON 数组：
+
+```json
+[
+  {
+    "scene_id": "scene-001",
+    "frame_token": "frame-001",
+    "task_type": "perception",
+    "question": "What is directly ahead of the ego vehicle?",
+    "answer": "A stopped vehicle is directly ahead.",
+    "image_paths": {
+      "CAM_FRONT": "/data/datasets/nuscenes/samples/CAM_FRONT/a.jpg",
+      "CAM_FRONT_LEFT": "/data/datasets/nuscenes/samples/CAM_FRONT_LEFT/b.jpg",
+      "CAM_FRONT_RIGHT": "/data/datasets/nuscenes/samples/CAM_FRONT_RIGHT/c.jpg",
+      "CAM_BACK": "/data/datasets/nuscenes/samples/CAM_BACK/d.jpg",
+      "CAM_BACK_LEFT": "/data/datasets/nuscenes/samples/CAM_BACK_LEFT/e.jpg",
+      "CAM_BACK_RIGHT": "/data/datasets/nuscenes/samples/CAM_BACK_RIGHT/f.jpg"
+    }
+  }
+]
+```
+
+图片路径必须是**公司服务器上的真实路径**，不能保留 Windows 的 `F:\...`。如手上是 DriveLM 原始 `v1_0_train_nus.json`，可在服务器转换：
+
+```bash
+python tools/convert_drivelm.py \
+  --json /data/datasets/drivelm/v1_0_train_nus.json \
+  --images-root /data/datasets/drivelm \
+  --output-dir /data/vla_drive/data/drive_lm
+```
+
+转换脚本按 scene 划分训练集和验证集，避免同一 scene 泄漏到两边。
+
+## 4. 严格按顺序跑
+
+### 4.1 数据审计
+
+```bash
+bash scripts/00_data_audit.sh
+```
+
+它会检查问题/答案是否为空、六路相机字段是否齐全、图片文件是否真实存在。出现错误时不要继续训练。
+
+### 4.2 模型与样本预检
+
+```bash
+bash scripts/01_preflight.sh
+```
+
+它会实际加载 Qwen3.5-4B 和一张图片，执行一次前向，确认：模型是 VLM、processor 能读取本地图片、chat template 可用、CUDA/BF16 正常。
+
+先做一个短 smoke run：
+
+```bash
+SFT_MAX_STEPS=5 SFT_GRAD_ACC=1 bash scripts/02_sft_student.sh
+```
+
+短跑无误后，删除或更换 smoke 输出目录，再开始正式 SFT：
+
+```bash
+bash scripts/02_sft_student.sh
+```
+
+在裸模型和 SFT adapter 上分别运行验证集推理，保留可复现基线。脚本在 adapter 不存在时自动评测裸模型，存在时自动加载 adapter：
+
+```bash
+EVAL_MAX_SAMPLES=100 bash scripts/02b_eval_student.sh
+```
+
+输出包括逐样本预测、Exact Match 和简单 token-F1。它们适合做工程回归检查，但不能替代 DriveLM 官方指标或人工驾驶安全评测。
+
+默认 Student SFT 只使用 `CAM_FRONT`，��是为了先建立可靠基线。有效 batch size 为 `4 × 1 × SFT_GRAD_ACC`。若单视图稳定后需要六视图：
+
+```bash
+STUDENT_SFT_VIEWS=6 SFT_MAX_LENGTH=4096 SFT_GRAD_ACC=4 \
+  bash scripts/02_sft_student.sh
+```
+
+显存不足时依次降低：视图数、`SFT_MAX_LENGTH`、LoRA rank（需修改脚本参数）；不要把每卡 batch size 从 1 调大。
+
+### 4.3 可选：领域微调 Teacher
+
+裸 9B Teacher 不一定熟悉 DriveLM 的回答格式。可先用六视图数据做一次 LoRA SFT：
+
+```bash
+TEACHER_SFT_MAX_STEPS=5 bash scripts/03_sft_teacher_optional.sh  # smoke
+bash scripts/03_sft_teacher_optional.sh                         # 正式
+```
+
+若跳过这一步，Teacher server 会直接使用 `/data/models/Qwen3.5-9B`。
+
+### 4.4 在线 OPD
+
+终端 A：
+
+```bash
+bash scripts/04_teacher_server.sh
+```
+
+看到包含 `"ok": true` 的健康信息后，在终端 B 先短跑：
+
+```bash
+OPD_MAX_STEPS=5 OPD_GRAD_ACC=1 bash scripts/05_online_opd.sh
+```
+
+确认 loss、advantage、response token 数均正常，再正式运行：
+
+```bash
+bash scripts/05_online_opd.sh
+```
+
+在线 OPD 的每个 step 是：Student 根据当前参数在线采样回答；Teacher 对**完全相同的回答 token**打分；Teacher 只返回这些 token 的 log-prob，不传 `[序列长度, 词表大小]` 的完整 logits；Student 用带截断 advantage 的 sampled-token loss 更新，同时加入少量 ground-truth SFT anchor 防止漂移。
+
+Teacher 与 Student 必须使用完全一致的 tokenizer。启动时会计算完整 token-id 映射的 SHA-256，不一致会立即退出。Teacher server 默认只监听 `127.0.0.1`，不会暴露到公司网络。
+
+## 5. 推荐实验顺序
+
+不要第一次就跑“大而全”：
+
+1. 1 张图、4B Student、5 step SFT，确认链路。
+2. 1 张图、4B Student 正式 SFT，保存可复现实验指标。
+3. 六视图 Student SFT，与单视图做消融。
+4. 对 9B Teacher 做六视图领域 SFT，并验证它确实优于 Student。
+5. 在线 OPD 先跑 5/20/100 step，检查回答质量与 KL/advantage 变化。
+6. 再比较 `SFT anchor=0/0.05/0.1`、Teacher 裸模型/领域 LoRA、不同采样温度。
+
+OPD 不是完整意义上的人类偏好 RLHF：它属于在线策略蒸馏。若要在简历中写“RLHF 全流程”，还应另外构建偏好对、训练 reward model，随后实现 DPO/GRPO/PPO 中至少一种，并提供安全性和任务指标评测；不要把 OPD 单独包装成完整 RLHF。
+
+## 6. 目录说明
+
+```text
+configs/                 DeepSpeed ZeRO-2 配置（SFT 显存紧张时可启用）
+scripts/                 H20×4 一键运行及私有 HF 上传脚本
+src/common.py            Qwen3.5 多模态消息、相机顺序、tokenizer 校验
+src/data.py              数据集与严格 assistant-only loss mask
+src/modeling.py          Qwen3.5 VLM、LoRA、视觉塔冻结
+src/train_sft.py         四卡 LoRA SFT
+src/evaluate.py          验证集生成、Exact Match、token-F1
+src/teacher_server.py    GPU0 Teacher sampled-token 打分服务
+src/train_online_opd.py  GPU1–3 Student 在线 OPD
+tools/convert_drivelm.py DriveLM 原始标注转换
+tests/                   与 token 对齐/梯度相关的单元测试
+```
+
+## 7. 当前边界
+
+- 本目录在本地可做语法和 CPU 单元测试，但真正的 Qwen3.5 多模态前向必须在公司 H20 环境预检。
+- 公司模型可能是内部修改版。若 `config.json`、processor 或层名偏离官方 Qwen3.5，预检/LoRA target discovery 会明确失败，不会静默训练错误模块。
+- 第一版 Teacher HTTP 服务为单 GPU 串行推理，优先保证正确性。三路 Student 会排队等待 GPU0；跑通后再考虑 vLLM/SGLang continuous batching。
+- `configs/ds_zero2.json` 是可选项。默认 LoRA SFT 用 DDP；需要 ZeRO-2 时给 `src.train_sft` 增加 `--deepspeed configs/ds_zero2.json`。
+
+运行测试：
+
+```bash
+pytest -q
+python -m compileall -q src tools
+```

configs/ds_zero2.json

@@ -0,0 +1,20 @@
+{
+  "bf16": {
+    "enabled": true
+  },
+  "zero_optimization": {
+    "stage": 2,
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "reduce_scatter": true,
+    "allgather_partitions": true,
+    "reduce_bucket_size": 50000000,
+    "allgather_bucket_size": 50000000
+  },
+  "gradient_accumulation_steps": "auto",
+  "train_micro_batch_size_per_gpu": "auto",
+  "train_batch_size": "auto",
+  "steps_per_print": 20,
+  "wall_clock_breakdown": false
+}
+

data_schema.example.json

@@ -0,0 +1,18 @@
+[
+  {
+    "scene_id": "example_scene",
+    "frame_token": "example_frame",
+    "task_type": "perception",
+    "question": "What is the state of the traffic light ahead?",
+    "answer": "The traffic light ahead is red.",
+    "image_paths": {
+      "CAM_FRONT": "/data/datasets/nuscenes/samples/CAM_FRONT/example.jpg",
+      "CAM_FRONT_LEFT": "/data/datasets/nuscenes/samples/CAM_FRONT_LEFT/example.jpg",
+      "CAM_FRONT_RIGHT": "/data/datasets/nuscenes/samples/CAM_FRONT_RIGHT/example.jpg",
+      "CAM_BACK": "/data/datasets/nuscenes/samples/CAM_BACK/example.jpg",
+      "CAM_BACK_LEFT": "/data/datasets/nuscenes/samples/CAM_BACK_LEFT/example.jpg",
+      "CAM_BACK_RIGHT": "/data/datasets/nuscenes/samples/CAM_BACK_RIGHT/example.jpg"
+    }
+  }
+]
+

requirements-h20-py312.txt

@@ -0,0 +1,17 @@
+# Python 3.12 dependencies for NVIDIA H20/Hopper.
+# Install the CUDA-enabled PyTorch wheel separately first (see README), or use
+# the company's approved torch wheel/mirror. Keeping torch out of this file
+# prevents pip from accidentally selecting a CPU build from another index.
+
+transformers>=5.0
+accelerate>=1.2
+peft>=0.15
+deepspeed>=0.16
+safetensors>=0.5
+pillow>=10.0
+pyyaml>=6.0
+numpy>=1.26
+huggingface_hub>=0.30
+tensorboard>=2.18
+wandb>=0.19
+pytest>=8.0

requirements.txt

@@ -0,0 +1,18 @@
+# Qwen3.5 currently requires a Transformers build that exposes
+# AutoModelForMultimodalLM. Prefer the company's validated wheel/mirror.
+torch>=2.6
+torchvision>=0.21
+transformers>=5.0
+accelerate>=1.2
+peft>=0.15
+deepspeed>=0.16
+safetensors>=0.5
+pillow>=10.0
+pyyaml>=6.0
+numpy>=1.26
+huggingface_hub>=0.30
+
+# Optional experiment tracking.
+tensorboard>=2.18
+wandb>=0.19
+pytest>=8.0

scripts/00_data_audit.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+python -m src.data_audit \
+  --data-dir "$DATA_DIR" \
+  --splits train val \
+  --num-views "${NUM_VIEWS:-6}"

scripts/01_preflight.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+CUDA_VISIBLE_DEVICES="${PREFLIGHT_GPU:-0}" python -m src.preflight \
+  --model "$STUDENT_MODEL" \
+  --data-dir "$DATA_DIR" \
+  --split train \
+  --num-views "${NUM_VIEWS:-1}" \
+  --max-length "${MAX_LENGTH:-2048}" \
+  --load-model

scripts/02_sft_student.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+CUDA_VISIBLE_DEVICES="${SFT_GPUS:-0,1,2,3}" torchrun \
+  --standalone --nproc_per_node="${SFT_NPROC:-4}" \
+  -m src.train_sft \
+  --model "$STUDENT_MODEL" \
+  --data-dir "$DATA_DIR" \
+  --output-dir "$OUTPUT_ROOT/student_sft" \
+  --num-views "${STUDENT_SFT_VIEWS:-1}" \
+  --max-length "${SFT_MAX_LENGTH:-2048}" \
+  --max-steps "${SFT_MAX_STEPS:-1000}" \
+  --gradient-accumulation-steps "${SFT_GRAD_ACC:-8}" \
+  --learning-rate "${SFT_LR:-2e-4}"

scripts/02b_eval_student.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+adapter_args=()
+if [[ -f "$STUDENT_ADAPTER/adapter_config.json" ]]; then
+  adapter_args=(--adapter-path "$STUDENT_ADAPTER")
+fi
+
+CUDA_VISIBLE_DEVICES="${EVAL_GPU:-0}" python -m src.evaluate \
+  --model "$STUDENT_MODEL" \
+  "${adapter_args[@]}" \
+  --data-dir "$DATA_DIR" \
+  --output "$OUTPUT_ROOT/eval/student_predictions.jsonl" \
+  --num-views "${EVAL_VIEWS:-1}" \
+  --max-samples "${EVAL_MAX_SAMPLES:-500}"

scripts/03_sft_teacher_optional.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+# Optional: align the 9B teacher to the same driving QA domain before OPD.
+CUDA_VISIBLE_DEVICES="${SFT_GPUS:-0,1,2,3}" torchrun \
+  --standalone --nproc_per_node="${SFT_NPROC:-4}" \
+  -m src.train_sft \
+  --model "$TEACHER_MODEL" \
+  --data-dir "$DATA_DIR" \
+  --output-dir "$OUTPUT_ROOT/teacher_sft" \
+  --num-views "${TEACHER_SFT_VIEWS:-6}" \
+  --max-length "${TEACHER_MAX_LENGTH:-4096}" \
+  --max-steps "${TEACHER_SFT_MAX_STEPS:-500}" \
+  --gradient-accumulation-steps "${TEACHER_SFT_GRAD_ACC:-8}" \
+  --learning-rate "${TEACHER_SFT_LR:-1e-4}"

scripts/04_teacher_server.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+adapter_args=()
+if [[ -f "$TEACHER_ADAPTER/adapter_config.json" ]]; then
+  adapter_args=(--adapter-path "$TEACHER_ADAPTER")
+fi
+
+CUDA_VISIBLE_DEVICES="${TEACHER_GPU:-0}" python -m src.teacher_server \
+  --model "$TEACHER_MODEL" \
+  "${adapter_args[@]}" \
+  --host "${TEACHER_HOST:-127.0.0.1}" \
+  --port "${TEACHER_PORT:-18080}" \
+  --num-views "${OPD_VIEWS:-6}" \
+  --max-length "${OPD_MAX_LENGTH:-4096}"

scripts/05_online_opd.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+source "$(dirname "$0")/_env.sh"
+
+if [[ ! -f "$STUDENT_ADAPTER/adapter_config.json" ]]; then
+  echo "Student adapter not found: $STUDENT_ADAPTER" >&2
+  echo "Run scripts/02_sft_student.sh first." >&2
+  exit 1
+fi
+
+CUDA_VISIBLE_DEVICES="${STUDENT_GPUS:-1,2,3}" torchrun \
+  --standalone --nproc_per_node="${STUDENT_NPROC:-3}" \
+  -m src.train_online_opd \
+  --model "$STUDENT_MODEL" \
+  --adapter-path "$STUDENT_ADAPTER" \
+  --data-dir "$DATA_DIR" \
+  --output-dir "$OUTPUT_ROOT/online_opd" \
+  --teacher-url "http://${TEACHER_HOST:-127.0.0.1}:${TEACHER_PORT:-18080}" \
+  --num-views "${OPD_VIEWS:-6}" \
+  --max-length "${OPD_MAX_LENGTH:-4096}" \
+  --max-new-tokens "${OPD_MAX_NEW_TOKENS:-128}" \
+  --max-steps "${OPD_MAX_STEPS:-300}" \
+  --gradient-accumulation-steps "${OPD_GRAD_ACC:-8}" \
+  --learning-rate "${OPD_LR:-5e-6}" \
+  --sft-anchor-coef "${SFT_ANCHOR_COEF:-0.1}"

scripts/06_upload_hf_dataset.ps1

@@ -0,0 +1,31 @@
+param(
+    [string]$RepoId = "huohuo0345/0716"
+)
+
+$ErrorActionPreference = "Stop"
+$RootDir = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+Set-Location $RootDir
+
+if (Test-Path -LiteralPath ".env") {
+    throw "Refusing upload: .env exists. Move it outside this folder first."
+}
+$weights = Get-ChildItem -Recurse -File | Where-Object {
+    $_.Extension -in ".safetensors", ".bin", ".pt", ".pth", ".ckpt"
+}
+if ($weights) {
+    throw "Refusing upload: model/checkpoint files exist in the transfer folder."
+}
+if (-not (Get-Command hf -ErrorAction SilentlyContinue)) {
+    throw "hf command not found. Run: py -m pip install -U huggingface_hub"
+}
+
+hf repos settings $RepoId --repo-type dataset --private
+if ($LASTEXITCODE -ne 0) {
+    throw "Could not make the dataset repository private. Stop before uploading."
+}
+hf upload $RepoId . . --repo-type dataset `
+    --commit-message "Upload H20 Qwen3.5 DriveLM code package"
+if ($LASTEXITCODE -ne 0) {
+    throw "Hugging Face upload failed with exit code $LASTEXITCODE"
+}
+Write-Host "Uploaded code-only package to private dataset repo: $RepoId"

scripts/06_upload_private_hf.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -ne 1 ]]; then
+  echo "Usage: bash scripts/06_upload_private_hf.sh YOUR_ACCOUNT/REPO_NAME" >&2
+  exit 2
+fi
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+REPO_ID="$1"
+
+if [[ -f .env ]]; then
+  echo "Refusing upload while .env exists. Move it out temporarily; it may contain paths/secrets." >&2
+  exit 1
+fi
+if find . -type f \( -name '*.safetensors' -o -name '*.bin' -o -name '*.pt' -o -name '*.pth' \) -print -quit | grep -q .; then
+  echo "Refusing upload: weight/checkpoint files exist inside the transfer folder." >&2
+  exit 1
+fi
+
+hf repo create "$REPO_ID" --repo-type model --private --exist-ok
+hf upload "$REPO_ID" . . --repo-type model
+echo "Uploaded code-only package to private repo: $REPO_ID"

scripts/_env.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+if [[ -f .env ]]; then
+  set -a
+  source .env
+  set +a
+fi
+
+: "${DATA_DIR:=/data/vla_drive/data/drive_lm}"
+: "${STUDENT_MODEL:=/data/models/Qwen3.5-4B}"
+: "${TEACHER_MODEL:=/data/models/Qwen3.5-9B}"
+: "${OUTPUT_ROOT:=$ROOT_DIR/outputs}"
+: "${STUDENT_ADAPTER:=$OUTPUT_ROOT/student_sft/final_adapter}"
+: "${TEACHER_ADAPTER:=$OUTPUT_ROOT/teacher_sft/final_adapter}"
+
+export PYTHONPATH="$ROOT_DIR${PYTHONPATH:+:$PYTHONPATH}"
+export HF_HUB_OFFLINE="${HF_HUB_OFFLINE:-1}"
+export TRANSFORMERS_OFFLINE="${TRANSFORMERS_OFFLINE:-1}"
+export TOKENIZERS_PARALLELISM="${TOKENIZERS_PARALLELISM:-false}"
+export WANDB_MODE="${WANDB_MODE:-offline}"
+mkdir -p "$OUTPUT_ROOT"

src/__init__.py

@@ -0,0 +1,2 @@
+"""Qwen3.5 DriveLM SFT and sampled-token online OPD package."""
+

src/common.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Sequence
+
+import torch
+
+
+CAMERA_ORDER = [
+    "CAM_FRONT",
+    "CAM_FRONT_LEFT",
+    "CAM_FRONT_RIGHT",
+    "CAM_BACK",
+    "CAM_BACK_LEFT",
+    "CAM_BACK_RIGHT",
+]
+
+SYSTEM_PROMPT = (
+    "You are an expert autonomous-driving assistant. Analyze the camera "
+    "views carefully and answer the driving-scene question accurately, "
+    "safely, and concisely. Do not invent objects that are not visible."
+)
+
+
+def camera_names(num_views: int) -> List[str]:
+    if not 1 <= num_views <= len(CAMERA_ORDER):
+        raise ValueError(f"num_views must be in [1, 6], got {num_views}")
+    return CAMERA_ORDER[:num_views]
+
+
+def load_rows(data_dir: str, split: str) -> List[Dict[str, Any]]:
+    root = Path(data_dir)
+    candidates = [
+        root / f"{split}.json",
+        root / f"drivelm_{split}.json",
+        root / f"{split}.jsonl",
+    ]
+    path = next((item for item in candidates if item.is_file()), None)
+    if path is None:
+        raise FileNotFoundError(
+            f"No {split} JSON/JSONL file under {root}. Expected one of: "
+            + ", ".join(str(item) for item in candidates)
+        )
+    if path.suffix == ".jsonl":
+        rows = []
+        with path.open("r", encoding="utf-8") as handle:
+            for line_no, line in enumerate(handle, 1):
+                if line.strip():
+                    row = json.loads(line)
+                    if not isinstance(row, dict):
+                        raise TypeError(f"{path}:{line_no} is not an object")
+                    rows.append(row)
+        return rows
+    with path.open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if not isinstance(payload, list):
+        raise TypeError(
+            f"{path} must be a list of flattened QA rows. Convert raw DriveLM first."
+        )
+    return payload
+
+
+def normalized_row(row: Dict[str, Any]) -> Dict[str, Any]:
+    question = str(row.get("question", row.get("query", ""))).strip()
+    answer = str(row.get("answer", row.get("response", ""))).strip()
+    image_paths = row.get("image_paths") or {}
+    if not isinstance(image_paths, dict):
+        raise TypeError("image_paths must be an object keyed by camera name")
+    return {
+        "scene_id": str(row.get("scene_id", "")),
+        "frame_token": str(row.get("frame_token", "")),
+        "task_type": str(row.get("task_type", row.get("category", "unknown"))),
+        "question": question,
+        "answer": answer,
+        "image_paths": {str(key): str(value) for key, value in image_paths.items()},
+    }
+
+
+def validate_image_paths(
+    image_paths: Dict[str, str],
+    num_views: int,
+    allow_missing: bool = False,
+) -> List[str]:
+    selected = []
+    missing = []
+    for camera in camera_names(num_views):
+        value = str(image_paths.get(camera, ""))
+        if not value or not os.path.isfile(value):
+            missing.append(f"{camera}={value!r}")
+        selected.append(value)
+    if missing and not allow_missing:
+        raise FileNotFoundError("Missing required camera images: " + "; ".join(missing))
+    return selected
+
+
+def build_messages(
+    question: str,
+    image_paths: Dict[str, str],
+    num_views: int,
+    answer: str | None = None,
+) -> List[Dict[str, Any]]:
+    paths = validate_image_paths(image_paths, num_views, allow_missing=False)
+    content: List[Dict[str, str]] = [
+        {"type": "image", "path": path} for path in paths
+    ]
+    content.append({"type": "text", "text": question})
+    messages: List[Dict[str, Any]] = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": SYSTEM_PROMPT}],
+        },
+        {"role": "user", "content": content},
+    ]
+    if answer is not None:
+        messages.append(
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": answer}],
+            }
+        )
+    return messages
+
+
+def apply_chat_template(
+    processor,
+    messages: Sequence[Dict[str, Any]],
+    *,
+    add_generation_prompt: bool,
+    max_length: int,
+):
+    return processor.apply_chat_template(
+        list(messages),
+        add_generation_prompt=add_generation_prompt,
+        tokenize=True,
+        return_dict=True,
+        return_tensors="pt",
+        truncation=True,
+        max_length=max_length,
+    )
+
+
+def move_to_device(batch: Dict[str, Any], device: torch.device) -> Dict[str, Any]:
+    return {
+        key: value.to(device) if torch.is_tensor(value) else value
+        for key, value in batch.items()
+    }
+
+
+def append_response_ids(
+    prompt_batch: Dict[str, Any],
+    response_ids: torch.Tensor,
+) -> tuple[Dict[str, Any], int]:
+    input_ids = prompt_batch["input_ids"]
+    if input_ids.shape[0] != 1 or response_ids.shape[0] != 1:
+        raise ValueError("The first online OPD implementation requires batch size 1")
+    prompt_len = int(input_ids.shape[1])
+    result: Dict[str, Any] = {}
+    for key, value in prompt_batch.items():
+        if key in {"input_ids", "attention_mask", "position_ids", "cache_position"}:
+            continue
+        result[key] = value
+    result["input_ids"] = torch.cat([input_ids, response_ids], dim=1)
+    prompt_mask = prompt_batch.get("attention_mask", torch.ones_like(input_ids))
+    response_mask = torch.ones_like(response_ids, dtype=prompt_mask.dtype)
+    result["attention_mask"] = torch.cat([prompt_mask, response_mask], dim=1)
+    return result, prompt_len
+
+
+def tokenizer_fingerprint(tokenizer) -> str:
+    """Hash token-id mapping and special tokens; OPD requires an exact match."""
+    digest = hashlib.sha256()
+    digest.update(str(len(tokenizer)).encode("utf-8"))
+    for index in range(len(tokenizer)):
+        token = tokenizer.convert_ids_to_tokens(index)
+        digest.update(index.to_bytes(4, "little", signed=False))
+        digest.update(str(token).encode("utf-8", errors="surrogatepass"))
+        digest.update(b"\0")
+    digest.update(
+        json.dumps(
+            tokenizer.special_tokens_map,
+            ensure_ascii=False,
+            sort_keys=True,
+        ).encode("utf-8")
+    )
+    return digest.hexdigest()
+
+
+def infer_input_device(model) -> torch.device:
+    for parameter in model.parameters():
+        if parameter.device.type != "meta":
+            return parameter.device
+    raise RuntimeError("Could not infer a real model input device")
+

src/data.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+import torch
+from torch.utils.data import Dataset
+
+from .common import apply_chat_template, build_messages, normalized_row
+
+
+class DriveDataset(Dataset):
+    def __init__(self, rows: List[Dict[str, Any]]) -> None:
+        self.rows = [normalized_row(row) for row in rows]
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def __getitem__(self, index: int) -> Dict[str, Any]:
+        return self.rows[index]
+
+
+class RawBatchCollator:
+    """Keep raw examples for online generation. Batch size must be one/GPU."""
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
+        if len(features) != 1:
+            raise ValueError("Online OPD requires per-device batch size 1")
+        return {"row": features[0]}
+
+
+class SFTCollator:
+    def __init__(self, processor, num_views: int, max_length: int) -> None:
+        self.processor = processor
+        self.num_views = num_views
+        self.max_length = max_length
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
+        if len(features) != 1:
+            raise ValueError(
+                "This safe multimodal collator requires per-device batch size 1; "
+                "use gradient accumulation for the effective batch size"
+            )
+        row = features[0]
+        if not row["question"] or not row["answer"]:
+            raise ValueError("question and answer must both be non-empty")
+
+        prompt_messages = build_messages(
+            row["question"], row["image_paths"], self.num_views
+        )
+        full_messages = build_messages(
+            row["question"], row["image_paths"], self.num_views, row["answer"]
+        )
+        prompt = apply_chat_template(
+            self.processor,
+            prompt_messages,
+            add_generation_prompt=True,
+            max_length=self.max_length,
+        )
+        full = apply_chat_template(
+            self.processor,
+            full_messages,
+            add_generation_prompt=False,
+            max_length=self.max_length,
+        )
+        prompt_ids = prompt["input_ids"]
+        full_ids = full["input_ids"]
+        prompt_len = int(prompt_ids.shape[1])
+        if full_ids.shape[1] <= prompt_len:
+            raise ValueError(
+                "Answer was fully truncated. Increase --max-length or shorten input."
+            )
+        if not torch.equal(full_ids[:, :prompt_len], prompt_ids):
+            raise RuntimeError(
+                "The full chat template is not prefixed by the generation prompt. "
+                "Refusing to guess the assistant loss mask; inspect the local processor."
+            )
+        labels = full_ids.clone()
+        labels[:, :prompt_len] = -100
+        attention_mask = full.get("attention_mask")
+        if attention_mask is not None:
+            labels = labels.masked_fill(attention_mask.eq(0), -100)
+        full["labels"] = labels
+        return full

src/data_audit.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import argparse
+import collections
+import os
+
+from .common import CAMERA_ORDER, load_rows, normalized_row
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Audit flattened DriveLM data")
+    parser.add_argument("--data-dir", required=True)
+    parser.add_argument("--splits", nargs="+", default=["train", "val"])
+    parser.add_argument("--num-views", type=int, default=6)
+    parser.add_argument("--allow-missing-images", action="store_true")
+    args = parser.parse_args()
+
+    failed = False
+    cameras = CAMERA_ORDER[: args.num_views]
+    for split in args.splits:
+        rows = [normalized_row(row) for row in load_rows(args.data_dir, split)]
+        tasks = collections.Counter(row["task_type"] for row in rows)
+        missing_text = sum(not row["question"] or not row["answer"] for row in rows)
+        missing_images = collections.Counter()
+        for row in rows:
+            for camera in cameras:
+                path = row["image_paths"].get(camera, "")
+                if not path or not os.path.isfile(path):
+                    missing_images[camera] += 1
+        print(f"[{split}] rows={len(rows)} task_types={dict(tasks)}")
+        print(f"[{split}] empty_question_or_answer={missing_text}")
+        print(f"[{split}] missing_images={dict(missing_images)}")
+        if rows:
+            print(f"[{split}] first_question={rows[0]['question'][:160]!r}")
+        failed |= missing_text > 0
+        failed |= bool(missing_images) and not args.allow_missing_images
+    if failed:
+        raise SystemExit("Data audit failed; fix the reported issues before training")
+    print("DATA_AUDIT_OK")
+
+
+if __name__ == "__main__":
+    main()

src/evaluate.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+from collections import Counter
+
+import torch
+from peft import PeftModel
+
+from .common import (
+    apply_chat_template,
+    build_messages,
+    load_rows,
+    move_to_device,
+    normalized_row,
+)
+from .modeling import load_base_model, load_processor
+
+
+def normalize(text: str) -> list[str]:
+    return re.findall(r"[a-z0-9]+", text.lower())
+
+
+def token_f1(prediction: str, reference: str) -> float:
+    pred = normalize(prediction)
+    ref = normalize(reference)
+    if not pred or not ref:
+        return float(pred == ref)
+    overlap = sum((Counter(pred) & Counter(ref)).values())
+    if overlap == 0:
+        return 0.0
+    precision = overlap / len(pred)
+    recall = overlap / len(ref)
+    return 2 * precision * recall / (precision + recall)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate DriveLM validation predictions")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--adapter-path", default=None)
+    parser.add_argument("--data-dir", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--split", default="val")
+    parser.add_argument("--num-views", type=int, default=1)
+    parser.add_argument("--max-length", type=int, default=4096)
+    parser.add_argument("--max-new-tokens", type=int, default=128)
+    parser.add_argument("--max-samples", type=int, default=None)
+    parser.add_argument("--attn-implementation", default="sdpa")
+    args = parser.parse_args()
+
+    processor = load_processor(args.model)
+    model = load_base_model(
+        args.model, attn_implementation=args.attn_implementation
+    )
+    if args.adapter_path:
+        model = PeftModel.from_pretrained(model, args.adapter_path, is_trainable=False)
+    model = model.cuda().eval()
+    rows = load_rows(args.data_dir, args.split)
+    if args.max_samples:
+        rows = rows[: args.max_samples]
+    os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
+    exact_sum = 0.0
+    f1_sum = 0.0
+    with open(args.output, "w", encoding="utf-8") as handle:
+        for index, raw in enumerate(rows):
+            row = normalized_row(raw)
+            prompt = apply_chat_template(
+                processor,
+                build_messages(row["question"], row["image_paths"], args.num_views),
+                add_generation_prompt=True,
+                max_length=args.max_length,
+            )
+            prompt = move_to_device(prompt, torch.device("cuda"))
+            prompt_len = int(prompt["input_ids"].shape[1])
+            generation_tokens = min(
+                args.max_new_tokens, args.max_length - prompt_len
+            )
+            if generation_tokens < 1:
+                raise RuntimeError(
+                    f"Sample {index} prompt reaches max_length={args.max_length}"
+                )
+            with torch.inference_mode():
+                sequences = model.generate(
+                    **prompt,
+                    max_new_tokens=generation_tokens,
+                    do_sample=False,
+                    use_cache=True,
+                )
+            prediction = processor.tokenizer.decode(
+                sequences[0, prompt_len:], skip_special_tokens=True
+            ).strip()
+            exact = float(normalize(prediction) == normalize(row["answer"]))
+            f1 = token_f1(prediction, row["answer"])
+            exact_sum += exact
+            f1_sum += f1
+            record = {
+                **{key: row[key] for key in ("scene_id", "frame_token", "task_type")},
+                "question": row["question"],
+                "reference": row["answer"],
+                "prediction": prediction,
+                "exact_match": exact,
+                "token_f1": f1,
+            }
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+            if (index + 1) % 20 == 0:
+                print(f"evaluated={index + 1}/{len(rows)}", flush=True)
+    count = len(rows)
+    metrics = {
+        "samples": count,
+        "exact_match": exact_sum / count if count else 0.0,
+        "token_f1": f1_sum / count if count else 0.0,
+    }
+    with open(args.output + ".metrics.json", "w", encoding="utf-8") as handle:
+        json.dump(metrics, handle, ensure_ascii=False, indent=2)
+    print(json.dumps(metrics, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

src/losses.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import torch
+
+
+def sampled_token_opd_loss(
+    student_logp: torch.Tensor,
+    teacher_logp: torch.Tensor,
+    valid_mask: Optional[torch.Tensor] = None,
+    advantage_clip: float = 10.0,
+) -> tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+    """Policy-gradient style sampled-token OPD loss.
+
+    Teacher and student tensors must score the exact same response token IDs.
+    The advantage is detached so gradients only flow through student_logp.
+    """
+    if student_logp.shape != teacher_logp.shape:
+        raise ValueError(
+            f"logp shape mismatch: student={tuple(student_logp.shape)} "
+            f"teacher={tuple(teacher_logp.shape)}"
+        )
+    if valid_mask is None:
+        valid_mask = torch.ones_like(student_logp, dtype=torch.bool)
+    if valid_mask.shape != student_logp.shape:
+        raise ValueError("valid_mask must have the same shape as log-probabilities")
+    if not bool(valid_mask.any()):
+        raise ValueError("sampled-token OPD received no valid response tokens")
+
+    raw_advantage = teacher_logp.float() - student_logp.detach().float()
+    advantage = raw_advantage.clamp(-advantage_clip, advantage_clip)
+    token_loss = -(advantage * student_logp.float())
+    loss = token_loss.masked_select(valid_mask).mean()
+
+    selected_raw = raw_advantage.masked_select(valid_mask)
+    selected_adv = advantage.masked_select(valid_mask)
+    clip_fraction = (selected_raw.abs() > advantage_clip).float().mean()
+    stats = {
+        "advantage_mean": selected_adv.mean().detach(),
+        "advantage_std": selected_adv.std(unbiased=False).detach(),
+        "advantage_positive_fraction": (selected_adv > 0).float().mean().detach(),
+        "advantage_clip_fraction": clip_fraction.detach(),
+        "student_logp_mean": student_logp.float().masked_select(valid_mask).mean().detach(),
+        "teacher_logp_mean": teacher_logp.float().masked_select(valid_mask).mean().detach(),
+    }
+    return loss, stats
+
+
+def response_token_logps(
+    logits: torch.Tensor,
+    response_ids: torch.Tensor,
+    response_start: int,
+) -> torch.Tensor:
+    """Gather next-token log-probabilities for a response appended to a prompt.
+
+    logits has shape [B, prompt_len + response_len, vocab]. response_start is
+    the prompt length. The returned tensor has shape [B, response_len].
+    """
+    if logits.dim() != 3 or response_ids.dim() != 2:
+        raise ValueError("Expected logits [B,L,V] and response_ids [B,T]")
+    response_len = response_ids.shape[1]
+    if response_len < 1:
+        raise ValueError("response_ids must not be empty")
+    start = response_start - 1
+    end = start + response_len
+    if start < 0 or end > logits.shape[1]:
+        raise ValueError(
+            f"Invalid response slice start={start}, end={end}, logits_len={logits.shape[1]}"
+        )
+    prediction_logits = logits[:, start:end, :].float()
+    log_probs = prediction_logits.log_softmax(dim=-1)
+    return log_probs.gather(-1, response_ids.unsqueeze(-1)).squeeze(-1)
+

src/modeling.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import List
+
+import torch
+from peft import LoraConfig, PeftModel, TaskType, get_peft_model
+from transformers import AutoModelForMultimodalLM, AutoProcessor
+
+
+VISION_MARKERS = ("visual", "vision", "image", "merger")
+LORA_LEAF_NAMES = {
+    "q_proj",
+    "k_proj",
+    "v_proj",
+    "o_proj",
+    "gate_proj",
+    "up_proj",
+    "down_proj",
+    "in_proj_qkv",
+    "in_proj_z",
+    "in_proj_a",
+    "in_proj_b",
+    "out_proj",
+}
+
+
+def load_processor(model_path: str, local_files_only: bool = True):
+    return AutoProcessor.from_pretrained(
+        model_path,
+        trust_remote_code=True,
+        local_files_only=local_files_only,
+    )
+
+
+def load_base_model(
+    model_path: str,
+    *,
+    attn_implementation: str = "sdpa",
+    local_files_only: bool = True,
+):
+    return AutoModelForMultimodalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.bfloat16,
+        attn_implementation=attn_implementation,
+        trust_remote_code=True,
+        local_files_only=local_files_only,
+        low_cpu_mem_usage=True,
+    )
+
+
+def freeze_vision_parameters(model) -> int:
+    count = 0
+    for name, parameter in model.named_parameters():
+        if any(marker in name.lower() for marker in VISION_MARKERS):
+            parameter.requires_grad_(False)
+            count += parameter.numel()
+    return count
+
+
+def discover_lora_targets(model) -> List[str]:
+    """Return exact linear-module paths, excluding the vision tower and lm_head."""
+    targets: List[str] = []
+    for name, module in model.named_modules():
+        if not isinstance(module, torch.nn.Linear):
+            continue
+        lower = name.lower()
+        if any(marker in lower for marker in VISION_MARKERS) or lower.endswith("lm_head"):
+            continue
+        if name.rsplit(".", 1)[-1] in LORA_LEAF_NAMES:
+            targets.append(name)
+    if not targets:
+        raise RuntimeError(
+            "No supported LoRA targets were found. Print model.named_modules() and "
+            "update LORA_LEAF_NAMES for this local model revision."
+        )
+    return sorted(set(targets))
+
+
+def prepare_trainable_model(
+    model,
+    *,
+    adapter_path: str | None,
+    lora_r: int,
+    lora_alpha: int,
+    lora_dropout: float,
+    freeze_vision: bool,
+):
+    if freeze_vision:
+        freeze_vision_parameters(model)
+    model.config.use_cache = False
+    if hasattr(model, "gradient_checkpointing_enable"):
+        model.gradient_checkpointing_enable(
+            gradient_checkpointing_kwargs={"use_reentrant": False}
+        )
+    if hasattr(model, "enable_input_require_grads"):
+        model.enable_input_require_grads()
+
+    if adapter_path:
+        return PeftModel.from_pretrained(model, adapter_path, is_trainable=True)
+
+    targets = discover_lora_targets(model)
+    config = LoraConfig(
+        r=lora_r,
+        lora_alpha=lora_alpha,
+        lora_dropout=lora_dropout,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+        target_modules=targets,
+    )
+    return get_peft_model(model, config)
+
+
+def trainable_parameter_summary(model) -> tuple[int, int]:
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    total = sum(p.numel() for p in model.parameters())
+    return trainable, total

src/preflight.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+import torch
+from transformers import AutoConfig
+
+from .common import (
+    apply_chat_template,
+    build_messages,
+    load_rows,
+    move_to_device,
+    normalized_row,
+    tokenizer_fingerprint,
+)
+from .modeling import load_base_model, load_processor
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Qwen3.5 VLM environment preflight")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--data-dir", required=True)
+    parser.add_argument("--split", default="train")
+    parser.add_argument("--num-views", type=int, default=1)
+    parser.add_argument("--max-length", type=int, default=2048)
+    parser.add_argument("--load-model", action="store_true")
+    parser.add_argument("--attn-implementation", default="sdpa")
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.model):
+        raise SystemExit(f"Local model directory does not exist: {args.model}")
+    config = AutoConfig.from_pretrained(
+        args.model, trust_remote_code=True, local_files_only=True
+    )
+    if not hasattr(config, "vision_config"):
+        raise SystemExit(
+            f"{args.model} is not recognized as a multimodal model (no vision_config)"
+        )
+    processor = load_processor(args.model)
+    fingerprint = tokenizer_fingerprint(processor.tokenizer)
+    row = normalized_row(load_rows(args.data_dir, args.split)[0])
+    batch = apply_chat_template(
+        processor,
+        build_messages(row["question"], row["image_paths"], args.num_views),
+        add_generation_prompt=True,
+        max_length=args.max_length,
+    )
+    print(f"model_type={getattr(config, 'model_type', 'unknown')}")
+    print(f"tokenizer_size={len(processor.tokenizer)}")
+    print(f"tokenizer_sha256={fingerprint}")
+    print(f"prompt_tokens={batch['input_ids'].shape[1]}")
+    print(f"batch_keys={sorted(batch)}")
+    if args.load_model:
+        if not torch.cuda.is_available():
+            raise SystemExit("--load-model requested but CUDA is unavailable")
+        model = load_base_model(
+            args.model, attn_implementation=args.attn_implementation
+        ).cuda().eval()
+        with torch.inference_mode():
+            outputs = model(**move_to_device(batch, torch.device("cuda")))
+        print(f"forward_logits_shape={tuple(outputs.logits.shape)}")
+    print("PREFLIGHT_OK")
+
+
+if __name__ == "__main__":
+    main()

src/teacher_server.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import argparse
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+import torch
+from peft import PeftModel
+
+from .common import (
+    append_response_ids,
+    apply_chat_template,
+    build_messages,
+    infer_input_device,
+    move_to_device,
+    tokenizer_fingerprint,
+)
+from .losses import response_token_logps
+from .modeling import load_base_model, load_processor
+
+
+class TeacherState:
+    def __init__(self, args: argparse.Namespace) -> None:
+        self.model_path = args.model
+        self.num_views = args.num_views
+        self.max_length = args.max_length
+        self.processor = load_processor(args.model)
+        model = load_base_model(
+            args.model, attn_implementation=args.attn_implementation
+        )
+        if args.adapter_path:
+            model = PeftModel.from_pretrained(model, args.adapter_path, is_trainable=False)
+        self.model = model.cuda().eval()
+        self.device = infer_input_device(self.model)
+        self.fingerprint = tokenizer_fingerprint(self.processor.tokenizer)
+        self.lock = threading.Lock()
+
+    def health(self) -> dict:
+        return {
+            "ok": True,
+            "model": self.model_path,
+            "num_views": self.num_views,
+            "tokenizer_size": len(self.processor.tokenizer),
+            "tokenizer_sha256": self.fingerprint,
+        }
+
+    def score(self, payload: dict) -> dict:
+        response_list = payload.get("response_ids")
+        if not isinstance(response_list, list) or not response_list:
+            raise ValueError("response_ids must be a non-empty list")
+        response_ids = torch.tensor(
+            [response_list], dtype=torch.long, device=self.device
+        )
+        messages = build_messages(
+            str(payload["question"]),
+            dict(payload["image_paths"]),
+            self.num_views,
+        )
+        prompt = apply_chat_template(
+            self.processor,
+            messages,
+            add_generation_prompt=True,
+            max_length=self.max_length,
+        )
+        prompt = move_to_device(prompt, self.device)
+        batch, prompt_len = append_response_ids(prompt, response_ids)
+        if batch["input_ids"].shape[1] > self.max_length:
+            raise ValueError("prompt + response exceeds teacher max_length")
+        with self.lock, torch.inference_mode():
+            outputs = self.model(**batch, use_cache=False)
+            logps = response_token_logps(outputs.logits, response_ids, prompt_len)
+        return {
+            "token_logps": logps[0].float().cpu().tolist(),
+            "prompt_tokens": prompt_len,
+            "response_tokens": int(response_ids.shape[1]),
+        }
+
+
+def handler_factory(state: TeacherState):
+    class Handler(BaseHTTPRequestHandler):
+        def _send(self, status: int, payload: dict) -> None:
+            body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self) -> None:
+            if self.path == "/health":
+                self._send(200, state.health())
+            else:
+                self._send(404, {"error": "not found"})
+
+        def do_POST(self) -> None:
+            if self.path != "/score":
+                self._send(404, {"error": "not found"})
+                return
+            try:
+                length = int(self.headers.get("Content-Length", "0"))
+                if length <= 0 or length > 4 * 1024 * 1024:
+                    raise ValueError("invalid request size")
+                payload = json.loads(self.rfile.read(length))
+                self._send(200, state.score(payload))
+            except Exception as exc:
+                self._send(400, {"error": f"{type(exc).__name__}: {exc}"})
+
+        def log_message(self, fmt: str, *args) -> None:
+            print(f"teacher_http {self.address_string()} {fmt % args}", flush=True)
+
+    return Handler
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Sampled-token OPD teacher server")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--adapter-path", default=None)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=18080)
+    parser.add_argument("--num-views", type=int, default=6)
+    parser.add_argument("--max-length", type=int, default=4096)
+    parser.add_argument("--attn-implementation", default="sdpa")
+    args = parser.parse_args()
+    state = TeacherState(args)
+    print(json.dumps(state.health(), ensure_ascii=False), flush=True)
+    server = ThreadingHTTPServer((args.host, args.port), handler_factory(state))
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

src/train_online_opd.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import urllib.request
+
+import torch
+from accelerate import Accelerator
+from torch.optim import AdamW
+from torch.utils.data import DataLoader
+from transformers import get_cosine_schedule_with_warmup, set_seed
+
+from .common import (
+    append_response_ids,
+    apply_chat_template,
+    build_messages,
+    infer_input_device,
+    load_rows,
+    move_to_device,
+    tokenizer_fingerprint,
+)
+from .data import DriveDataset, RawBatchCollator, SFTCollator
+from .losses import response_token_logps, sampled_token_opd_loss
+from .modeling import (
+    load_base_model,
+    load_processor,
+    prepare_trainable_model,
+    trainable_parameter_summary,
+)
+
+
+def http_json(url: str, payload: dict | None = None, timeout: float = 300.0) -> dict:
+    data = None if payload is None else json.dumps(payload).encode("utf-8")
+    request = urllib.request.Request(
+        url,
+        data=data,
+        method="GET" if data is None else "POST",
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return json.loads(response.read())
+    except Exception as exc:
+        raise RuntimeError(f"Teacher request failed: {url}: {exc}") from exc
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Online sampled-token OPD")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--adapter-path", required=True)
+    parser.add_argument("--data-dir", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--teacher-url", default="http://127.0.0.1:18080")
+    parser.add_argument("--train-split", default="train")
+    parser.add_argument("--num-views", type=int, default=6)
+    parser.add_argument("--max-length", type=int, default=4096)
+    parser.add_argument("--max-new-tokens", type=int, default=128)
+    parser.add_argument("--max-steps", type=int, default=300)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=8)
+    parser.add_argument("--learning-rate", type=float, default=5e-6)
+    parser.add_argument("--warmup-ratio", type=float, default=0.03)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top-p", type=float, default=0.8)
+    parser.add_argument("--top-k", type=int, default=20)
+    parser.add_argument("--advantage-clip", type=float, default=5.0)
+    parser.add_argument("--sft-anchor-coef", type=float, default=0.1)
+    parser.add_argument("--save-steps", type=int, default=50)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--attn-implementation", default="sdpa")
+    return parser.parse_args()
+
+
+def save_adapter(accelerator: Accelerator, model, processor, output_dir: str) -> None:
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        os.makedirs(output_dir, exist_ok=True)
+        unwrapped = accelerator.unwrap_model(model)
+        unwrapped.save_pretrained(output_dir, safe_serialization=True)
+        processor.save_pretrained(output_dir)
+    accelerator.wait_for_everyone()
+
+
+def main() -> None:
+    args = parse_args()
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision="bf16",
+    )
+    set_seed(args.seed + accelerator.process_index)
+    health = http_json(f"{args.teacher_url}/health", timeout=30)
+
+    processor = load_processor(args.model)
+    local_fingerprint = tokenizer_fingerprint(processor.tokenizer)
+    if health.get("tokenizer_sha256") != local_fingerprint:
+        raise SystemExit(
+            "Teacher/student tokenizers differ. Sampled-token OPD requires exact token "
+            f"IDs. teacher={health.get('tokenizer_sha256')} student={local_fingerprint}"
+        )
+    if int(health.get("num_views", -1)) != args.num_views:
+        raise SystemExit("Teacher and student --num-views must be identical")
+
+    base = load_base_model(args.model, attn_implementation=args.attn_implementation)
+    model = prepare_trainable_model(
+        base,
+        adapter_path=args.adapter_path,
+        lora_r=16,
+        lora_alpha=32,
+        lora_dropout=0.0,
+        freeze_vision=True,
+    )
+    trainable, total = trainable_parameter_summary(model)
+    accelerator.print(
+        f"trainable_parameters={trainable:,}/{total:,} ({trainable / total:.4%})"
+    )
+    dataset = DriveDataset(load_rows(args.data_dir, args.train_split))
+    loader = DataLoader(
+        dataset,
+        batch_size=1,
+        shuffle=True,
+        collate_fn=RawBatchCollator(),
+        num_workers=0,
+    )
+    optimizer = AdamW(
+        [parameter for parameter in model.parameters() if parameter.requires_grad],
+        lr=args.learning_rate,
+    )
+    scheduler = get_cosine_schedule_with_warmup(
+        optimizer,
+        num_warmup_steps=max(1, int(args.max_steps * args.warmup_ratio)),
+        num_training_steps=args.max_steps,
+    )
+    model, optimizer, loader, scheduler = accelerator.prepare(
+        model, optimizer, loader, scheduler
+    )
+    sft_collator = SFTCollator(processor, args.num_views, args.max_length)
+    update_step = 0
+    micro_step = 0
+    model.train()
+    while update_step < args.max_steps:
+        for batch in loader:
+            row = batch["row"]
+            with accelerator.accumulate(model):
+                prompt = apply_chat_template(
+                    processor,
+                    build_messages(row["question"], row["image_paths"], args.num_views),
+                    add_generation_prompt=True,
+                    max_length=args.max_length,
+                )
+                device = infer_input_device(accelerator.unwrap_model(model))
+                prompt = move_to_device(prompt, device)
+                prompt_len = int(prompt["input_ids"].shape[1])
+                generation_tokens = min(
+                    args.max_new_tokens, args.max_length - prompt_len
+                )
+                if generation_tokens < 1:
+                    raise RuntimeError(
+                        "Prompt already reaches max_length; shorten it or increase "
+                        "--max-length"
+                    )
+                unwrapped = accelerator.unwrap_model(model)
+                unwrapped.eval()
+                with torch.inference_mode():
+                    sequences = unwrapped.generate(
+                        **prompt,
+                        max_new_tokens=generation_tokens,
+                        do_sample=True,
+                        temperature=args.temperature,
+                        top_p=args.top_p,
+                        top_k=args.top_k,
+                        use_cache=True,
+                    )
+                unwrapped.train()
+                response_ids = sequences[:, prompt_len:].detach()
+                if response_ids.shape[1] == 0:
+                    raise RuntimeError("Student generated no response tokens")
+
+                teacher = http_json(
+                    f"{args.teacher_url}/score",
+                    {
+                        "question": row["question"],
+                        "image_paths": row["image_paths"],
+                        "response_ids": response_ids[0].cpu().tolist(),
+                    },
+                )
+                teacher_logp = torch.tensor(
+                    teacher["token_logps"], dtype=torch.float32, device=device
+                ).unsqueeze(0)
+                student_batch, response_start = append_response_ids(prompt, response_ids)
+                outputs = model(**student_batch, use_cache=False)
+                student_logp = response_token_logps(
+                    outputs.logits, response_ids, response_start
+                )
+                opd_loss, stats = sampled_token_opd_loss(
+                    student_logp,
+                    teacher_logp,
+                    advantage_clip=args.advantage_clip,
+                )
+                total_loss = opd_loss
+                sft_loss = torch.zeros((), device=device)
+                if args.sft_anchor_coef > 0:
+                    sft_batch = move_to_device(sft_collator([row]), device)
+                    sft_loss = model(**sft_batch, use_cache=False).loss
+                    total_loss = total_loss + args.sft_anchor_coef * sft_loss
+                accelerator.backward(total_loss)
+                if accelerator.sync_gradients:
+                    accelerator.clip_grad_norm_(model.parameters(), 1.0)
+                optimizer.step()
+                scheduler.step()
+                optimizer.zero_grad(set_to_none=True)
+
+            micro_step += 1
+            if accelerator.sync_gradients:
+                update_step += 1
+                if accelerator.is_main_process:
+                    print(
+                        json.dumps(
+                            {
+                                "step": update_step,
+                                "loss": float(total_loss.detach()),
+                                "opd_loss": float(opd_loss.detach()),
+                                "sft_loss": float(sft_loss.detach()),
+                                "advantage_mean": float(stats["advantage_mean"]),
+                                "response_tokens": int(response_ids.shape[1]),
+                                "lr": scheduler.get_last_lr()[0],
+                            }
+                        ),
+                        flush=True,
+                    )
+                if update_step % args.save_steps == 0:
+                    save_adapter(
+                        accelerator,
+                        model,
+                        processor,
+                        os.path.join(args.output_dir, f"checkpoint-{update_step}"),
+                    )
+                if update_step >= args.max_steps:
+                    break
+    save_adapter(
+        accelerator, model, processor, os.path.join(args.output_dir, "final_adapter")
+    )
+    accelerator.print("ONLINE_OPD_DONE")
+
+
+if __name__ == "__main__":
+    main()

src/train_sft.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+from transformers import Trainer, TrainingArguments, set_seed
+
+from .common import load_rows
+from .data import DriveDataset, SFTCollator
+from .modeling import (
+    load_base_model,
+    load_processor,
+    prepare_trainable_model,
+    trainable_parameter_summary,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="LoRA SFT for Qwen3.5 VLM")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--data-dir", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--adapter-path", default=None)
+    parser.add_argument("--train-split", default="train")
+    parser.add_argument("--val-split", default="val")
+    parser.add_argument("--num-views", type=int, default=1)
+    parser.add_argument("--max-length", type=int, default=2048)
+    parser.add_argument("--max-steps", type=int, default=1000)
+    parser.add_argument("--learning-rate", type=float, default=2e-4)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+    parser.add_argument("--lora-r", type=int, default=16)
+    parser.add_argument("--lora-alpha", type=int, default=32)
+    parser.add_argument("--lora-dropout", type=float, default=0.05)
+    parser.add_argument("--eval-steps", type=int, default=100)
+    parser.add_argument("--save-steps", type=int, default=100)
+    parser.add_argument("--logging-steps", type=int, default=5)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--attn-implementation", default="sdpa")
+    parser.add_argument("--deepspeed", default=None)
+    parser.add_argument("--freeze-vision", action=argparse.BooleanOptionalAction, default=True)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    set_seed(args.seed)
+    processor = load_processor(args.model)
+    model = load_base_model(args.model, attn_implementation=args.attn_implementation)
+    model = prepare_trainable_model(
+        model,
+        adapter_path=args.adapter_path,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        freeze_vision=args.freeze_vision,
+    )
+    trainable, total = trainable_parameter_summary(model)
+    print(f"trainable_parameters={trainable:,}/{total:,} ({trainable / total:.4%})")
+
+    train_dataset = DriveDataset(load_rows(args.data_dir, args.train_split))
+    eval_dataset = DriveDataset(load_rows(args.data_dir, args.val_split))
+    collator = SFTCollator(processor, args.num_views, args.max_length)
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=1,
+        per_device_eval_batch_size=1,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=args.learning_rate,
+        max_steps=args.max_steps,
+        warmup_ratio=0.03,
+        lr_scheduler_type="cosine",
+        bf16=True,
+        tf32=True,
+        gradient_checkpointing=True,
+        eval_strategy="steps",
+        eval_steps=args.eval_steps,
+        save_strategy="steps",
+        save_steps=args.save_steps,
+        save_total_limit=2,
+        logging_steps=args.logging_steps,
+        report_to="none",
+        remove_unused_columns=False,
+        dataloader_num_workers=0,
+        ddp_find_unused_parameters=False,
+        deepspeed=args.deepspeed,
+        seed=args.seed,
+    )
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=collator,
+    )
+    trainer.train(resume_from_checkpoint=False)
+    final_dir = os.path.join(args.output_dir, "final_adapter")
+    trainer.save_model(final_dir)
+    processor.save_pretrained(final_dir)
+    print(f"SFT_DONE adapter={final_dir}")
+
+
+if __name__ == "__main__":
+    main()

tests/test_losses.py

@@ -0,0 +1,23 @@
+import torch
+
+from src.losses import response_token_logps, sampled_token_opd_loss
+
+
+def test_response_token_logps_alignment():
+    logits = torch.full((1, 5, 7), -10.0)
+    response = torch.tensor([[3, 4]])
+    logits[0, 2, 3] = 10.0
+    logits[0, 3, 4] = 10.0
+    result = response_token_logps(logits, response, response_start=3)
+    assert result.shape == (1, 2)
+    assert torch.all(result > -1e-3)
+
+
+def test_sampled_loss_has_student_gradient():
+    student = torch.tensor([[-2.0, -3.0]], requires_grad=True)
+    teacher = torch.tensor([[-1.0, -4.0]])
+    loss, stats = sampled_token_opd_loss(student, teacher, advantage_clip=5.0)
+    loss.backward()
+    assert student.grad is not None
+    assert torch.isfinite(student.grad).all()
+    assert "advantage_mean" in stats

tools/convert_drivelm.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+from pathlib import Path
+
+
+CAMERAS = [
+    "CAM_FRONT",
+    "CAM_FRONT_LEFT",
+    "CAM_FRONT_RIGHT",
+    "CAM_BACK",
+    "CAM_BACK_LEFT",
+    "CAM_BACK_RIGHT",
+]
+
+
+def resolve_images(raw: dict, images_root: str) -> dict:
+    result = {}
+    for camera in CAMERAS:
+        value = str(raw.get(camera, ""))
+        if value.startswith("../"):
+            value = value[3:]
+        result[camera] = os.path.abspath(os.path.join(images_root, value)) if value else ""
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Flatten DriveLM nuScenes QA JSON")
+    parser.add_argument("--json", required=True)
+    parser.add_argument("--images-root", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--train-ratio", type=float, default=0.9)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--max-samples", type=int, default=None)
+    args = parser.parse_args()
+
+    with open(args.json, "r", encoding="utf-8") as handle:
+        raw = json.load(handle)
+    rows = []
+    for scene_id, scene in raw.items():
+        for frame_token, frame in scene.get("key_frames", {}).items():
+            images = resolve_images(frame.get("image_paths", {}), args.images_root)
+            for task_type, qa_pairs in frame.get("QA", {}).items():
+                for pair in qa_pairs:
+                    question = str(pair.get("Q", "")).strip()
+                    answer = str(pair.get("A", "")).strip()
+                    if question and answer:
+                        rows.append(
+                            {
+                                "scene_id": scene_id,
+                                "frame_token": frame_token,
+                                "task_type": task_type,
+                                "question": question,
+                                "answer": answer,
+                                "image_paths": images,
+                            }
+                        )
+    rng = random.Random(args.seed)
+    if args.max_samples and len(rows) > args.max_samples:
+        rng.shuffle(rows)
+        rows = rows[: args.max_samples]
+    scene_ids = sorted({row["scene_id"] for row in rows})
+    rng.shuffle(scene_ids)
+    boundary = int(len(scene_ids) * args.train_ratio)
+    train_scenes = set(scene_ids[:boundary])
+    splits = {
+        "train": [row for row in rows if row["scene_id"] in train_scenes],
+        "val": [row for row in rows if row["scene_id"] not in train_scenes],
+    }
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+    for split, values in splits.items():
+        output = Path(args.output_dir) / f"{split}.json"
+        with output.open("w", encoding="utf-8") as handle:
+            json.dump(values, handle, ensure_ascii=False)
+        print(f"{split}: {len(values)} rows -> {output}")
+
+
+if __name__ == "__main__":
+    main()