Downloads · 30 days
0
gn01697933/tartanimu-iros2026-unified-model
tartanimu-iros2026-unified-model is a machine learning model from gn01697933. Use it for the machine learning task on the model card, and read the license before you ship it in a product. It is set up for pytorch. The card lists the license as cc-by-nc-4.0.
Team thisray (Kaggle leaderboard name) · Author: Ssu-Rui Lee (Team Leader), RaydioTek, Taiwan · Contact: [email protected]
Downloads · 30 days
0
Access
Public
Updated Sep 24, 2026
Repo size
350 MB
Likes
0
Public
Click a slice to open those files.
.pt350 MB · 98%
From the Hugging Face model README
Team thisray (Kaggle leaderboard name) · Author: Ssu-Rui Lee (Team Leader), RaydioTek, Taiwan ·
Contact: [email protected]
Primary candidate. The technical report describes
D_union_H_G2(S-C3, Kaggle submission56353966) as its primary system and reports the second selected final,D_union_H_G2_SC6(S-C6,56353958), alongside it. Both selected finals ship here unchanged; both were selected as Kaggle finals because their validation and test orderings disagreed and the observed differences were small. The API check on 2026-09-24 did not return private scores.The technical report and the team report (
report_thisray.md, in this repository) are the authoritative description of the system.
| Kaggle submission | Candidate | File uploaded to Kaggle | Same bytes in this repo | CSV MD5 | Reproduce with |
|---|---|---|---|---|---|
| 56353966 (Public 0.22610), primary system of the technical report | S-C3, D_union_H_G2 | r15z_D_union_H_G2.csv | submission_D_union_H_G2.csv | 7a3fab85c4da99588f02d90f2e90c2b6 | python inference.py --data-root <competition-root> --output submission_D_union_H_G2.csv --device cuda --pipeline pipeline_D_union_H_G2.json |
| 56353958 (Public 0.22738), second selected final | S-C6, D_union_H_G2_SC6 | r15z_D_union_H_G2_SC6.csv | submission.csv | 5381dadd49140b23558cb18159088391 | python inference.py --data-root <competition-root> --output submission.csv --device cuda (default pipeline.json) |
<competition-root> holds test/ and index/test_windows.csv. Environment: Python 3.11 and
pip install -r requirements.txt; on linux-aarch64, conda-linux-aarch64.lock gives byte-identical
output (see "Quick start").tartanimu-technical-report-thisray.pdf in this repository
(compliance answers in Appendix B, every inference constant in Appendix F), with the organizers'
starter-template team report report_thisray.md. The rest of this page is detailed release notes.inference.py, tartanimu_release/, vendor/): Apache-2.0.weights/) and the prediction CSVs: CC-BY-NC-4.0.The repository header declares cc-by-nc-4.0, the more restrictive of the two, because the weights
dominate what is distributed here. The non-commercial term is not a preference: the competition
dataset these weights were trained on "may be used only for the purpose of this competition and
academic research. It must not be used for any commercial purpose", and weights derived from it are
not given a more permissive licence than the data they come from.
Body-frame velocity for every 1-second window of the 89 test trajectories, computed end to end from
the raw 6-axis IMU by one program, inference.py:
D_union, the same dog3 operator for the human stage). Question (2) of the
compliance section describes the detectors in full.D_union_H_G2). G2 runs
immediately after WORLD G1. It estimates attitude from IMU only, fits the accelerometer-integrated
velocity independently in consecutive 20-window segments, fits the body-heading gauge to the current
G1 prior, blends both outputs 0.5/0.5, and uses the frozen released-train-only selector to accept or
reject the result per trajectory._gain pipelines only). After every other stage and immediately
before the submission CSV is written, each row's current prediction is judged by its float64
Euclidean norm; rows whose speed is at least 1.0 m/s have all three velocity components multiplied
by that candidate's fixed constant (1.0200 for the main candidate, 1.0225 for the strict one) and
every other row is left unchanged. The stage never alters rows, their order or window_id.
Neither claimed candidate uses it.The package holds seven candidates in eight pipeline files. Every candidate runs the same program; its
pipeline file fixes everything else: the weight set (weight_set, which names the set and its
manifest weights/manifest_<set>.json) and the stage operators and detector frequencies.
| Pipeline file | Candidate | Weight set | Stages | Reference output sha256 |
|---|---|---|---|---|
pipeline.json (default; the same bytes as pipeline_D_union_H_G2_S-C6.json) | D_union_H_G2_SC6 (main) | S-C6 | network prior, readout, BODY (speed_sig, union of the 0.5, 1 and 5 Hz detectors), WORLD G1 (union detector), WORLD G2, dog, car, human | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf |
pipeline_D_union_H_G2_S-C6.json | D_union_H_G2_SC6 (main) | S-C6 | as pipeline.json | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf |
pipeline_B_H_G2_S-C6.json | B_H_G2_SC6 (strict) | S-C6 | network prior, readout, BODY (frozen_sig1, 0.5 Hz detector), WORLD G1 (1 Hz detector), WORLD G2, dog, car, human | f829182d66913a0a43ba4a77937778128539683ce18bc326984ce638165bb8b4 |
pipeline_D_union_H_G2_S-C6_gain.json | D_union_H_G2_SC6_gain | S-C6 | main candidate, then final fast-window gain (threshold_mps 1.0, factor 1.0200) | package canonical: 5350c541861d269e54078018ff25c2dc138afda621779d161fd12336a817cd69 |
pipeline_B_H_G2_S-C6_gain.json | B_H_G2_SC6_gain | S-C6 | strict candidate, then final fast-window gain (threshold_mps 1.0, factor 1.0225) | package canonical: 0f2134ade8bd4b1d540fb726d3882c12e1da4ae2fdfc2c67cd17b7d318976530 |
pipeline_D_union_H_G2.json | D_union_H_G2 | S-C3 | as the main candidate | 9e9c254e6bfcc295e541ea9e2254ae93f94a53d7d208c29160ebe9ecce8b9a83 |
pipeline_D_union_H.json | D_union_H | S-C3 | as D_union_H_G2, without WORLD G2 | 21ced71e8f5a95464a1412d5eeb40fc3e8d7ef7e22aff9821cd78b7fda158fc6 |
pipeline_D_union.json | D_union | S-C3 | as D_union_H, without the human stage | e5ff5f5a5f8dd7239dbd2eb58515bb0131cf97c50f70f643acab161e3a46365e |
submission.csv in this repository is the default pipeline's output (D_union_H_G2_SC6), and
submission_D_union_H_G2.csv is the output of pipeline_D_union_H_G2.json. Both are exactly the
files the team uploaded to Kaggle, so whichever of the two is claimed, the prediction file that
produced the claimed leaderboard score is already in this repository.
Every row below is a file this package reproduces. The Kaggle columns are facts from the team's submission history. The table marks the report's primary candidate (S-C3), the second selected Kaggle final (S-C6), and the other released candidates.
The team's two selected Kaggle final submissions are D_union_H_G2_SC6 (ref 56353958) and
D_union_H_G2 (ref 56353966); the prediction file of each is shipped in this repository so that
either can be the claimed result without any change to the model or the code.
| Candidate (pipeline file) | Weight set | Submission file in this repository | sha256 / MD5 | Claimed as final | Official scoring service, all 89 test trajectories | Kaggle submission | Kaggle Public | Kaggle Private |
|---|---|---|---|---|---|---|---|---|
D_union_H_G2_SC6 (pipeline.json, default) | S-C6 | submission.csv (30,644 rows, window_id,vx,vy,vz) | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf / 5381dadd49140b23558cb18159088391 | selected as a Kaggle final; reported in the technical report alongside the primary system | 0.18835 (2026-09-20) | 56353958, 2026-09-19 08:47:43 UTC | 0.22738 | not returned by the API at the report check on 2026-09-24 |
D_union_H_G2 (pipeline_D_union_H_G2.json) | S-C3 | submission_D_union_H_G2.csv (30,644 rows) | 9e9c254e6bfcc295e541ea9e2254ae93f94a53d7d208c29160ebe9ecce8b9a83 / 7a3fab85c4da99588f02d90f2e90c2b6 | primary system of the technical report; selected as a Kaggle final | 0.18775 (2026-09-20) | 56353966, 2026-09-19 08:48:07 UTC | 0.22610 | not returned by the API at the report check on 2026-09-24 |
B_H_G2_SC6 (pipeline_B_H_G2_S-C6.json) | S-C6 | written by inference.py --pipeline pipeline_B_H_G2_S-C6.json | f829182d66913a0a43ba4a77937778128539683ce18bc326984ce638165bb8b4 / 243ae6b354a9e40b57ac2df3aaba8c2a | not claimed | not scored | 56353963, 2026-09-19 08:47:56 UTC | 0.28152 | - |
D_union_H (pipeline_D_union_H.json) | S-C3 | written by inference.py --pipeline pipeline_D_union_H.json | 21ced71e8f5a95464a1412d5eeb40fc3e8d7ef7e22aff9821cd78b7fda158fc6 / 136e1da0e34da0adfcdd737ed31e95c6 | not claimed | not scored | 56332657, 2026-09-18 14:37:30 UTC | 0.23035 | - |
D_union (pipeline_D_union.json) | S-C3 | written by inference.py --pipeline pipeline_D_union.json | e5ff5f5a5f8dd7239dbd2eb58515bb0131cf97c50f70f643acab161e3a46365e / dc01d6db3f765e366ed27d9d48389ed0 | not claimed | 0.19503 | 56272462, 2026-09-16 07:03:27 UTC | 0.23548 | - |
D_union_H_G2_SC6_gain (pipeline_D_union_H_G2_S-C6_gain.json) | S-C6 | written by inference.py with the named pipeline | package canonical 5350c541861d269e54078018ff25c2dc138afda621779d161fd12336a817cd69 / 37b4af23a205468d3468edf437174883; development-format a5083c2230a955951722e197737041812eb1a9e8b83f8f4b6262259a41c5b01b / f1d6ff494decc095e826debb09f81f4e | not claimed | not scored | 56375243, 2026-09-20 00:56:04 UTC | 0.22815 | - |
B_H_G2_SC6_gain (pipeline_B_H_G2_S-C6_gain.json) | S-C6 | written by inference.py with the named pipeline | package canonical 0f2134ade8bd4b1d540fb726d3882c12e1da4ae2fdfc2c67cd17b7d318976530 / 56c39e55cbe515aedf0130e755935b98; development-format cec8a31f237bde32ada52aa1469baff70e43b844d1c4aa0047923bec9c07de42 / 2598359b9c13a3bcc857a8563b30793a | not claimed | not scored | 56375474, 2026-09-20 01:06:29 UTC | 0.27978 | - |
The two _gain pipelines are shipped for completeness because they were submitted to the leaderboard;
neither was selected as a final. The union candidate worsened on Public from 0.22738 to 0.22815,
while the strict candidate improved from 0.28152 to 0.27978. Neither selected final uses the
additional fast-window gain stage; the BODY stage retains its own conditional rescaling.
How the files relate (row counts from the files themselves):
frozen_sig1 operator instead of the union detector and speed_sig.D_union_H and D_union are identical except on the 10 test trajectories that the human detector
selects (11,264 of 30,644 rows).Both claimed prediction files ship with the receipt of the run that produced them, and both receipts were written by exactly the code in this repository:
| Prediction file | Receipt | Run | Produced by | Output sha256 |
|---|---|---|---|---|
submission.csv | submission.receipt.json | l24-b1 | inference.py --pipeline pipeline_D_union_H_G2_S-C6.json --device cuda | dd01a43f..., byte-identical |
submission_D_union_H_G2.csv | submission_D_union_H_G2.receipt.json | l24-b3 | inference.py --pipeline pipeline_D_union_H_G2.json --device cuda | 9e9c254e..., byte-identical |
pipeline_D_union_H_G2_S-C6.json is byte-identical to the default pipeline.json, so l24-b1 is the
default candidate; it was invoked with the pipeline named explicitly rather than by default. Each
receipt's package block equals the code that ships here - python_files 97, sha256_of_listing
d2d1ebdc..., inference_py_sha256 f119fd59... - so a re-run of this package reproduces both the file
and its receipt's fingerprint. On the reference setup, non-gain candidates reproduce their
development CSVs byte for byte. The two gain variants reproduce all float64 values exactly
but use different decimal formatting (see "Verification").
History of the package code. An earlier revision of this repository shipped run k1's receipt, whose
package block reads python_files 96, sha256_of_listing d916f502..., inference_py_sha256
500d3787.... The package gained one file after that run, at commit 7eab1177: the pre-registered
fast-window gain stage, tartanimu_release/fast_window_gain.py and the apply_final_gain call in
inference.py. That stage is inert for every claimed candidate - their pipeline files carry no
gain key, so apply_final_gain returns its input unchanged - and runs l24-b1 and l24-b3 above,
executed at that commit, reproduce both claimed files byte for byte. Note that only *.py files enter
code_fingerprint(), so a CSV, this card or run_inference.sh never changes any of the three values.
# Python 3.11 with the pinned packages (torch 2.13.0 + CUDA 13 wheels, numpy 2.4.6, scipy 1.17.1, pandas 3.0.5)
conda create -n tartanimu-release python=3.11.16 pip && conda activate tartanimu-release
pip install -r requirements.txt
python inference.py --data-root /path/to/competition --output submission.csv --device cuda
# the strict candidate B_H_G2_SC6 (same S-C6 weight set):
python inference.py --data-root /path/to/competition --output submission_B_H_G2_SC6.csv --device cuda --pipeline pipeline_B_H_G2_S-C6.json
# the candidates on the S-C3 weight set:
python inference.py --data-root /path/to/competition --output submission_D_union_H_G2.csv --device cuda --pipeline pipeline_D_union_H_G2.json
python inference.py --data-root /path/to/competition --output submission_D_union_H.csv --device cuda --pipeline pipeline_D_union_H.json
python inference.py --data-root /path/to/competition --output submission_D_union.csv --device cuda --pipeline pipeline_D_union.json
--output defaults to submission.csv in the current directory and --pipeline to pipeline.json
(D_union_H_G2_SC6). The pipeline file also selects the weight set, so there is no separate weights
argument; inference.py refuses to run if the manifest named by the pipeline belongs to another weight
set or if any weight file differs from the sha256 in that manifest.
inference.py takes one --data-root that contains the test trajectories and the window index in the
competition's published layout. When the trajectory directory and the window index CSV are separate
paths, run_inference.sh takes them as two arguments instead:
# (a) one competition directory (<root>/test/<traj_id>.npz and <root>/index/test_windows.csv)
python inference.py --data-root /path/to/competition --output submission.csv --device cuda
# (b) the trajectory directory and the window index CSV as separate paths
./run_inference.sh --test-dir /path/to/trajectories \
--windows-csv /path/to/test_windows.csv \
--output submission.csv --device cuda
run_inference.sh is a POSIX shell script. It assembles a temporary directory of symlinks in the
layout above, runs the unmodified inference.py against it, and removes the temporary directory
on exit, including on error or interrupt. It adds no Python file and changes none, so the package
fingerprint a run reports is the same whichever form is used. It accepts the same
--pipeline, --output and --device options, plus --sample-submission for the file that fixes the
output row order (auto-detected when it sits beside the trajectory directory or the window index CSV,
as it does in the released competition directory). Set PYTHON to choose the interpreter; the default
is python3. Missing or unreadable paths abort before any computation, with a message naming the
argument, and exit status 2.
Form (b) was verified end to end on the reference machine: run h5-w1 in "Verification".
Which environment to use, by architecture. The reference machine is linux-aarch64, so
conda-linux-aarch64.lock pins that platform and cannot be used anywhere else. Both paths were
measured; neither is a guess.
conda create -n tartanimu-release --file conda-linux-aarch64.lock, then
pip install -r requirements.txt. This reproduces the shipped CSVs byte for byte.pip install -r requirements.txt into a fresh CPython 3.11 environment. The
pinned stack installs cleanly (measured: exit 0 in 132 s, pip freeze matching all 38 pins,
torch 2.13.0+cu130 with CUDA available). The run completes well inside the host limits, and the
stage routing is identical to the aarch64 reference on all 89 trajectories. The predicted
values differ slightly; see the table below.D_union_H_G2_SC6 | D_union_H_G2 | |
|---|---|---|
| Wall-clock against the 2 h limit | 2,040 s (28.3%) | 2,067 s (28.7%) |
| Peak GPU memory against 16 GB | 489 MiB (3.0%) | 489 MiB (3.0%) |
| Peak host RSS | 1.80 GiB | 1.80 GiB |
| Stage routing vs the reference | identical, all 89 trajectories | identical, all 89 trajectories |
| Max absolute velocity-component difference | 2.0907e-4 m/s | 3.6740e-4 m/s |
| Mean / p99 difference | 5.37e-6 / 4.83e-5 m/s | 5.55e-6 / - |
| Official rescoring of these outputs | not performed | not performed |
Cross-environment comparison. For S-C6 on the same T4, the tested PyTorch 2.13.0+cu130 and 2.10.0+cu128 stacks produced identical network priors; changing the tested CPU numerical packages changed final values by at most 5.567e-9 m/s. These comparisons locate most of the observed discrepancy in the network forward pass. They do not establish hardware-independent bit identity or a rigorous bound on the change in the full challenge score.
A caveat about this repository's own earlier wording. requirements.txt states that the PyPI
numpy/scipy wheels cost "at most 6.6e-5 m/s per window". That figure is an aarch64 measurement and
does not hold on another accelerator - it is 3.2x and 5.6x larger for the two candidates above.
Use the table, not that sentence.
Two practical requirements for an x86_64 host.
torch 2.13.0+cu130 is compiled for sm_75, sm_80, sm_86, sm_90, sm_100, sm_120 (measured). A P100 (sm_60) or V100 (sm_70) cannot run the pinned stack at all;
use a wheel compatible with the target GPU. P100/V100 were not tested; the T4 package comparison
above does not establish numerical behavior or compatibility on those GPUs.numpy==2.4.6 publishes no cp310 wheel).Run the test set as one unit for byte-exact comparison. Changing the trajectory
set changes network batch composition; the five-trajectory subset differed from
the full 89-trajectory run by at most 1.6e-5 m/s. Context, proposal fits, and
aggregation remain within each trajectory. Point --data-root at the complete
competition directory when reproducing the submitted CSV.
Byte-identical output is claimed only for the measured reference setup. On the T4, use the measured numerical differences and stage agreement above; weight and source hashes establish artifact identity separately from output rounding.
/path/to/competition needs index/test_windows.csv and test/<traj_id>.npz (keys imu, ts,
fs); sample_submission.csv, when present, only fixes the row order. The program reads nothing else
outside this repository and the installed packages, opens no network connection (an audit hook raises
on any socket use), writes submission.csv plus submission.receipt.json (timings, peak GPU memory,
weight hashes, per-trajectory detector statistics and stages), and needs one GPU.
| Measured on the reference machine (NVIDIA GB10, aarch64) | D_union_H_G2_SC6 (default), run k1 (GPU and CPU shared with other jobs) | B_H_G2_SC6, run k2 (same conditions as k1) | D_union, run r1 (GPU not shared) | Host limit |
|---|---|---|---|---|
| Wall-clock, 89 trajectories, end to end | 1,599 s (network prior 963 s on the shared GPU, physics stages 631 s on one CPU thread, of which WORLD G2 210 s) | 1,644 s (network prior 970 s, physics stages 669 s, of which WORLD G2 238 s) | 458 s (network prior 271 s on GPU, physics stages 186 s on one CPU thread) | 2 h |
| Peak GPU memory (PyTorch allocator: allocated / reserved) | 270 MiB / 386 MiB | 270 MiB / 386 MiB | 270 MiB / 386 MiB | 16 GB |
| Peak GPU memory of the process (nvidia-smi, includes the CUDA context) | 601 MiB | 601 MiB | 601 MiB | 16 GB |
| Peak host memory (max RSS) | 1.95 GiB | 1.96 GiB | 2.0 GiB | - |
| Network access | none needed; verified inside a network namespace with loopback only | same | none needed; verified in run r2 (network namespace with loopback only) | none |
The k1 and k2 times are upper bounds for this machine: together with a third run (k3 in "Verification") they shared the GPU with one process of another project while the host CPU was loaded by other jobs (load average about 15-30, the runs at nice 10), so the network prior took about 3.5 times as long as in the idle-GPU run r1. Both weight sets have the same network, so the network-prior cost does not depend on the weight set (k3, S-C3: 1,021 s in the same batch). WORLD G2's extra cost is CPU time: 200-237 s of CPU time over the 34 trajectories the WORLD detector selects (runs k1-k3; 292 s in the busier conditions of the previous version's run g1). The human stage's extra cost, measured on 2026-09-18 in similar conditions, was 133 s (runs h1 and h2).
tartanimu_release/network_prior.py)Architecture FullExposureQueryContext (vendor/src/tartanimu/models/query_context.py, base class in
full_exposure_body.py): a per-window raw-IMU encoder (convolutional stems and a 4-layer transformer
over each 200-sample window) feeds eight jointly trained recurrent (GRU) velocity branches that run
over up to 64 consecutive windows of the same trajectory and emit velocities for the 16 query windows.
The velocity output is the mean of the eight branches plus one shared, confidence-gated low-frequency
(DCT) residual. Inputs: raw accelerometer and gyroscope samples only.
Test-time operator: every 16-window query view at stride one window; the prior of a window is the coordinate-wise median of its branch-mean-plus-DCT velocities over the views that contain it (1 to 16 views; 16 for interior windows).
Weights: two weight sets, each an element-wise float64 average, with equal weights, of checkpoints
that share one warm start (train-only H64 checkpoint, sha256 8742f820...) and were each fine-tuned
for 50 epochs on released train+val (EMA 0.999, fixed terminal epoch 50, no epoch selection), with
one of three recipes:
TV - no rotation augmentation;A2 - finite body-coordinate tilt augmentation up to 45 degrees, probability 0.5;SO3 - Haar-uniform SO(3) rotation, probability 0.5.Both rotation recipes use the same allowlist of 147 BODY-stored trajectories in released train, across all four platforms. The 41 BODY-stored validation trajectories and WORLD-stored streams are excluded from rotation augmentation, even though final members train on train+validation.
| Weight set | File | Members (recipe, seed, sha256 of the member checkpoint) |
|---|---|---|
| S-C6 (default; main and strict candidates) | weights/soup_S-C6/network_soup_S-C6.pt | six: TV seed 17 (a3248af3...), TV seed 18 (49d4f7ff...), A2 seed 17 (35fb3abe...), A2 seed 18 (ba70a6f8...), SO3 seed 17 (08981685...), SO3 seed 18 (135a76ef...) |
S-C3 (D_union_H_G2, D_union_H, D_union) | weights/network_soup_S-C3.pt | three: TV seed 17 (a3248af3...), A2 seed 17 (35fb3abe...), SO3 seed 17 (08981685...) |
The seed-18 members repeat the seed-17 members' recipes with only the seed changed. S-C6 contains every member of S-C3. Both soups have the same architecture and configuration (one state dict of 266 tensors, 43,669,432 parameters).
Training losses of the members include an auxiliary platform-classification loss (weight 0.1) and a
frame-family head. These heads are outputs only: the velocity does not depend on them (randomising
their weights leaves the velocity bitwise unchanged on test batches), and at test time the platform
input is absent (platform_id = -1 for every test window).
tartanimu_release/physics.py: apply_readout)SharedPhysicsReadout (vendor/src/tartanimu/models/exact_mean_readout.py)
uses BODY- and WORLD-frame strapdown proposals fitted to the incoming neural
prior and raw IMU over 16-window chunks. Its 18 features summarize proposal
corrections, prior motion, IMU statistics, and fit conditioning. A fixed
residual-based logit anchor is added to a learned correction:
r = max(expm1(f[0:2]), 0);
ell = log_softmax(-r / 0.10);
z = clip((f - center) / scale, -8, 8);
alpha = softmax([0, ell[0], ell[1]] + W2 tanh(W1 z + b1) + b2).
The 18 → 12 → 3 MLP has 267 learned parameters. One mixture vector is shared by all windows of each chunk, while the candidate velocities vary per window. The residuals measure agreement with the incoming prior, not ground-truth error. Every platform uses the same readout. Each soup has its own readout, fitted on released validation labels using its train-only twin as prior (seed 17, 300 AdamW steps, AVE loss). Candidate comparison used three-fold OOF readouts; the deployed readout is refitted on all 80 validation trajectories.
| Weight set | File | Input prior during training |
|---|---|---|
| S-C6 | weights/soup_S-C6/physics_readout_refit_val80_S-C6t.pt | S-C6t: the uniform soup of the six members' train-only twins |
| S-C3 | weights/physics_readout_refit_val80.pt | S-C3t: the uniform soup of the three members' train-only twins |
tartanimu_release/detectors.py, physics.py)Detectors (statistics and thresholds in vendor/scripts/r15/l4a_family/analyze.py; the human
detector's mean tilt in vendor/excerpts/replay_frozen_human_h1_20260912_family_statistics.py) read
only the raw IMU of one trajectory (the human detector also its timestamps, for the duration). Each
stage applies to the trajectories its detector selects, in this order, each taking the previous output
as its prior:
| Stage | Detector (fires if any listed low-pass frequency fires) | Operator | Trained parameters |
|---|---|---|---|
| BODY | rot_ratio <= 1.2, gait < 0.35, abs(corr_body) <= 0.45, mean tilt >= 3 deg; 0.5, 1 or 5 Hz (strict pipeline: 0.5 Hz only) | whole-trajectory rotor-drag least-squares smoother; the prior is rescaled when the network-free solution is >= 2 m/s and >= 1.4x faster; prior sigma speed_sig (strict pipeline: frozen_sig1, prior sigma 1) | 0 |
| WORLD | corr_body <= -0.45, mean tilt <= 3.5 deg, rot_ratio <= 1.6, hf50 <= 0.10; 0.5, 1 or 5 Hz (strict pipeline: 1 Hz only) | W1 world-frame fit fused with the prior (frozen anomaly gate); G1 switches to the pure physics solution when the spectral misfit statistic exceeds 0.1198 | 0 |
WORLD G2 (D_union_H_G2_SC6, B_H_G2_SC6, D_union_H_G2) | only trajectories selected by the same pipeline's WORLD detector; then all frozen selector bounds must pass | IMU-only attitude; whole-trajectory accelerometer integration, segmentwise velocity/bias fits, and heading-gauge fit; 0.5/0.5 blend with the G1 prior | 0 |
| dog | mean tilt < 30 deg, duration > 60.5 s, rot_ratio >= 1.43, and 22.6885 still_frac + 11.4416 ln(std abs(acc)) - 9.6867 > 0; 5 Hz | segmented (30 s) strapdown + prior least squares with zero-velocity updates, blended 0.5/0.5 with the prior (dog3) | 0 (3 fixed discriminant coefficients) |
| car | same gate, discriminant <= 0; 5 Hz | segmented (60 s) strapdown + prior least squares with zero-velocity updates | 0 (same coefficients) |
human (every candidate except D_union) | mean tilt > 60 deg and duration > 300 s (no low-pass frequency; mean tilt = angle between the whole-trajectory mean specific force and the sensor z axis; duration = last minus first timestamp) | dog3, the dog stage's operator, unchanged | 0 |
Safety fallbacks keep the stage's input prior: BODY, dog, car and human on non-finite output or any window faster than 30 m/s; W1 also when the fit's median residual exceeds 0.657 m/s or the mean change exceeds 0.193 m/s (thresholds fixed on released WORLD flights); the G1 physics branch on non-finite output; G2 whenever its selector rejects the trajectory. The detectors read only the raw IMU, so their decisions do not depend on the weight set; the G2 selector's statistics do, because they are computed from each run's G1 output. On the test set:
| Pipeline | BODY | WORLD (G2 accepted) | dog | car | human | readout only | trajectories in two top-level groups |
|---|---|---|---|---|---|---|---|
main (D_union_H_G2_SC6) and D_union_H_G2 | 11 | 34 (20) | 14 | 19 | 10 | 1 | 0 |
strict (B_H_G2_SC6) | 9 | 34 (20) | 14 | 19 | 10 | 3 | 0 |
D_union_H | 11 | 34 (no G2) | 14 | 19 | 10 | 1 | 0 |
D_union | 11 | 34 (no G2) | 14 | 19 | - | 11 | 0 |
The strict pipeline's 0.5 Hz BODY detector does not fire on two of the 11 trajectories on which the union detector fires; its 1 Hz WORLD detector selects the same 34 trajectories as the union detector.
The human stage was added to D_union by a pre-registered test on released data only: the detector
rule and seven candidate operators, all existing zero-parameter operators of this chain (W1, G1, the
car and dog variants of the segmented hybrid, dog3 and the two BODY operators), and the pass criteria
and selection rule were fixed before any operator was run on a human trajectory. The candidates were
evaluated on the released validation human trajectories; dog3 was the only candidate that passed every
pre-registered criterion and was selected mechanically. The rule's two thresholds were taken unchanged
from an earlier development rule and re-checked on the 475 released trajectories before any operator
was evaluated: the mean tilt separates every released human trajectory (66.4 to 99.3 deg) from every
car, dog and drone trajectory (at most 47.8 deg), and every released human trajectory lasts more than
300 s (959 to 1,335 s), so the rule selects all 33 released human trajectories and nothing else.
WORLD G2 estimates attitude and gyroscope bias from the trajectory's own IMU, performs one
whole-trajectory accelerometer integration, then fits initial velocity and accelerometer bias
independently over 20-window segments and a heading gauge to the incoming G1 estimate.
No attitude, velocity or position label is read. The four thresholds of the frozen
selector (heading_uniqueness >= 5, speed_ratio <= 1, misfit_q90_deg <= 2.5, n_windows >= 10)
were derived on released train only; every run recomputes the statistics and the accept/reject
decision from the current G1 prior.
tartanimu_release/fast_window_gain.py)This is the L24 stage fixed by docs/research/opus-r15-20260914/17-L24-fast-window-gain-prereg.md at
origin/main commit 9cc163e6. It sits after every readout, BODY, WORLD G1, WORLD G2, dog, car and
human stage, immediately before the CSV is written. Input and arithmetic are float64 throughout: for
each row the Euclidean norm of the pipeline's current prediction (vx, vy, vz) is computed, and where
speed >= 1.0 all three components are multiplied by that pipeline's single constant — 1.0200 for the
main candidate, 1.0225 for the strict one. Pipelines without a gain block skip the function entirely,
and neither claimed candidate has one.
Each constant was fitted once, on that candidate's own released val80 chain. There is no per-platform
constant and no test label was used. 2,505 and 2,504 test windows respectively pass the fixed
threshold for the main and the strict variant; the stage performs no sorting, no row filtering and no
change to window_id.
(1) Is this a single model with one shared weight set?
Yes. Each candidate uses exactly one weight set, fixed by its pipeline file: S-C6 for the main and the
strict candidate, S-C3 for D_union_H_G2, D_union_H and D_union. The package ships both sets only
because it holds candidates of both kinds; no candidate combines them. Within a candidate, all 89 test
trajectories, from every platform, pass through the same program with the same two weight files, and
both files are applied to every trajectory: the network (one state dict) and the 267-parameter readout
that follows it. There are no per-platform or per-trajectory weights. The physics operators contain no
trained weights; they are deterministic least-squares and filtering procedures with fixed constants.
The human stage adds no weights: it re-uses the dog stage's operator. WORLD G2 likewise adds no learned
weights: its IMU-only attitude fit, whole-trajectory integration, segmentwise fitting, gauge fit and selector are fixed numerical
procedures.
(2) Is there any platform classification, routing or specialization at inference?
D_union) on 33, all human (of 33); no trajectory enters two
top-level operator families; in D_union, no human trajectory triggers any stage. With the strict pipeline's frequencies
(BODY 0.5 Hz, WORLD 1 Hz), BODY fires on the same 50 trajectories and WORLD on 273, all WORLD-frame
drones (a subset of the 278); dog, car and human are unchanged, and no trajectory enters two top-level operator families.tartanimu_release/detectors.py.D_union_H_G2) runs only on the trajectories that
the same pipeline's WORLD IMU detector selects. Its selector uses the heading uniqueness, speed ratio,
IMU attitude misfit and window count computed from that trajectory at inference. There is no
platform label, trajectory-name lookup or frozen per-trajectory acceptance table.(3) Is any ensembling, checkpoint averaging or test-time augmentation used?
Checkpoint averaging: yes. In each weight set the network weights are a uniform weight soup, the element-wise average of fine-tuned checkpoints, each member its fixed terminal-epoch EMA (0.999) of its training weights (recipes in "Network prior"):
TV seed 17 (a3248af3...), TV seed 18
(49d4f7ff...), A2 seed 17 (35fb3abe...), A2 seed 18 (ba70a6f8...), SO3 seed 17
(08981685...), SO3 seed 18 (135a76ef...);D_union_H_G2, D_union_H, D_union), three members: TV seed 17 (a3248af3...), A2
seed 17 (35fb3abe...), SO3 seed 17 (08981685...).One averaged state dict is loaded and one network runs; no predictions of separate models are combined.
Internal averaging: the eight recurrent branches of the network are averaged inside its forward pass; they are trained jointly as one network.
Test-time augmentation: yes, temporal multi-view TTA. The one network is evaluated on every stride-one 16-window query view, so each window receives 1 to 16 passes (16 for interior windows), and its prior is the coordinate-wise median of those passes. No rotated, flipped or noise-perturbed input is evaluated.
Other mixtures: the readout's soft mixture of prior and physics proposals; the dog3 operator's 0.5/0.5
blend with its input prior (dog stage, and the human stage of every candidate except D_union); in
the G2 candidates (main, strict, D_union_H_G2), WORLD G2's 0.5/0.5 blend of its output with the G1
output on the trajectories its selector accepts.
(4) How was test-set leakage avoided, including for model and checkpoint selection?
D_union (and so
for D_union_H, D_union_H_G2 and the main candidate D_union_H_G2_SC6, which contain it),
decisions informed by such feedback include taking the union of the 0.5/1/5 Hz BODY and WORLD
detectors (released data could not distinguish it from 0.5 Hz alone), the choice of the BODY operator
speed_sig over the alternatives, and the choice of D_union as the final candidate of that round.
Earlier development rounds also used test scores to decide which model, augmentation and soup-member
directions to pursue and to adopt some structural choices (for example the rescale-then-smooth form
of the BODY operator, and the 1 Hz low-pass used by the frame-family detector, which was changed from
5 Hz after inspecting which test trajectories the detector selected). The inference code contains no test-derived constant, threshold or
per-trajectory rule.B_H_G2_SC6 (pipeline_B_H_G2_S-C6.json) excludes the two choices of the last
development round that were made with test feedback: the 0.5/1/5 Hz detector union, which is what
makes test trajectories test_0028 and test_0055 BODY in the main pipeline, and the BODY speed_sig
operator. It uses the BODY detector at 0.5 Hz with the frozen_sig1 operator and the WORLD detector
at 1 Hz instead. It still inherits the earlier-round components listed in the previous point, including the 1 Hz
frame-family low-pass that its WORLD detector uses.D_union_H test file was written by inference alone and
no test score of it was used to build or select it.D_union_H chain on released val80, computed with the members'
train-only twins; differences below 0.0001 choose the soup with fewer members). The S-C6 test files
were written by inference alone.inference.py and tartanimu_release/ contain no
test-derived constant, threshold or per-trajectory rule, and both claimed files are reproduced byte
for byte from raw IMU alone. The team's full development history, including exploratory uses of the
public leaderboard and of the official scoring service that are not part of any claimed
candidate, is disclosed in the technical report submitted to the organizers, which per the
organizers' own statement (discussion #739576, section 2) "is the authoritative description of your
final system".rule_grid_A1.csv). The selector was evaluated on released val80 twice. The originally pre-registered selector failed one criterion: one short trajectory degraded by more than the allowed margin. Under a rule fixed in advance, exactly one amendment was then derived mechanically on released train, using training crops with representative lengths, and evaluated once; it passed all criteria. Because the per-trajectory val80 table of the first evaluation had been seen, the outcome of the second evaluation was predictable in advance; it is not an independent validation on val80. The amendment's crop lengths were first drawn from the window counts of the WORLD-detected val80 and test trajectories (label-free metadata). To remove any test influence, the derivation was repeated with lengths drawn from released train+val trajectories only, and it produced identical decision fields. The packaged config is that released-only re-derivation (sha256 89df11c5...); its decision fields equal those of the config evaluated on val80 (sha256 dd73761a...). Measured after the fact on the deployed chain, the selector captures 82.5% of what a perfect label-picked accept/reject decision would be worth: a label-picked selector reaches val80 .168364 against the deployed .168824, so the entire remaining headroom of this stage's routing decision is .00046. All five of its wrong rejects fail the heading_uniqueness >= 5 condition, while its sixteen correct rejects each avoid up to +.00098, so that condition is not loose — it is the part doing the work.docs/research/opus-r15-20260914/17-L24-fast-window-gain-prereg.md (origin/main 9cc163e6).
Neither selected final contains this stage. The union gain worsened Public from
0.22738 to 0.22815; the strict gain improved it from 0.28152 to 0.27978. Neither
gain variant was selected as a final.(5) What differs between the development and the submitted system?
Each candidate uses this program with its pipeline file. On the reference setup, non-gain candidates reproduce their development CSVs byte for byte. The two gain variants reproduce all float64 values exactly but use different decimal formatting:
| Pipeline file | Candidate | Weight set | Reference sha256 (development file) | Reproduced by |
|---|---|---|---|---|
pipeline.json (default) | D_union_H_G2_SC6 | S-C6 | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf | run k1 (GPU, default arguments); l24-b1 with the same bytes named explicitly, and that is the shipped receipt |
pipeline_D_union_H_G2_S-C6.json | D_union_H_G2_SC6 | S-C6 | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf | the same bytes as pipeline.json (run k1); also a CPU check of this version from the development prior |
pipeline_B_H_G2_S-C6.json | B_H_G2_SC6 | S-C6 | f829182d66913a0a43ba4a77937778128539683ce18bc326984ce638165bb8b4 | run k2 (GPU) |
pipeline_D_union_H_G2_S-C6_gain.json | D_union_H_G2_SC6_gain | S-C6 | development-format a5083c2230a955951722e197737041812eb1a9e8b83f8f4b6262259a41c5b01b | run l24-g1 (GPU): package canonical 5350c541...; exact float64 equality, different decimal formatting |
pipeline_B_H_G2_S-C6_gain.json | B_H_G2_SC6_gain | S-C6 | development-format cec8a31f237bde32ada52aa1469baff70e43b844d1c4aa0047923bec9c07de42 | run l24-g2 (GPU): package canonical 0f2134ad...; exact float64 equality, different decimal formatting |
pipeline_D_union_H_G2.json | D_union_H_G2 | S-C3 | 9e9c254e6bfcc295e541ea9e2254ae93f94a53d7d208c29160ebe9ecce8b9a83 | run k3 (GPU) |
pipeline_D_union_H.json | D_union_H | S-C3 | 21ced71e8f5a95464a1412d5eeb40fc3e8d7ef7e22aff9821cd78b7fda158fc6 | run k4 (GPU) |
pipeline_D_union.json | D_union | S-C3 | e5ff5f5a5f8dd7239dbd2eb58515bb0131cf97c50f70f643acab161e3a46365e | CPU check of this version from the development prior; GPU run h1 of the 2026-09-18 version |
In development, G2 was applied by a separate program to the stored WORLD G1 output of each chain (read back from CSV with exact round-trip parsing, several worker processes); here it runs in the same process on the in-memory G1 output. The outputs are byte-identical (runs k1-k3).
The development G2 runs read the config evaluated on val80 (sha256 dd73761a...); the package ships
the released-only re-derivation (sha256 89df11c5...). The two files differ only in fields that
inference never reads (the config's name, output directory, source note and training summary); the
fields it reads (attitude settings, bias prior, segment length, blend weight, selector bounds) and the
pinned code hashes are equal, and runs k1-k3 reproduce the development files byte for byte with it.
In development, each chain's decisions file named the readout by path and the network soup was fixed by the prior-export job; here each pipeline file names its weight set, whose manifest pins both files by sha256.
Development evaluation used train-only "twin" versions of the soup members on released val; the submitted members were retrained on train+val, so no released data is held out for them. The readout was fit with the train-only twin soup as input prior and is applied to the train+val soup's prior.
During development the prior was exported to a CSV by a GPU job and the physics stages ran in separate CPU worker processes; here both run in one process. The CSV serialisation of the prior is kept (in memory) because it is part of the exact arithmetic of the submitted file.
The stage wiring was re-implemented from the development tool with its released-data evaluation code
removed; every numerical routine is the vendored original (SOURCES.md). The human stage was added
the same way from the development tool's later revision, in which every other stage is unchanged.
The G2 candidates are likewise selected by their pipeline files alone. The two vendored G2 numerical
files and the frozen config are pinned by sha256 (SOURCES.json); a missing config, or a config or
vendored-code hash mismatch, stops the run before the network prior is computed.
The CUDA context is created before any weight file is read or model built (see "Reproducibility"); in development it was created lazily inside the first GPU allocation. This changes no computed value.
Both files claimed in "Result claimed" were verified against their leaderboard originals on
2026-09-20: run l24-b1 reproduces dd01a43f... and run l24-b3 reproduces 9e9c254e..., byte for
byte, from raw IMU in a fresh offline environment (see "Verification"). submission.csv and
submission_D_union_H_G2.csv in this repository are those two files. No other difference exists
between the claimed leaderboard files and this package's candidates.
Reference machine: NVIDIA GB10 (aarch64 Grace CPU, driver 580.159.03), Python 3.11.16, torch 2.13.0
with CUDA 13 wheels, numpy 2.4.6 and scipy 1.17.1 from conda-forge linked to conda-forge OpenBLAS
0.3.34 (build pthreads_h9d3fd7e_0). conda-linux-aarch64.lock pins every conda package build.
Determinism: inference.py sets single-threaded BLAS/OpenMP before numpy and torch load; the network
runs with batch size 8 (a different batch size changes GPU kernel selection and the last bits).
CUDA context: with a CUDA device, inference.py first creates the CUDA context
(network_prior.create_cuda_context: torch.cuda.init() and one cudaMemGetInfo call), before it
reads any weight file or builds the network. On the reference machine the GPU uses host memory, and
a context created lazily by the first allocation of model.to("cuda"), after the network had been
built on the CPU, intermittently failed with "CUDA error: out of memory" while other jobs shared the
machine; creating it first did not fail. Only the moment of context creation changes, not what is
computed: with it, the network prior of each weight set and every reference file are reproduced bit
for bit (runs k1-k4 of this version, g1 and g2 of the previous one; see "Verification"). The receipt
records the context state and the free GPU memory at creation.
The linear-algebra build is part of the exact result. Measured on the reference machine for D_union
(2026-09-17), CPU physics stages from the same network prior, all 89 trajectories (D_union_H was
checked in the exact-build and the development environment only, byte-identical in both):
| Environment | Output vs submitted file |
|---|---|
exact conda-forge builds (conda-linux-aarch64.lock + requirements.txt) | byte-identical |
| same package versions resolved from conda-forge on 2026-09-17 (newer builds of OpenBLAS 0.3.34, libgfortran/libgomp 16.2.0 and python 3.11.16) | max 6.5e-5 m/s, 18,113 of 30,644 rows differ |
requirements.txt only (PyPI numpy/scipy wheels, bundled OpenBLAS 0.3.31) | max 6.6e-5 m/s, 19,166 rows differ |
In the PyPI-wheel environment every detector statistic is bitwise identical, so every stage decision is unchanged; LAPACK-based solves (lstsq, SVD, trust-region least squares) round differently. Largest per-stage differences over the 89 trajectories: readout 6.0e-8 m/s, WORLD 3.3e-9, BODY 7.7e-6, car 7.9e-6, dog 6.6e-5 m/s.
The three rows above are all linux-aarch64 on the reference GPU, which is why the routing is unchanged and only the LAPACK-based solves round differently. An x86_64 Tesla T4 was measured separately and behaves differently in kind, not just in size - see "Measured off-reference reproduction" in Quick start. Other GPUs, CPU architectures and BLAS libraries were not available to us; expect differences of this order or larger there (GPU kernels also change the network prior in its last bits).
End-to-end runs of inference.py on all 89 test trajectories, reference machine.
h5-w1 (2026-09-20)run_inference.sh was run on all 89 test trajectories with the trajectory directory and the window
index CSV given as two separate arguments, to confirm that the explicit-path form produces the
claimed file and not merely a similar one:
./run_inference.sh --test-dir <competition>/test \
--windows-csv <competition>/index/test_windows.csv \
--output submission.csv --device cuda
| Run | Form | Output vs submission.csv | Wall-clock (network prior / physics) | GPU peak (allocated / reserved) | Max RSS |
|---|---|---|---|---|---|
h5-w1 | run_inference.sh --test-dir ... --windows-csv ... | byte-identical, dd01a43f..., 30,644 rows, 2,170,602 bytes | 2,634 s (1,915 s / 719 s) | 270 / 386 MiB | 1.81 GiB |
--data-root run: the receipt records
test_index_sha256 e46c5925... and sample_submission_sha256 f659ebae..., equal to the values in
submission.receipt.json. Its data_root is the temporary directory the wrapper assembled, which
is what makes the two forms equivalent rather than merely similar.l24-b1 in everything that determines the output: the S-C6 network prior
(fbcc36d5...), the package fingerprint (97 files, d2d1ebdc..., f119fd59...), the weight set, and
the stages applied (readout 89, BODY 11, WORLD 34, WORLD G2 34, dog 14, car 19, human 10).bwrap --unshare-net, niced, on a pinned CPU set, on a GPU shared with two
other projects. The temporary directory was removed when the run exited.imports.research_modules_outside_package is 0: nothing outside this repository was imported.At commit 7eab11776fd0d521a74059a64f884f176d37106a, all six pipelines were re-run end to end with the
pinned kaggle_tartanimu_260827 conda Python. Two batches of three independent processes shared the
reference machine, using the project's gpu.lock, bwrap --unshare-net, strace, the single-threaded
numerical environment and an eager CUDA context created before the model is built. No other project's
process was stopped or modified, and none of the six runs hit an OOM or needed a retry.
| Run | Pipeline | sha256 | Against the reference file | Seconds (network / physics) | GPU MiB (allocated / reserved / process) | Max RSS |
|---|---|---|---|---|---|---|
| l24-g1 | pipeline_D_union_H_G2_S-C6_gain.json | 5350c541861d269e54078018ff25c2dc138afda621779d161fd12336a817cd69 | numerically identical; same rows and order; development text file a5083c22... | 1,551 (1,090 / 461) | 270 / 386 / 601 | 2.02 GiB |
| l24-g2 | pipeline_B_H_G2_S-C6_gain.json | 0f2134ade8bd4b1d540fb726d3882c12e1da4ae2fdfc2c67cd17b7d318976530 | numerically identical; same rows and order; development text file cec8a31f... | 1,519 (1,064 / 455) | 270 / 386 / 601 | 2.01 GiB |
| l24-b1 | pipeline_D_union_H_G2_S-C6.json | dd01a43fd2db904f76f8b023adc00fe5e3db7241cb26f57feb59a1d34e10f8cf | byte-identical | 1,532 (1,077 / 455) | 270 / 386 / 601 | 2.01 GiB |
| l24-b2 | pipeline_B_H_G2_S-C6.json | f829182d66913a0a43ba4a77937778128539683ce18bc326984ce638165bb8b4 | byte-identical | 2,000 (1,511 / 489) | 270 / 386 / 601 | 2.02 GiB |
| l24-b3 | pipeline_D_union_H_G2.json | 9e9c254e6bfcc295e541ea9e2254ae93f94a53d7d208c29160ebe9ecce8b9a83 | byte-identical | 2,016 (1,534 / 482) | 270 / 386 / 601 | 2.01 GiB |
| l24-b4 | pipeline_D_union_H.json | 21ced71e8f5a95464a1412d5eeb40fc3e8d7ef7e22aff9821cd78b7fda158fc6 | byte-identical | 1,832 (1,510 / 322) | 270 / 386 / 601 | 2.01 GiB |
The four claimed-family runs (l24-b1 to l24-b4) reproduce their reference files byte for byte,
including both files claimed in "Result claimed". The two _gain development files used a shorter
decimal representation, while this package's canonical writer always uses %.17g, so their text bytes
and sha256 differ (main: package 2,170,534 bytes against the development file's 2,122,088; strict:
2,170,498 against 2,122,016). Compared with a correctly round-tripping float parser over the 30,644
window_id values and the 91,932 float64 values, the ids and row order are identical in both cases and
the maximum absolute difference is 0.0, with no value differing at all — so the package output is
the canonical artifact and reproduces exactly, well beyond a 1e-12 tolerance, though it is not
claimed to be byte-identical to the development text files. The receipts also confirm that the main
variant scaled 2,505 rows and the strict one 2,504, with threshold and constant 1.0 / 1.0200 and
1.0 / 1.0225 respectively. The full machine-readable evidence is in the reference machine's artifact
OPUS_R15_20260914/L24_gain/release_repro_7eab1177/verification_summary.json.
Runtime against the host re-execution limits. The slowest of the six runs took 2,016 s (34 min) and
the default pipeline 1,532 s (26 min), against the organizers' 2-hour wall-clock limit; peak GPU memory
was 601 MiB for the process, against the 16 GB VRAM limit; peak host RSS was 2.02 GiB. All six runs
shared one GPU with unrelated jobs, so these are contended figures, not best-case ones. The slowest
run recorded anywhere in this card is h5-w1 at 2,634 s (44 min), on a GPU shared with two other
projects at a host load average above 20; peak GPU memory and RSS were unchanged. Every run of this
package has finished inside half the wall-clock budget, at about 4% of the VRAM budget.
This version of the package (final: S-C6 weight set, strict candidate, each pipeline names its weight set, packaged G2 config re-derived on released data only), 2026-09-19. Two batches, each under one lock, at most three runs at once: k1, k2 and k3 started together (07:52Z), k4 and the smoke run s2 together after them (08:20Z). All runs were independent processes on a GPU shared with one process of another project and on a CPU shared with other jobs (load average about 15-30, the runs at nice 10), so the wall-clock times are upper bounds for this machine, not its idle speed:
| Run | Candidate (arguments) | Weight set | Environment | Network | Output vs development file | Wall-clock (network prior / physics) | GPU peak (PyTorch allocated / reserved / process) | Max RSS |
|---|---|---|---|---|---|---|---|---|
| k1 | D_union_H_G2_SC6 (default arguments) | S-C6 | fresh env: conda-linux-aarch64.lock + requirements.txt | none: network namespace with loopback only; every open/connect syscall traced | byte-identical (dd01a43f...) | 1,599 s (963 s / 631 s) | 270 / 386 / 601 MiB | 1.95 GiB |
| k2 | B_H_G2_SC6 (--pipeline pipeline_B_H_G2_S-C6.json) | S-C6 | same | same | byte-identical (f829182d...) | 1,644 s (970 s / 669 s) | 270 / 386 / 601 MiB | 1.96 GiB |
| k3 | D_union_H_G2 (--pipeline pipeline_D_union_H_G2.json) | S-C3 | same | same | byte-identical (9e9c254e...) | 1,649 s (1,021 s / 622 s) | 270 / 386 / 601 MiB | 1.96 GiB |
| k4 | D_union_H (--pipeline pipeline_D_union_H.json) | S-C3 | same | same | byte-identical (21ced71e...) | 1,028 s (690 s / 334 s) | 270 / 386 / 601 MiB | 2.03 GiB |
fbcc36d5...), S-C3 in k3 and k4 (522e8e68...). Every
receipt records that the CUDA context was active before the network was built.89df11c5...): the same 34 trajectories as in the
corresponding development chain, the same 20 accepted and 14 rejected (9 by the thrust-axis misfit
bound, 5 by the heading-uniqueness bound), and every selector statistic of every trajectory (884
values per run) equal, as a float64, to that chain's table. The 34 trajectories and the 20 accepted
ones are the same in all three runs; k2's 0.5 Hz BODY detector fires on 9 of k1's 11 BODY trajectories.submission.csv shipped here, and so is l24-b1's; the
receipt this repository ships is l24-b1's, because that run used the current package code (see
"Result claimed"). All outputs pass the team's submission validator (30,644
rows in sample_submission.csv order, unique ids, finite values). The k1-k4 receipts' code
fingerprint (sha256 over the 96 Python files of that revision) equalled the repository at that
revision, and every imported research module came
from vendor/.index/test_windows.csv, sample_submission.csv and the 89 test/*.npz of the data
directory, and system/driver files; files written were the output and its receipt plus the two runtime
caches described under r2. No IPv4/IPv6 connection was attempted; the only connect calls were failed
Unix-socket probes for nscd and the CUDA MPS daemon.D_union_H_G2_SC6, B_H_G2_SC6, D_union_H_G2
and D_union files byte for byte, and the two S-C6 candidates without WORLD G2 (the development base
files of the main and the strict candidate) byte for byte.--pipeline pipeline_D_union_H_G2_S-C6.json, the main
candidate): the same label-free stand-in of the test split as run s1 of the previous version (the 80
released validation trajectories in the test layout, only imu, ts and fs; shuffled, renamed and
renumbered so that no name or order reveals a platform). The run completed (1,064 s; network prior
575 s, physics stages 485 s; 270 / 386 / 601 MiB; 1.95 GiB), all 23,714 outputs are finite, the
validator passes, the same system-call picture holds, and every stage that kept its input prior logged
why (WORLD W1 anomaly gate on 5 trajectories, G2 selector on 24). WORLD G2 ran on the 38 trajectories
the WORLD detector selected, all of them WORLD-frame drones (39 in the validation split), and accepted
14, the same 14 as run s1 with the S-C3 weight set. The network and the readout were trained on these
trajectories, so this only checks that the program runs correctly on a different data directory and
trajectory set; it measures no accuracy, and no score was computed.Previous version of the package (WORLD G2 stage; CUDA context created first), 2026-09-19, S-C3 weight set only. Runs g1 and g2 and the smoke run s1 below started together (independent processes) on a GPU shared with three processes of another project and on a fully loaded CPU (load average about 45-60, the runs at nice 10), so the wall-clock times are upper bounds for this machine, not its idle speed:
| Run | Candidate (arguments) | Environment | Network | Output vs development file | Wall-clock (network prior / physics) | GPU peak (PyTorch allocated / reserved / process) | Max RSS |
|---|---|---|---|---|---|---|---|
| g1 | D_union_H_G2 (--pipeline pipeline_D_union_H_G2.json) | fresh env: conda-linux-aarch64.lock + requirements.txt | none: network namespace with loopback only; every open/connect syscall traced | byte-identical (9e9c254e...) | 3,389 s (1,972 s / 1,402 s) | 270 / 386 / 601 MiB | 1.9 GiB |
| g2 | D_union_H (default arguments) | same | same | byte-identical (21ced71e...) | 2,951 s (2,052 s / 882 s) | 270 / 386 / 601 MiB | 2.0 GiB |
522e8e68...). In every run of that version the receipt records that the CUDA
context was active before the network was built.dd73761a...): the same 34 trajectories as in the
development chain, the same 20 accepted and 14 rejected (9 by the thrust-axis misfit bound, 5 by the
heading-uniqueness bound), and every selector statistic of every trajectory (884 values) equal, as a
float64, to the development chain's table.submission.csv was the g2 output (D_union_H, the default then) and
submission.receipt.json g2's receipt. Both outputs pass the team's submission validator (30,644 rows
in sample_submission.csv order, unique ids, finite values). The receipts' code fingerprint (sha256
over the 96 Python files) equalled that version's, and every imported research module came from
vendor/.index/test_windows.csv, sample_submission.csv and the 89 test/*.npz of the
data directory, and system/driver files; files written were the output and its receipt plus the two
runtime caches described under r2. No IPv4/IPv6 connection was attempted; the only connect calls
were failed Unix-socket probes for nscd and the CUDA MPS daemon.--pipeline pipeline_D_union_H_G2.json): a label-free
stand-in of the test split built from the 80 released validation trajectories, in the test layout
(only imu, ts and fs; trajectories shuffled, renamed and renumbered so that no name or order
reveals a platform). The run completed (2,900 s; network prior 1,574 s, physics stages 1,304 s;
270 / 386 / 601 MiB; 1.9 GiB), all 23,714 outputs are finite, the validator passes, the same
system-call picture holds, and every stage that kept its input prior logged why (WORLD W1 anomaly
gate on 5 trajectories, G2 selector on 24). WORLD G2 ran on the 38 trajectories the WORLD detector
selected, all of them WORLD-frame drones (39 in the validation split), and accepted 14. The network
and the readout were trained on these trajectories, so this only checks that the program runs
correctly on a different data directory and trajectory set; it measures no accuracy, and no score
was computed.Previous version of the package (human stage added), 2026-09-18. Both runs started together (independent processes) on a GPU and CPU shared with other jobs (about ten other GPU processes; GPU utilisation about 94 % when the runs started), so the wall-clock times are upper bounds for this machine, not its idle-GPU speed:
| Run | Candidate (arguments) | Environment | Network | Output vs development file | Wall-clock (network prior / physics) | GPU peak (PyTorch allocated / reserved / process) | Max RSS |
|---|---|---|---|---|---|---|---|
| h1 | D_union (--pipeline pipeline_D_union.json) | fresh env: conda-linux-aarch64.lock + requirements.txt | none: network namespace with loopback only; every open/connect syscall traced | byte-identical (e5ff5f5a...) | 4,155 s (3,641 s / 505 s) | 270 / 386 / 601 MiB | 1.8 GiB |
| h2 | D_union_H (default arguments) | same | same | byte-identical (21ced71e...) | 4,270 s (3,625 s / 638 s) | 270 / 386 / 601 MiB | 1.8 GiB |
522e8e68...).sample_submission.csv order,
unique ids, finite values). The receipts' code fingerprint (sha256 over the 93 Python files of that
version) equalled that version's, and every imported research module came from vendor/.index/test_windows.csv, sample_submission.csv and the 89 test/*.npz of the
data directory, and system/driver files; files written were the output and its receipt plus the two
runtime caches described under r2. No IPv4/IPv6 connection was attempted; the only connect calls
were failed Unix-socket probes for nscd and the CUDA MPS daemon.Previous version of the package (D_union only), 2026-09-17, one GPU held exclusively:
| Run | Environment | Network | Output vs submitted file | Wall-clock | GPU peak (PyTorch reserved / process) |
|---|---|---|---|---|---|
| r1 | the development conda env | normal | byte-identical (e5ff5f5a...) | 458 s | 386 MiB / 601 MiB |
| r2 | fresh env: conda-linux-aarch64.lock + requirements.txt | none: network namespace with loopback only; every open/connect syscall traced | byte-identical (e5ff5f5a...) | 461 s | 386 MiB / 601 MiB |
| r3 | fresh env: Python 3.11.16 + requirements.txt only (PyPI wheels) | none: network namespace with loopback only | max 6.6e-5 m/s, 19,166 of 30,644 rows differ (1af40885...) | 431 s | 386 MiB / 601 MiB |
522e8e68...); the r3 difference is entirely in the CPU physics
stages (see "Reproducibility").sample_submission.csv order,
unique ids, finite values).index/test_windows.csv, sample_submission.csv and the 89 test/*.npz of the data directory, and
system/driver files (/dev/nvidia*, /proc, /sys, /usr/lib, /etc/ld.so.cache, /etc/passwd,
/etc/localtime). Files written: the output and its receipt, plus two runtime caches outside the
repository that do not affect results, the NVIDIA driver's PTX JIT cache (~/.nv/ComputeCache) and a
oneDNN JIT symbol map (/tmp/perf-<pid>.map). No IPv4/IPv6 connection was attempted; the only
connect calls were failed Unix-socket probes for nscd and the CUDA MPS daemon.D_union_H_G2 and D_union_H files byte for
byte in the exact-build environment (before the CUDA-context change, which does not touch these
stages) and the D_union file byte for byte (after it); with the 2026-09-18 version, the D_union_H
and D_union files byte for byte in the exact-build and in the development environment, and ten other
chain variants of the development tool (A, A_union, B, B_union, E_union, F_union,
G_soupE3 on the S-E3 soup's prior, N0, N1, N2), each selected through its pipeline file alone.D_union_H pipeline, the detectors are unchanged since; strict
frequencies: this version, pipeline_B_H_G2_S-C6.json), and the auxiliary platform/frame heads'
independence from the velocity (2026-09-17 version with the S-C3 soup, and this version with the S-C6
soup: randomising the heads' weights leaves the velocity of the first two test batches bitwise
unchanged; the network code is unchanged).A pipeline file (pipeline.json by default, another one with --pipeline) fixes the whole candidate:
weight_set: the weight set's name and its manifest (weights/manifest_<set>.json, path relative
to the pipeline file). The manifest carries the same name and lists the set's two files (network
soup and readout, paths relative to the manifest) with bytes and sha256. inference.py refuses a
manifest of another weight set and any file whose sha256 differs.body: none/frozen_sig1/speed_sig, world: none/w1/g1, dog:
none/dog3, car: none/g0, human: none/dog3 with detector tilt60_dur300, world_g2:
none/g2 with config and config_sha256, optional final gain: fast_window_gain with
threshold_mps and factor, readout f183.mode: none/refit) and the detector frequencies, in
the schema of the team's development decision files.Changing the candidate means adding files and editing JSON files; no code changes. For a new soup, put
the soup and its matching readout under weights/soup_<name>/, write weights/manifest_<name>.json
with "weight_set": "<name>", and write a pipeline file whose weight_set block names it; neither the
Python code nor the G2 config changes. Example:
sha256sum weights/soup_<name>/*.pt # bytes and sha256 for weights/manifest_<name>.json
python inference.py --data-root /path/to/competition --output submission_new.csv --device cuda \
--pipeline pipeline_<candidate>_<name>.json
The GPU stage has been run through this package with the S-C3 and S-C6 soups; a new soup needs one full run to re-verify it. G2 re-fits from the new chain's G1 output and recomputes the selector decision for every trajectory; no per-trajectory decision is frozen or carried over from another weight set. Ten other chain variants of the development tool were checked on the S-C3 weight set, with the 2026-09-18 version of the package, from their exported priors (see "Verification").
| Path | Content |
|---|---|
inference.py | entry point; stage orchestration, output and run receipt |
run_inference.sh | the same entry point taking the trajectory directory and the window index CSV as two separate arguments; assembles the expected layout in a temporary directory and runs inference.py unmodified |
tartanimu_release/ | release wiring: runtime guards, config, test data, network prior, detectors, physics stages, WORLD G2 selector, final fast-window gain |
vendor/src/tartanimu/ | model and physics-proposal code, byte-identical to the research repository (SOURCES.md) |
vendor/scripts/ | frozen physics operators and detector statistics, byte-identical to the research repository |
vendor/excerpts/ | the human detector's mean-tilt statistic (family_statistics), a verbatim excerpt of one research-repository script (SOURCES.md, "Vendored excerpts") |
vendor/l16/ | byte-identical IMU attitude and G2 numerical kernels from commit bb3ac291 |
weights/manifest_S-C6.json, weights/soup_S-C6/ | weight set S-C6: network_soup_S-C6.pt, physics_readout_refit_val80_S-C6t.pt |
weights/manifest_S-C3.json, weights/network_soup_S-C3.pt, weights/physics_readout_refit_val80.pt | weight set S-C3 |
pipeline.json | default: main candidate D_union_H_G2_SC6 (the same bytes as pipeline_D_union_H_G2_S-C6.json) |
pipeline_D_union_H_G2_S-C6.json, pipeline_B_H_G2_S-C6.json | main and strict candidates on the S-C6 weight set |
pipeline_D_union_H_G2_S-C6_gain.json, pipeline_B_H_G2_S-C6_gain.json | main and strict candidates plus the pre-registered L24 final gain |
pipeline_D_union_H_G2.json, pipeline_D_union_H.json, pipeline_D_union.json | candidates on the S-C3 weight set |
world_g2_config.json | byte-pinned WORLD G2 config (released-only re-derivation, sha256 89df11c5...) |
requirements.txt | pinned pip requirements |
conda-linux-aarch64.lock | exact conda-forge builds of the reference environment (bitwise reproduction) |
SOURCES.md, SOURCES.json | origin commit and sha256 of every code file and weight file |
submission.csv, submission.receipt.json | the S-C6 selected final (D_union_H_G2_SC6, package default) on the test set, and the receipt of the run that produced it (l24-b1, current package code) |
submission_D_union_H_G2.csv, submission_D_union_H_G2.receipt.json | the team's second selected Kaggle final (D_union_H_G2, S-C3 weight set, Kaggle submission 56353966); reproduced byte for byte by inference.py --pipeline pipeline_D_union_H_G2.json, and the receipt of that run (l24-b3, current package code) |