Simulated trajectories of cables released from a randomized pose and falling onto a floor. This is the dataset behind 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 · Code: github.com/avihaig/dlogps · Trained models: avihaig/dlogps-checkpoints

root	cables	episodes	role
`release_train/`	46	4,597	the training set of every model in the paper
`unseen_cables_test/`	40	1,200	the paper's test set: cables that never appear in training
`seen_cables_test/`	the 46 training cables	1,378	new release poses of the training cables; not used in the paper

About 26 GB in 270 files (release_train 16.6 GB, seen_cables_test 5.0 GB, unseen_cables_test 4.4 GB). release_train holds 100 release poses per cable, from two generator runs of 50 poses each (seed 0, then seed 1). The test roots hold 30 poses per cable (unseen_cables_test seed 3, seen_cables_test seed 2). The 40 test cables lie inside the parameter ranges of the training cables but never appear in training.

The training cables span rest length 0.80 to 1.60 m, diameter 1.5 to 10 mm and five Young's moduli from 10^6 to 10^9 Pa, in five material classes with their own density and joint damping. The populations are listed in configs/release_cables.csv and configs/unseen_cables_test.csv.

Removed episodes

Five recorded episodes are solver divergences, where the cable jumps metres between two frames. The code's loader has always dropped them (any vertex moving more than 5 cm in one frame), so no model saw them, and the released files leave them out:

root	cable	original episode indices
`release_train`	029	45, 78
`release_train`	037	86
`seen_cables_test`	029	22
`seen_cables_test`	037	15

Each affected cable's params.yaml maps the remaining episodes to their original indices under release_filter, and release_train/MERGED_FROM.txt records the merge and the removals. The paper's test set lost nothing.

How the data was generated

MuJoCo 3.9.0. Each cable is a 32-segment chain (33 vertices) under the MuJoCo cable elasticity plugin, twist-to-bend ratio G/E = 0.38, integrator implicitfast at a 4.2e-4 s time step.
The scene is a floor (the plane z = 0) and two grippers welded to the cable ends. Each episode settles the cable, drives the grippers to a randomized pose, then releases both welds on the same tick. t = 0 is that instant.
Kinematics are recorded at a nominal 500 Hz until the 95th percentile of vertex speed stays below 1 cm/s for 0.5 s, or for at most 5 s. The achieved rate is quantized to whole simulator steps, so take the time step from t, not from record_hz.
Self-collision is permitted and common: the soft cables fold onto themselves.

Every physical and protocol value is recorded in configs/release.yaml and the three files that extend it, in the code repository.

Format

<root>/
  cable_000/
    episodes.npz    vertex_pos, vertex_vel   (episodes, T_pad, 33, 3)   float64, metres
                    edge_quat (..., 32, 4)  edge_omega (..., 32, 3)  edge_wrench (..., 32, 6)
                    t (episodes, T_pad)     episode_lengths (episodes,)
                    record_hz, cable_id, length, diameter, bend_stiffness,
                    joint_damping, effective_linear_density   (scalars)
    params.yaml     the cable's parameters, derived constants, protocol values,
                    and the per-episode release record
  cable_001/ ...
  index.csv         the population, with each cable's released episode count
  datagen.yaml      the generator's provenance (MERGED_FROM.txt in release_train)

Arrays are padded to a common length: past episode_lengths[e] there is one -1 stop token, then NaN. Read episode counts from episode_lengths or index.csv. A training cable's params.yaml comes from the seed-0 run, so its release record covers 50 episodes, except for cables 029 and 037, whose files were rebuilt from both runs. In the test roots, datagen.yaml records the generation run (30 episodes per cable).

Usage

Download everything, or one root:

hf download avihaig/dlogps-cables --repo-type dataset --local-dir dlogps-data
hf download avihaig/dlogps-cables --repo-type dataset --include "unseen_cables_test/*" --local-dir dlogps-data

With the code repository:

git clone https://github.com/avihaig/dlogps && cd dlogps
export DLOGPS_DATA=/path/to/dlogps-data && scripts/link_data.sh

With NumPy alone:

import numpy as np
from huggingface_hub import hf_hub_download

path = hf_hub_download("avihaig/dlogps-cables", "unseen_cables_test/cable_000/episodes.npz",
                       repo_type="dataset")
d = np.load(path)
for e, n in enumerate(d["episode_lengths"]):
    t = d["t"][e, :n]              # (n,) seconds since release
    pos = d["vertex_pos"][e, :n]   # (n, 33, 3) metres

Citation

@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}
}