Courier Recovery

Courier Recovery

An autonomous courier works on an 8 × 8 map. In every episode it must reach
the depot holding a package, pick it up, reach a different destination depot,
and drop it off. Each map has six depots and eight wall cells.

You receive normal expert demonstrations and a deliberately small number of
recovery demonstrations. In a recovery demonstration, the courier's state
is perturbed to a neighboring reachable cell before the labeled continuation
begins. Your task is to train one fixed neural policy that can recover from
unfamiliar states and generalize to hidden maps.

This is a model-submission task. You submit only the weights of the prescribed
network. The evaluator safely loads those arrays and runs the policy on fully
hidden scenarios; it never executes participant code.

Environment

The six actions are:

An episode succeeds when action 5 is selected at the destination while the
courier is carrying the package. The limit is 96 actions.

The policy always receives an action mask. A movement is masked when it would
leave the map or enter a wall. Pickup is available only at the package depot,
and dropoff only at the destination while carrying. Masked actions can never be
selected by the evaluator.

Some hidden episodes contain deterministic actuator stalls. On a stalled
time step, an otherwise valid movement action consumes the step but does not
change the courier's position. The next observation therefore describes the
unchanged state. Pickup and dropoff actions do not stall.

Policy input

The input is a float32 vector of length 397:

1. a flattened (6, 8, 8) grid, in channel-first order;
2. 13 numerical features.

Grid channels are walls, depot cells, courier position, package position
(empty while carrying), destination, and a carrying flag broadcast over the
grid.

The final 13 values are: normalized row and column, package-depot index,
destination-depot index, carrying flag, current target row and column, target
deltas, and four blocked-movement indicators in action order south, north,
east, west. starter_kit.py is the normative implementation.

Fixed architecture

You must train this exact deterministic MLP:

1397 -> Linear -> 48 -> ReLU -> Linear -> 32 -> ReLU -> Linear -> 6

At every step, the evaluator replaces logits of masked actions with negative
infinity and takes argmax. NumPy's first-index tie rule is used. No softmax,
sampling, recurrent state, or participant code is used during evaluation.

The six arrays and exact shapes are:

All arrays must be finite float32 values with absolute value at most
1000.

Public data

The public archive contains labeled normal and recovery demonstrations,
unlabeled validation scenarios, a local simulator, a baseline trainer, an
exporter, and a submission validator. Hidden evaluation scenarios and stall
schedules are not published.

train_demo_kind.npy is 0 for a normal sample and 1 for a recovery sample.
Use train_episode_offsets.npy to recover trajectory boundaries. Details and
exact shapes are in the dataset README.md and its SHA manifest.

Submission

Submit one ZIP with exactly two root-level files:

1submission.zip2├── manifest.json3└── policy.npz

policy.npz must contain exactly the six arrays above. Do not use pickle or
object arrays. The provided export_policy.py creates the correct manifest and
archive, and validate_submission.py checks it before upload.

Hidden evaluation and scoring

The live/partial split contains hidden maps from the familiar training layout
family, with no or light stalls. The complete/final split contains unseen
barrier and room-like layout families, starts perturbed to valid cells outside
their nominal expert routes, and more stalls. Split membership, layouts, and
perturbation schedules remain hidden.

For one split, let:

1SR  = successful episodes / all episodes2EFF = mean(success * optimal_unstalled_steps / used_steps)3metric = 0.90 * SR + 0.10 * EFF4score  = 100 * metric

Failed episodes contribute zero efficiency. optimal_unstalled_steps is the
shortest delivery length on the map before actuator stalls; therefore stalls
can slightly reduce the attainable efficiency term. Success is intentionally
the dominant objective.

The evaluator reports separate live and final metrics through the platform.
There are no platform subtasks.

Integrity rule

Train a policy from the supplied demonstrations. Do not attempt to reconstruct,
probe, or obtain hidden evaluation scenarios. The organizers may request the
training notebook and source used to produce an awarded submission.

Attribution

This is an original RO-OAI simulation task inspired by the behavioral-cloning
setting of IOAI 2026 Home Task 2, Robot Delivery Academy. All scenarios,
recovery perturbations, splits, packaging, and evaluation code in this task are
newly generated for the simulation.