LDMR — Breaking the Model Forgetting Cycle in Long-Incremental 3D Object Detection

Per-stage checkpoints for

Breaking the Model Forgetting Cycle in Long-Incremental 3D Object Detection Peisheng Qian, Jie Xu, Xulei Yang, Na Zhao European Conference on Computer Vision (ECCV), 2026

Code: https://github.com/qianpeisheng/LDMR  ·  Dataset metadata: Peisheng/LDMR-data

Incremental 3D object detection must learn new object classes while remembering old ones. Prior methods rely on pseudo-labeling and hold up over one or two increments, but collapse over long sequences: novel-class distribution shift degrades the model on old classes, which corrupts the pseudo labels, which degrades the model further — a self-reinforcing forgetting cycle.

LDMR (Learning-Dynamics-driven Memory and Review) breaks that cycle by monitoring per-class detection quality at periodic training checkpoints and turning those learning dynamics into two mechanisms: human-like intra-stage review, which over-samples whatever the model most recently forgot, and scene-aware cross-stage memory evolution, which scores memory scenes jointly for learnability and diversity.

This repository holds the checkpoint of every stage of every protocol, not just the final one, so each point of the forgetting curve can be inspected.

Contents

36 checkpoints across six protocols, ~2.0 GB total. All use the TR3D backbone.

sunrgbd_3stage/    stage_01.pth .. stage_03.pth   manifest.json
sunrgbd_5stage/    stage_01.pth .. stage_05.pth   manifest.json
sunrgbd_10stage/   stage_01.pth .. stage_10.pth   manifest.json
scannet_3stage/    stage_01.pth .. stage_03.pth   manifest.json
scannet_5stage/    stage_01.pth .. stage_05.pth   manifest.json
scannet_10stage/   stage_01.pth .. stage_10.pth   manifest.json

Each manifest.json records the source run, and the per-stage mAP@0.25, byte size and SHA-256 sum of every file.

Optimizer state is stripped (59 MB per file instead of 176 MB). It is not needed to evaluate a stage or to seed the next one — both paths read only state_dict. This means the files are not byte-exact training-resume points.

Results

Final-stage mAP@0.25 over all seen classes:

Dataset	Protocol	Classes per stage	Seed	Final mAP@0.25
SUN RGB-D (40 cls)	3-stage	20+10+10	200	29.12
SUN RGB-D	5-stage	8×5	200	25.10
SUN RGB-D	10-stage	4×10	200	19.38
ScanNetV2 (35 cls)	3-stage	15+10+10	201	37.81
ScanNetV2	5-stage	7×5	201	27.46
ScanNetV2	10-stage	4,4,4,4,4,3,3,3,3,3	200	17.64

Per stage, over all classes seen so far. Stage i is the model in stage_0i.pth.

SUN RGB-D, 3-stage

Stage	1	2	3
mAP@0.25	39.76	33.21	29.12
mAP@0.50	25.66	20.54	17.53

SUN RGB-D, 5-stage

Stage	1	2	3	4	5
mAP@0.25	53.61	39.61	33.67	29.53	25.10
mAP@0.50	38.62	26.98	21.44	18.36	14.75

SUN RGB-D, 10-stage

Stage	1	2	3	4	5	6	7	8	9	10
mAP@0.25	55.56	51.16	40.42	37.14	33.13	27.85	25.93	24.00	21.63	19.38
mAP@0.50	41.48	36.40	27.43	25.02	20.02	16.37	14.92	13.39	11.86	10.57

ScanNetV2, 3-stage

Stage	1	2	3
mAP@0.25	53.83	46.80	37.81
mAP@0.50	37.56	24.53	17.88

ScanNetV2, 5-stage

Stage	1	2	3	4	5
mAP@0.25	58.34	45.65	42.33	36.44	27.46
mAP@0.50	44.64	27.53	19.15	13.76	11.42

ScanNetV2, 10-stage

Stage	1	2	3	4	5	6	7	8	9	10
mAP@0.25	59.14	51.84	39.11	36.61	33.30	25.05	24.41	21.30	21.08	17.64
mAP@0.50	48.44	31.81	17.03	13.75	14.64	8.10	10.56	9.19	8.38	5.85

A stage-1 model is trained on only the first k classes, so its mAP is not comparable across protocols: SUN RGB-D 3-stage starts with 20 classes and scores 39.76, while the 10-stage run starts with 4 and scores 55.56. The forgetting curve within a column is the quantity of interest.

The three ScanNet runs reuse a base stage trained by a separate run and do not re-evaluate it, so their stage-1 scores above are read from that run's log. The stage-1 checkpoint published here is byte-identical to the one it produced.

Usage

Fetch one protocol:

from huggingface_hub import snapshot_download

snapshot_download('Peisheng/LDMR', repo_type='model',
                  allow_patterns='sunrgbd_10stage/*', local_dir='checkpoints')

Evaluate it with the code from the GitHub repo:

python tools/eval_incremental.py \
    configs/incremental/sunrgbd/tr3d_dynamic_head_4x10_pseudo_memory_ld_design2_reviewing_6111111111.py \
    checkpoints/sunrgbd_10stage/stage_10.pth \
    --eval mAP

Evaluation needs the extracted point clouds, which are not distributed here — see Data below.

To restart the incremental sequence from a released stage rather than retraining the base stage, pass --start-stage 2 --checkpoint-path stage_01.pth to tools/train_incremental_scene.py.

Every checkpoint records its own provenance:

import torch
torch.load('stage_10.pth', map_location='cpu')['meta']['ldmr']
# {'protocol': 'sunrgbd_10stage', 'stage': 10,
#  'source_run': 'sunrgbd_s10_ld2revpse_...', 'source_file': 'epoch_5.pth',
#  'mAP@0.25': 0.1938, 'optimizer_stripped': True}

Data

The raw ScanNet and SUN RGB-D scans are not redistributed here. ScanNet requires each user to sign its Terms of Use with the ScanNet team, so mirroring the scans — or point clouds derived from them — would breach those terms.

Download the scans from their original sources (ScanNetV2, SUN RGB-D) and follow the preparation steps in the GitHub repo. The annotation-index .pkl files we used are on Peisheng/LDMR-data, which lets you skip the index-building step but not the scan extraction.

License

CC BY-NC 4.0, inherited from TR3D. Non-commercial use only. These weights are derived from models trained on ScanNet and SUN RGB-D; their respective terms of use continue to apply.

Citation

@inproceedings{qian2026ldmr,
  title     = {Breaking the Model Forgetting Cycle in Long-Incremental 3D Object Detection},
  author    = {Qian, Peisheng and Xu, Jie and Yang, Xulei and Zhao, Na},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2026}
}

Built on TR3D and mmdetection3d; incremental protocols follow SDCoT.