Robot Delivery Academy

Robot Delivery Academy

You are training a delivery robot on an urban map consisting of 8 × 8 cells. In each episode, the robot starts from a free cell, reaches the depot where the package is located, picks it up, travels to another depot—the destination—and delivers it. Each map contains six depots and eight blocked cells.

The goal is to learn the robot’s behaviour from an intentionally small number of expert demonstrations. This is a behavioural cloning problem: you train a model on observation/action examples and then run it step by step on new episodes.

Environment

The depots are indexed 0..5 and labelled A..F. An episode ends successfully when the robot executes a valid dropoff action at the destination while carrying the package. At most 120 actions are allowed.

Moving into a wall or outside the map does not change the robot’s position, but it consumes one step. pickup succeeds only at the package depot, when the robot is not already carrying the package. dropoff succeeds only at the destination, when the robot is carrying the package. An invalid pickup or dropoff does not change the state and consumes one step.

Observation

Each training observation contains:

• grid: a float32 tensor with shape (6, 8, 8);
• vector: 13 normalized numerical values;
• action_mask: six Boolean values indicating the valid actions;
• state: (row, column, package_field, destination).

The channels of the grid tensor represent:

1. walls;
2. all depots;
3. the robot’s position;
4. the package position, with an empty channel while the package is being carried;
5. the destination;
6. the carrying indicator, repeated across the entire map.

The vector contains, in order: the robot’s normalized row and column, the package field, the destination, the carrying indicator, the row and column of the current target, the differences relative to the target, followed by four blocked-movement indicators in the order south, north, east, west.

Data

The public dataset contains:

• 400 successful expert demonstrations, containing 5,327 labelled steps;
• 200 validation scenarios without expert actions;
• 1,600 test scenarios without expert actions.

The platform package uses JSON and safe NumPy arrays rather than Python pickle files. See starter_kit.py for the exact names and loading code. Load NumPy files using allow_pickle=False.

Each layout_id is shared by four episodes. The unique key is always:

1(layout_id, episode_seed)

Task

Train a deterministic model that predicts the next action from the current observation. Run the model over complete episodes and generate one action sequence for each test scenario.

You may use the provided demonstrations for training. You are not allowed to obtain expert labels for the validation or test sets, nor may you generate additional expert demonstrations through search, planning, or another expert model. Rule-based or explicitly hard-coded solutions may be reviewed by the Scientific Committee. The organizers may request the notebook or source code used to generate the submission.

Submission Format

Submit a ZIP archive named predictions.zip, containing exactly one file at its root: predictions.json.

The file must contain a JSON array with exactly 1,600 objects, one for each test episode:

1[2  {"layout_id":"test_0000","episode_seed":300000,"actions":[1,1,2,4,0,5]}3]

Requirements:

• episodes are matched using (layout_id, episode_seed), not by row order;
• each episode must appear exactly once;
• unknown or duplicate keys are not allowed;
• actions must be a JSON list of integers—not Boolean values—between 0 and 5;
• each list may contain at most 120 actions;
• prediction generation must be deterministic.

Invalid archives or incomplete submissions are rejected.

Evaluation

The metric is the episode success rate:

1SR = successful deliveries / evaluated episodes2score = 100 × SR

No partial credit is awarded for reaching the package, getting closer to the target, or using fewer steps.

For the platform leaderboard, the test maps are split deterministically:

• live/partial leaderboard: 80 maps, 320 episodes;
• final/full leaderboard: 320 maps, 1,280 episodes.

During the competition, the partial score is displayed, while the final leaderboard uses the full set. Membership in the two subsets is not included in the public data. The average number of steps and invalid pickup/dropoff attempts may appear in the evaluator logs, but they do not affect the score.

Attribution

Adapted from “Robot Delivery Academy: Preparatory Program” (IOAI 2026, Home Task 2). The safe data representation, validation rules, leaderboard split, and evaluator are adaptations for the MLCompete platform.