# LaserAct checkpoints

Every trained model behind the paper, 270 checkpoints in seven archives, so
any number in the tables can be checked without spending GPU hours on
retraining.

Each checkpoint is a plain PyTorch `state_dict` and travels with the JSON its
training run wrote. That JSON carries the architecture, the split, the seed and
the accuracies the paper reports, which is what makes a bare tensor file
reproducible instead of merely downloadable.

## Archives

| archive | contents | models | size |
|---|---|---|---|
| `laseract_ckpt_action_xsub.tar` | action recognition, cross-subject split | 74 | 291 MB |
| `laseract_ckpt_action_xtake.tar` | action recognition, cross-take split | 48 | 232 MB |
| `laseract_ckpt_person.tar` | the same grids on RGB-supervised person crops | 63 | 195 MB |
| `laseract_ckpt_loso.tar` | leave-one-subject-out, nine folds across five sensors | 45 | 86 MB |
| `laseract_ckpt_reid.tar` | person re-identification, plus the ModelNet-pretrained encoder | 15 | 27 MB |
| `laseract_ckpt_pose.tar` | two-stage 3D pose estimation | 16 | 38 MB |
| `laseract_ckpt_raycast.tar` | trained on Velodyne scenes resampled along another sensor's rays | 9 | 17 MB |

`SHA256SUMS` covers all seven. Verify with `sha256sum -c SHA256SUMS`.

## Use

Each archive extracts into the layout of the code repository, so unpack it at
the repository root and every checkpoint lands beside the run record it belongs
to:

```bash
tar xf laseract_ckpt_action_xsub.tar -C laseract/     # -> baseline/runs/*.pt
```

Then evaluate one, which rebuilds the model from the run record and prints the
reproduced accuracy next to the recorded one:

```bash
export LASERACT_ROOT=/path/to/laseract        # release and precomputed cache
python baseline/eval_ckpt.py baseline/runs/xsub_velodyne_pointnet-gru_p1024_s0.pt
```

```
xsub_velodyne_pointnet-gru_p1024_s0: pointnet-gru trained on velodyne, xsub split, 911 test sequences
evaluated on       recorded reproduced    delta
velodyne              22.9%      22.9%    0.00
livox                  5.0%       5.0%    0.01
cepton                 9.6%       9.7%    0.01
blickfeld              1.6%       1.6%    0.00
depth                  3.7%       3.7%    0.00
```

Evaluation needs the release and the precomputed clip cache
(`baseline/precompute_cache.py`, and `precompute_cache_person.py` for the
person-crop models); the checkpoints alone are not enough. A model evaluates
on every sensor, not only the one it was trained on, which is where the
cross-sensor matrix comes from.

## Naming

`<split>_<sensor>_<model>-<temporal>_p<points>_s<seed>.pt`, for example
`xtake_blickfeld_sparseconv-gru_p1024_s2.pt`. The two exceptions are
`modelnet_encoder.pt`, the ModelNet40-pretrained encoder used to initialise
the few-shot runs, which has no run record because it was not trained on
LaserAct, and the pose checkpoints, which follow
`p2_<sensor>_<arch>_<target>_s<seed>.pt` and store the architecture inside the
file.

## Licence

Same terms as the dataset, CC BY-NC 4.0.