PASSAGE Reg — RepViT M1
A frozen 256 × 256 route-planning candidate: a vision network predicts the remaining cost to the goal at every cell, then a fixed descent follows it to the goal.
Dataset • Code • Documentation • Presentation • Leaderboard • Seg candidate
256 × 256 only. The supplied exports and entry points accept only
256x256scenes. Other resolutions are planned variants; this release contains no export for them.
PASSAGE Reg is one of the two reference candidates released with the PASSAGE benchmark for trustworthy constrained path planning (NeurIPS 2026, Track on Evaluations and Datasets). It answers a routing request on a real-terrain scene in two frozen steps:
- A RepViT M1 backbone with a learned UPerNet head predicts a nonnegative cost-to-go at every cell: how much cost remains to reach the goal.
- A fixed Bellman descent follows decreasing predicted values from the start. If the descent stalls, a goal-rooted geometric Dijkstra search reconnects it to the goal.
The repository holds three ONNX exports (seeds 2026, 1234 and 3407), a CPU reference that needs no GPU, native entry points for edge targets, and the records that identify each artifact. Its companion, PASSAGE Seg, predicts a path logit instead and decodes it with weighted A*.
How the candidate works
Our candidates, SEG and REG: slide 6 of the final talk (v17, 14 November 2026), reproduced unchanged. The same scheme forms section 3 of the final poster (v9). Terrain derived from JAXA/EORC ALOS World 3D-30m (AW3D30), processed for PASSAGE.
The scheme has three bands. The middle band, A, is inference; this model is its lower row, REG:
- A — inference. The three-channel scene
Xenters RepViT M1.0 with UPerNet, which returns the predicted cost-to-go field (V̂ on the slide). Bellman descent takes downhill steps on that field, withκ = 8selected on the calibration split (CAL). If the descent stalls, goal-rooted Dijkstra reconnects the route. The decoder receives only the field, the obstaclesO, the startsand the goalg. - B′ — REG training. On the same graph, a reverse Dijkstra solve from the goal gives the target cost-to-go
Y*_r. The loss combines reconstruction on reachable cells with Bellman-consistency, local-policy and optimal-set terms. - SEG rows. Band B and the upper row of A describe the companion Seg candidate.
The slide shows the edge deployment, with the network on the GPU and the decoder on the CPU; the CPU reference in this repository runs both on the CPU. Its example is TRAIN scene 0000001971 with the seed-2026 weights. There, REG's 229-cell route costs +16.2 % in elevation cost against the 352-cell A* reference, and the descent reaches the goal without reconnection; SEG's 356-cell route costs +2.5 %. These per-scene values are illustrations, not TEST scores. The presentation page gives the full talk and its script, and the figure provenance records the source of the image.
Run on CPU
Follow INSTALL.md to download the repository with its model files and create cpu-env. While the repository is private, the download needs a Hugging Face account with access. Then, from the repository root:
mkdir predictions
cpu-env/bin/python -I -B predict.py --seed 2026 \
--input validation-input-only.npz --output predictions/example.json
The command writes the route, its status (ok, no_path or budget_exhausted), work counters and artifact hashes as JSON. It refuses to overwrite an existing file, so give each run a new output name. To route your own scenes, follow the input contract.
- Platforms. The hashed locks cover CPython 3.12 on Linux AArch64 and x86-64. Fresh CPU installations were checked on a limited functional cohort; this does not qualify x86 container images or GPU execution. Other platforms need a separately checked dependency lock.
- Runtime. The reference uses ONNX's NumPy interpreter and needs no GPU or vendor SDK. It does not enforce the historical native wall-time limit.
Model architecture
Three scene channels enter the network: elevation, endpoint markers and obstacles. Elevation is calibrated with the fixed global limits −430 m and 8767 m; markers use −1 for background, 0 for start and 1 for goal; obstacles are 1 where blocked. The stored dataset tensor is already calibrated, so converting it from HWC to NCHW does not calibrate it again. The CPU command instead takes raw elevation in metres and applies the same calibration itself.
The backbone produces four feature maps, from fine spatial detail to wide context. UPerNet pools the deepest map at scales 1, 2, 3, 6, passes context back towards the finer levels and fuses all four maps through 128 channels. A final classifier and bilinear upsampling return a field on the original 256×256 grid.
| Backbone level | Spatial size | Channels |
|---|---|---|
| F1 — stride 4 | 64×64 |
56 |
| F2 — stride 8 | 32×32 |
112 |
| F3 — stride 16 | 16×16 |
224 |
| F4 — stride 32 | 8×8 |
448 |
The RepViT M1 stages contain 3, 4, 16, 3 blocks; these dimensions follow the architecture code. The head emits one scalar per cell, and softplus makes the exported float32 1×1×256×256 field nonnegative. Values use the fixed training scale S = 897803.25 and may exceed one. This is a cost field, not a sigmoid probability map, and inference does not multiply it by a reference scene's maximum cost.
Training supervision
Regression needs more supervision than one start-to-goal route: it learns the remaining cost from every reachable cell to the goal. Data preparation therefore adds a goal-rooted reverse shortest-path solve to each terrain scene:
- Decode physical elevation and read the goal and binary obstacles for target construction; retain the declared directed graph and physical edge-cost rule. Keep the calibrated three-channel tensor as the model input.
- Solve towards the goal over reversed edges, preserving each original forward edge cost. This produces physical cost-to-go values
V*and a reachable-cell mask. - At training load time, divide finite target values by
S = 897803.25, the maximum finite physical target cost over the original 900,000 TRAIN tasks. The stored target cache keeps physical values; neither clipping nor per-scene target fitting is used. Reachability selects the cells used by the reconstruction loss; it is not an inference input. - Pair those offline targets with the ordinary three-channel scene tensor. The network sees elevation, markers and obstacles; the training losses additionally see the target field and the permitted supervision.
These locally prepared regression targets are not included in the Hub dataset.
The last released continuation uses 32,768 TRAIN scenes for four passes. Its loss combines reachable-cell reconstruction with Bellman consistency (weight 0.5), local-policy supervision (weight 0.1) and optimal-set supervision (weight about 0.00747). Reconstruction fits the values; Bellman consistency ties a value to the cost of a legal next step plus the predicted remaining cost; the last two terms emphasise useful neighbour choices around reference routes. The method notes give the exact target construction, recipe and provenance limits.
Route decoder
Starting at the requested start, the decoder considers the free neighbours whose predicted value is strictly lower, and moves to the one that minimises:
predicted_value(v) + 8 × 30 / 897803.25 × step_length(u,v)
The goal's value is taken as zero. The geometric term favours shorter moves among promising neighbours; it is not an elevation-dependent physical edge cost.
If the descent reaches a local minimum, geometric Dijkstra grows from the goal until it settles any cell on the visited descent prefix. The final route keeps the prefix up to that connection cell, then follows the Dijkstra branch to the goal; it need not keep the entire prefix up to the stalled cell.
The decoder receives only the predicted field, obstacles and endpoints. It never reads elevation, reference reachability, a reference route or a target-derived scene scale. This frozen procedure does not guarantee physical-cost optimality.
Data roles and scope
| Split | Role |
|---|---|
| TRAIN | Fit network weights from ordinary scene inputs and offline supervision. |
| VAL | Compare model and loss choices and inspect generalisation during development. |
| CAL | Choose the route-decoder parameters before freezing the procedure. |
| TEST | Evaluate the fixed complete procedure on the declared population. |
These are the intended roles, not a claim that the historical selection was independently preregistered. The release manifest records exposed validation and calibration use, and unresolved geographic independence for the continuation subset. The weights and parameters in this package are already fixed.
PASSAGE's contribution here is the routing formulation and complete procedure: real-terrain scene inputs, goal-conditioned dense cost supervision at a fixed training scale, and an explicit field-to-route algorithm whose output can be evaluated as a path. ConvNeXt V2, RepViT, UPerNet and classical graph search are established components; this release adapts and combines them without claiming their invention.
Release contents and checks
The three ONNX exports embed PASSAGE-trained weights. Seed 2026 is the original frozen reg-bellman-descent candidate; seeds 1234 and 3407 are separately trained replicas. All three share the frozen preprocessing and route decoder.
| To | Read |
|---|---|
| Install and run on CPU | INSTALL.md |
| Check inputs, method and decoder details | docs/METHOD.md |
Wrap the candidate behind the plan interface |
docs/CANDIDATE_PACKAGE.md |
| Reproduce inference, training or an exact resume | REPRODUCTION.md |
| Run with CPU, OpenVINO or TensorRT on edge targets | native/README.md |
| Review the complete release record | docs/RELEASE_DETAILS.md |
| Plan another grid size | docs/VARIANTS.md |
Release records: release manifest · artifact identities · integrity hashes · CPU functional check · native functional check · x86 CPU receipt · execution record
The functional checks cover one exposed validation scene per export and per native target. They do not establish general numerical parity, latency, benchmark admission or a score.
- Native x86-64 CPU. A fresh native CPython 3.12.3 environment installed the hashed CPU lock and ran all three seeds of both candidate families; the decoder controls and the historical core 1.1.0 common adapter also passed. On the one exposed scene, the six paths and costs matched the ARM run while the network-field hashes differed. These receipts do not requalify the integration against the public core 1.0.0, and they make no Windows, x86 OCI, GPU or benchmark claim.
- Native API. Compatible packages, vendor SDKs and drivers are obtained separately, and any runtime image is built locally. The native guide lists the current edge limitations.
Measured results, each with its declared population and status, and the contribution process are described on the leaderboard page of the documentation.
Licence, references and citation
MIT covers PASSAGE's original code and trained weights (LICENSE). JAXA AW3D30 terrain, including the example input and the scene renders in the scheme, and third-party software keep their own terms (NOTICE.md, inference notices).
Backbones: ConvNeXt V2 and RepViT. Dense head: Xiao et al., UPerNet, ECCV 2018. These references explain the architectures; NOTICE.md keeps source-specific attribution and the limits of the recorded training-code origins.
These candidates accompany PASSAGE: A Real-Terrain Benchmark for Trustworthy Constrained Path Planning by Geoffrey Delhomme, François Trap and Fateh Kaakai (NeurIPS 2026, Track on Evaluations and Datasets). See also the citation metadata.
@inproceedings{delhomme2026passage,
title = {{PASSAGE}: A Real-Terrain Benchmark for Trustworthy Constrained Path Planning},
author = {Delhomme, Geoffrey and Trap, Fran{\c{c}}ois and Kaakai, Fateh},
booktitle = {Advances in Neural Information Processing Systems (NeurIPS), Track on Evaluations and Datasets},
year = {2026},
url = {https://github.com/ThalesGroup/passage}
}
