---
datasets:
- avihaig/dlogps-cables
license: cc-by-4.0
pipeline_tag: robotics
tags:
- pytorch
- graph-transformer
- graphgps
- attention-bias
- learned-simulator
- physics-simulation
- deformable-linear-objects
- cable
- robotics
---

# Predicting Cable Dynamics with Physical Attention Bias: checkpoints

The final checkpoints (step 100,000) of the 39 runs reported in **Predicting
Cable Dynamics with Physical Attention Bias**, an extended abstract at the
NeurIPS 2026 Workshop on Symmetry and Geometry in Neural Representations
(NeurReps).

**Authors:** Avihai Giuili\*, Rotem Atari\*, Avishai Sintov (Tel Aviv
University), Maya Bechler-Speicher (Meta AI). \*Equal contribution.

**Paper:** [arXiv:2610.11975](https://arxiv.org/abs/2610.11975) ·
**Code:** [github.com/avihaig/dlogps](https://github.com/avihaig/dlogps) ·
**Dataset:** [avihaig/dlogps-cables](https://huggingface.co/datasets/avihaig/dlogps-cables)

## The model

A GraphGPS-style learned simulator of a falling cable (33 vertices). Each layer
runs a GatedGCN over the chain edges in parallel with dense attention over all
vertices. A *physical attention bias* subtracts a distance, scaled by one learned
rate per head, from the attention logits. The variants differ only in which
distance each head receives: arc-length along the cable (chain), Euclidean
distance in space, both, or none. The model predicts per-vertex displacements
and is rolled out autoregressively. The block is d = 128, 8 heads, 4 layers
(891k parameters), trained 100k steps at batch 512.

## What is here

The layout is the code repository's `results/runs/`. Each
`<experiment>/<label>/` folder holds the checkpoint
`checkpoints/step_100000.pt` and the run's record: the resolved `config.yaml`,
`env.json` (code version, library versions, GPU, timings), the training log
(`train_log.jsonl`, `train_log.txt`) and the unseen-test scorecard under
`eval/model/` (summary, per window, per cable, per frame).

| experiment | labels (seeds 0, 1, 2) | model |
|---|---|---|
| `local_on` | `varA_s*`, `varB_s*`, `varC_s*`, `varD_s*`, `varF_s*` | hybrid block: GatedGCN and global attention |
| `local_off` | the same | global attention only |
| `chain_only` | `chain_s*` | GatedGCN only, no attention |
| `structfree` | `mlp_pernode_s*`, `lstm_global_s*` | per-node MLP, global LSTM |

The records keep the experiment names and labels the runs had during
development (for example `b7_encoding`, `varF_enc_s0`). `provenance.csv` maps
each folder to its source run, the commit of the authors' development
repository it ran from, and whether that working tree had uncommitted changes.
Every checkpoint loads in the public code, and every cell of the paper's Tables
1 and 2 is recomputed from these records. The local-on runs predate the phase
split that Table 2 reads, so each `local_on` folder also holds
`eval/rescore/`: its checkpoint re-scored with the public code
(`scripts/evaluate_final.sh`) on the released test root.

Variant letters, for the 8 heads: **A** Unbiased · **B** Euclidean on every
head · **C** Chain on every head · **D** Mixed (two heads Euclidean, two chain,
four unbiased) · **F** Euclidean+Chain only (four heads each).

## Usage

```bash
git clone https://github.com/avihaig/dlogps && cd dlogps && uv sync
scripts/fetch_checkpoints.sh   # all 39 into results/runs/<experiment>/<label>/checkpoints/
```

```python
from dlogps.harness.train import load_checkpoint

ckpt = load_checkpoint("results/runs/local_on/varF_s0/checkpoints/step_100000.pt")
model = ckpt.restore_model()   # eval mode; the input normalization is ckpt.stats
```

To re-score a checkpoint on the paper's test set, fetch `unseen_cables_test`
from the [dataset](https://huggingface.co/datasets/avihaig/dlogps-cables), link
it with `scripts/link_data.sh`, and run
`scripts/evaluate_final.sh results/runs/local_on/varF_s0`.

Each file is a `torch.save` dictionary of tensors and plain values with no
pickled classes, so it loads with `torch.load(path, weights_only=True)`.

## Results

Unseen-cable test, 400 windows of 400-frame rollouts. Cell: mean of seed means
± mean of window sds ± sd of seed means; bold is the lowest mean in its block.
Lower is better.

| | rel ℓ2 (frac. of L) | link-length drift δ (frac. of ℓ0) | self-intersection v (frac. of frames) |
|---|---|---|---|
| *local stream on* | | | |
| Unbiased | 0.0325 ± 0.0281 ± 0.0058 | 0.0300 ± 0.0159 ± 0.0032 | 0.171 ± 0.231 ± 0.009 |
| Euclidean | 0.0320 ± 0.0267 ± 0.0042 | 0.0303 ± 0.0135 ± 0.0021 | 0.174 ± 0.229 ± 0.032 |
| Chain | 0.0316 ± 0.0341 ± 0.0057 | 0.0271 ± 0.0124 ± 0.0023 | 0.167 ± 0.227 ± 0.030 |
| Mixed | 0.0302 ± 0.0251 ± 0.0067 | **0.0267 ± 0.0109 ± 0.0030** | 0.168 ± 0.229 ± 0.012 |
| Euclidean+Chain only | **0.0297 ± 0.0288 ± 0.0035** | 0.0275 ± 0.0129 ± 0.0007 | **0.165 ± 0.229 ± 0.012** |
| *local stream off* | | | |
| Unbiased | 0.0399 ± 0.0246 ± 0.0002 | 0.1693 ± 0.1891 ± 0.0030 | 0.216 ± 0.258 ± 0.006 |
| Euclidean | 0.0382 ± 0.0279 ± 0.0007 | 0.1470 ± 0.2232 ± 0.0178 | 0.208 ± 0.262 ± 0.020 |
| Chain | **0.0339 ± 0.0195 ± 0.0008** | 0.0783 ± 0.0382 ± 0.0040 | 0.174 ± 0.241 ± 0.004 |
| Mixed | 0.0352 ± 0.0211 ± 0.0016 | **0.0779 ± 0.0455 ± 0.0036** | 0.172 ± 0.242 ± 0.016 |
| Euclidean+Chain only | 0.0343 ± 0.0202 ± 0.0002 | 0.0784 ± 0.0409 ± 0.0013 | **0.161 ± 0.234 ± 0.006** |
| *baselines* | | | |
| chain only | 0.0925 ± 0.0838 ± 0.0720 | 0.0812 ± 0.0589 ± 0.0322 | 0.115 ± 0.191 ± 0.024 |
| MLP | 0.0868 ± 0.0785 ± 0.0163 | 1.35 ± 2.32 ± 0.73 | 0.435 ± 0.256 ± 0.010 |
| LSTM | 0.1070 ± 0.0911 ± 0.0397 | 0.2819 ± 0.3124 ± 0.0509 | 0.082 ± 0.150 ± 0.031 |

## Citation

```bibtex
@inproceedings{giuili2026predicting,
  title         = {Predicting Cable Dynamics with Physical Attention Bias},
  author        = {Giuili, Avihai and Atari, Rotem and Sintov, Avishai and Bechler-Speicher, Maya},
  booktitle     = {NeurIPS 2026 Workshop on Symmetry and Geometry in Neural Representations (NeurReps)},
  year          = {2026},
  eprint        = {2610.11975},
  archivePrefix = {arXiv},
  primaryClass  = {cs.RO},
  url           = {https://arxiv.org/abs/2610.11975}
}
```

## License

CC BY 4.0, the license of the paper. The code repository is MIT.