rudals/resmap-navsim-teacher-kd

ReSMap teacher outputs on NAVSIM navtrain and navtest (for distillation)

Per-frame outputs of a trained ReSMap online HD-map model, cached so a student can be distilled (and planning readouts evaluated) without re-running the teacher: 126,032 frames from the train_logs of NAVSIM navtrain at the root, the 26,463 frames of its val_logs under val/, and the 12,146 navtest tokens under navtest/.

stage1_seg/ holds the outputs of the same model's stage-1 checkpoint (BEV + segmentation, before the vector head was trained) on all 152,495 navtrain frames. See Stage-1 teacher.

The teacher is camera + satellite, front-only: three front cameras (CAM_L0/F0/R0) and a front-cropped satellite tile. It has no LiDAR and no rear observation, so its BEV covers the front alone.

Teacher

Map classes	road, walkway, centerline, crosswalk — nuPlan map-API layers, the same set NAVSIM's TransFuser rasterises, plus CROSSWALK
ROI	forward 0..32 m, lateral ±32 m
BEV grid	50 (forward) × 100 (lateral), 0.64 m square cells
Vector eval	mAP 0.7743 — road .8178 / walkway .6162 / centerline .8162 / crosswalk .8470

Layout

Path	Split	Frames	Use
./ (root)	navtrain, NAVSIM train_logs only	126,032	training (distillation, planning readouts)
val/	navtrain, NAVSIM val_logs only	26,463	validation (added 2026-10-16)
navtest/	navtest allow-list tokens	12,146	evaluation (PDMS of readouts on teacher features)
stage1_seg/	navtrain, all logs (train_logs + val_logs)	152,495	stage-1 teacher: BEV + segmentation only (added 2026-10-16)

val/ and navtest/ have the same files and format as the root, from the same checkpoint. val/ together with the root covers every navtrain frame (the log partition is NAVSIM's default_train_val_test_log_split.yaml). navtest/ has the same files and format as the root. The teacher was run on all 71,460 sensor-covered navtest frames in scene order so its temporal memory matches training, and only the 12,146 allow-list tokens were saved. navtest/meta.json records this (only_split_tokens: true).

Contents

Root: 384 .npy shards (64 per field), ~2000 frames each, all float16 unless noted.

Field	Per-frame shape	Notes
bev/	(256, 100, 50)	neck output, the tensor every head reads. Axes are (channel, lateral, forward)
seg/	(4, 200, 100)	raw class logits, not a thresholded mask
vectors/	(100, 20, 2)	100 queries × 20 points, normalised to [0, 1] over the ROI — not metres
scores/	(100,)	sigmoid confidence per query
labels/	(100,)	int8, class index 0..3
props/	(100,)	int16, temporal-propagation flag

index.json maps a NAVSIM token to [shard, row]; meta.json records the teacher checkpoint SHA-256, its geometry and the dtype of every field.

Reading it

Shards are plain .npy, so mmap_mode='r' pages in one frame (2.56 MB for bev) rather than the 5 GB shard. Do not np.load without it.

import json, numpy as np

root = "."
index = json.load(open(f"{root}/index.json"))

def teacher(token, field="bev"):
    shard, row = index[token]
    arr = np.load(f"{root}/{field}/{shard}.npy", mmap_mode="r")
    return np.asarray(arr[row])          # only this frame is read

bev = teacher("018ddf01779056c4")        # (256, 100, 50) float16

Cache the memmap per shard in your dataloader worker; reopening it per sample costs a syscall each time.

Stage-1 teacher (stage1_seg/)

Checkpoint resmap_nav_rideflux_stage1/iter_31512.pth (end of stage 1; SHA-256 1d88c48e5d8be056b00b4cfd814720358d2dff96e213afaf37629a3fdc5947e7). Stage 1 trains the BEV encoders and the segmentation heads; it has no vector head. Segmentation mIoU at the end of stage 1 (NAVSIM val_logs): fused 0.508, camera 0.463, satellite 0.439.

Same shard / index.json / meta.json layout as the root (77 shards per field, every frame of every navtrain log, meta.json split: none). Fields, all float16:

Field	Per-frame shape	Notes
bev/	(256, 100, 50)	camera BEV after the neck — the same tensor as the root's bev/, from the stage-1 weights
seg/	(4, 200, 100)	camera-branch seg logits (seg_decoder) — the same head as the root's seg/
seg_fused/	(4, 200, 100)	fused camera + satellite seg logits (seg_decoder_fused), stage 1's main prediction
seg_sat/	(4, 200, 100)	satellite-branch seg logits (seg_decoder_sat)

All seg fields are raw logits, not thresholded masks. To split train / val, use the log of each token (NAVSIM's log split yaml), as for the root and val/. Generated with tools/cache_teacher_kd_seg.py.

Aligning it to a student

The 256 channels and the 0.64 m cell were not chosen arbitrarily. For a student whose BEV covers ±32 m in both axes on a 100 × 100 grid at 0.64 m with embed_dims=256, the teacher's grid is the front half of the student's, cell for cell — feature distillation is a crop, with no projection and no resample.

Frames were generated in scene order with the teacher's temporal memory bank live, so each frame's features carry the sequence context the teacher had.

Provenance

Generated with tools/cache_teacher_kd.py; meta.json pins the exact checkpoint. Derived from NAVSIM / nuPlan, whose own licence terms govern the underlying data.