{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "zetN4ubB12vc" }, "source": [ "# Robot Delivery Academy: Preparatory Program\n", "\n", "## 1. Problem Description\n", "\n", "Welcome to the **Robot Delivery Academy**, the preparatory program for the Robot Training task.\n", "\n", "You are working with a small delivery robot on an `8 x 8` city map. In each episode, the robot starts somewhere on the map, picks up a package from one depot, and delivers it to another depot. Some cells are blocked, and every map is slightly different.\n", "\n", "For a human programmer, this kind of task may look easy: inspect the map, find a path, pick up the package, deliver it. But the goal here is different. We want to check whether an AI model can learn this behavior from examples instead of being given the full hand-written strategy.\n", "\n", "The training principle is supervised learning. We prepare many examples of the form:\n", "\n", "```text\n", "observation -> action\n", "```\n", "\n", "The model sees what action was taken in each situation and tries to learn the pattern. Later, it must act on new scenarios where the answers are not provided.\n", "\n", "### Your Mission\n", "\n", "Train a model that can:\n", "\n", "1. Learn from provided demonstrations.\n", "2. Predict a useful next action from the current observation.\n", "3. Run for a complete episode and deliver the package.\n", "4. Generalize to validation and test scenarios that were not shown as demonstrations.\n", "\n", "### The Challenge\n", "\n", "You are given a deliberately small demonstration budget. The interesting question is not whether the task can be solved by a search algorithm, but whether you can train a model that learns enough from limited examples.\n", "\n", "A single wrong action can move the robot into states that were rare in the demonstrations, so high action accuracy does not always mean high episode success.\n" ], "id": "zetN4ubB12vc" }, { "cell_type": "markdown", "metadata": { "id": "MP0HNTo412ve" }, "source": [ "## 2. Download the data\n", "\n", "This task's data (three `.pkl` files) lives in the shared **`IOAI-2026/RobotDelivery`** Drive folder. The cell below downloads it into a local `data/` folder — no sign-in or setup, just run it." ], "id": "MP0HNTo412ve", "outputs": [], "execution_count": null }, { "cell_type": "code", "execution_count": null, "id": "c12b1a1b", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "c12b1a1b", "outputId": "7fb339c3-0622-4f3b-cfda-bf3f844aa5bd" }, "outputs": [], "source": [ "!pip install -q gdown\n", "import os\n", "from pathlib import Path\n", "import gdown\n", "\n", "# Data lives in the shared IOAI-2026/RobotDelivery folder (public link, no sign-in).\n", "DATA_DIR = Path('data')\n", "if not DATA_DIR.exists() or not any(DATA_DIR.iterdir()):\n", " gdown.download_folder(id='1DXFDoY9bqulMBFacyDShVIx8Sa7Z5Wpa',\n", " output=str(DATA_DIR), quiet=True, use_cookies=False)\n", "os.listdir(DATA_DIR)" ] }, { "cell_type": "markdown", "id": "611ad339", "metadata": { "id": "611ad339" }, "source": [ "## 3. Understanding the Task Simulator\n", "\n", "For this preparatory task, we also provide a small simulator. It is mainly here to make the task easier to understand: you can use it to inspect scenario conditions, replay demonstration trajectories, and visualize the solutions produced by your model.\n", "\n", "The task is a small grid delivery problem.\n", "\n", "- The grid size is `8 x 8`.\n", "- There are six depot cells: `A`, `B`, `C`, `D`, `E`, `F`.\n", "- One depot contains the package.\n", "- Another depot is the destination.\n", "- The robot must move to the package, pick it up, move to the destination, and drop it off.\n", "- Walls block movement.\n", "\n", "The simulator is included directly in this notebook so it works as a single Google Colab file. It is used to show examples and to check complete episodes after training. The visual helper below can also save and display animated GIFs.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "9c0957a9", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9c0957a9", "outputId": "441f3e83-7922-4af9-816c-788ea5f25bf3" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "data dir: data\n", "device: cpu\n" ] } ], "source": [ "import json\n", "import pickle\n", "import random\n", "import zipfile\n", "from collections import Counter\n", "from pathlib import Path\n", "from typing import Any\n", "\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "from torch.utils.data import DataLoader, Dataset\n", "from IPython.display import Image as NotebookImage, display\n", "from PIL import Image as PILImage, ImageDraw\n", "from tqdm.auto import tqdm\n", "\n", "SEED = 42\n", "random.seed(SEED)\n", "np.random.seed(SEED)\n", "torch.manual_seed(SEED)\n", "\n", "GRID_SIZE = 8\n", "N_DEPOTS = 6\n", "MAX_STEPS = 120\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "ACTION_NAMES = {\n", " 0: \"south\",\n", " 1: \"north\",\n", " 2: \"east\",\n", " 3: \"west\",\n", " 4: \"pickup\",\n", " 5: \"dropoff\",\n", "}\n", "\n", "ACTION_DELTAS = {\n", " 0: (1, 0),\n", " 1: (-1, 0),\n", " 2: (0, 1),\n", " 3: (0, -1),\n", "}\n", "\n", "DEPOT_NAMES = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\"]\n", "\n", "print(\"data dir:\", DATA_DIR)\n", "print(\"device:\", DEVICE)\n" ] }, { "cell_type": "code", "execution_count": null, "id": "1c226bae", "metadata": { "id": "1c226bae" }, "outputs": [], "source": [ "class DeliverySimulator8x8:\n", " \"\"\"Run one 8x8 delivery episode.\"\"\"\n", "\n", " def reset(self, scenario: dict[str, Any]) -> tuple[int, int, int, int]:\n", " \"\"\"Start a scenario and return the compact state.\"\"\"\n", " self.step_count = 0\n", " self.carrying = False\n", " self.walls = {tuple(cell) for cell in scenario[\"walls\"]}\n", " self.depots = [tuple(cell) for cell in scenario[\"depots\"]]\n", " self.agent_pos = tuple(scenario[\"agent_pos\"])\n", " self.package_location = int(scenario[\"package_location\"])\n", " self.destination = int(scenario[\"destination\"])\n", " return self.state()\n", "\n", " def state(self) -> tuple[int, int, int, int]:\n", " \"\"\"Return row, column, package field, and destination.\"\"\"\n", " package_field = N_DEPOTS if self.carrying else self.package_location\n", " return int(self.agent_pos[0]), int(self.agent_pos[1]), int(package_field), int(self.destination)\n", "\n", " def can_enter(self, row: int, col: int) -> bool:\n", " \"\"\"Check whether the robot can occupy a cell.\"\"\"\n", " return 0 <= row < GRID_SIZE and 0 <= col < GRID_SIZE and (row, col) not in self.walls\n", "\n", " def valid_action_mask(self) -> np.ndarray:\n", " \"\"\"Return the currently valid actions.\"\"\"\n", " row, col, _, destination = self.state()\n", " mask = np.zeros(6, dtype=bool)\n", " for action, (dr, dc) in ACTION_DELTAS.items():\n", " mask[action] = self.can_enter(row + dr, col + dc)\n", " mask[4] = (not self.carrying) and self.agent_pos == self.depots[self.package_location]\n", " mask[5] = self.carrying and self.agent_pos == self.depots[destination]\n", " return mask\n", "\n", " def observation(self) -> dict[str, Any]:\n", " \"\"\"Build the model observation for the current state.\"\"\"\n", " row, col, package_field, destination = self.state()\n", " carrying = package_field == N_DEPOTS\n", " dest_row, dest_col = self.depots[destination]\n", " target_row, target_col = (dest_row, dest_col) if carrying else self.depots[package_field]\n", "\n", " grid = np.zeros((6, GRID_SIZE, GRID_SIZE), dtype=np.float32)\n", " for wr, wc in self.walls:\n", " grid[0, wr, wc] = 1.0\n", " for dr, dc in self.depots:\n", " grid[1, dr, dc] = 1.0\n", " grid[2, row, col] = 1.0\n", " if not carrying:\n", " pr, pc = self.depots[package_field]\n", " grid[3, pr, pc] = 1.0\n", " grid[4, dest_row, dest_col] = 1.0\n", " grid[5, :, :] = float(carrying)\n", "\n", " blocked_moves = [float(not self.can_enter(row + dr, col + dc)) for dr, dc in ACTION_DELTAS.values()]\n", " vector = np.array(\n", " [\n", " row / (GRID_SIZE - 1),\n", " col / (GRID_SIZE - 1),\n", " package_field / N_DEPOTS,\n", " destination / (N_DEPOTS - 1),\n", " float(carrying),\n", " target_row / (GRID_SIZE - 1),\n", " target_col / (GRID_SIZE - 1),\n", " (target_row - row) / (GRID_SIZE - 1),\n", " (target_col - col) / (GRID_SIZE - 1),\n", " *blocked_moves,\n", " ],\n", " dtype=np.float32,\n", " )\n", " return {\"grid\": grid, \"vector\": vector, \"action_mask\": self.valid_action_mask(), \"state\": self.state()}\n", "\n", " def step(self, action: int) -> tuple[tuple[int, int, int, int], bool, bool, dict[str, Any]]:\n", " \"\"\"Apply one action and report episode status.\"\"\"\n", " action = int(action)\n", " done = False\n", " info = {\"invalid_pickup_or_dropoff\": False}\n", "\n", " if action in ACTION_DELTAS:\n", " dr, dc = ACTION_DELTAS[action]\n", " row, col = self.agent_pos[0] + dr, self.agent_pos[1] + dc\n", " if self.can_enter(row, col):\n", " self.agent_pos = (row, col)\n", " elif action == 4 and (not self.carrying) and self.agent_pos == self.depots[self.package_location]:\n", " self.carrying = True\n", " elif action == 5 and self.carrying and self.agent_pos == self.depots[self.destination]:\n", " done = True\n", " self.carrying = False\n", " self.package_location = self.destination\n", " elif action in (4, 5):\n", " info[\"invalid_pickup_or_dropoff\"] = True\n", " else:\n", " raise ValueError(f\"unknown action: {action}\")\n", "\n", " self.step_count += 1\n", " return self.state(), done, self.step_count >= MAX_STEPS and not done, info\n", "\n", " def render(self) -> str:\n", " \"\"\"Return an ASCII rendering of the current grid.\"\"\"\n", " grid = [[\".\" for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]\n", " for row, col in self.walls:\n", " grid[row][col] = \"#\"\n", " for i, (row, col) in enumerate(self.depots):\n", " grid[row][col] = DEPOT_NAMES[i]\n", "\n", " agent_row, agent_col = self.agent_pos\n", " grid[agent_row][agent_col] = \"T*\" if self.carrying else \"T\"\n", " rows = [\" \".join(f\"{cell:>2}\" for cell in row) for row in grid]\n", " package_name = \"in taxi\" if self.carrying else DEPOT_NAMES[self.package_location]\n", " rows.append(f\"package={package_name}, destination={DEPOT_NAMES[self.destination]}\")\n", " return \"\\n\".join(rows)\n" ] }, { "cell_type": "code", "execution_count": null, "id": "94500d0f", "metadata": { "id": "94500d0f" }, "outputs": [], "source": [ "CELL_SIZE = 56\n", "FRAME_FOOTER = 44\n", "DEPOT_COLORS = [\"#ef4444\", \"#3b82f6\", \"#22c55e\", \"#f59e0b\", \"#a855f7\", \"#06b6d4\"]\n", "\n", "\n", "def draw_episode_frame(simulator, step=0, action_name=\"start\"):\n", " \"\"\"Render the current simulator state as a PIL image.\"\"\"\n", " width = GRID_SIZE * CELL_SIZE\n", " height = GRID_SIZE * CELL_SIZE + FRAME_FOOTER\n", " image = PILImage.new(\"RGB\", (width, height), \"#f8fafc\")\n", " draw = ImageDraw.Draw(image)\n", "\n", " for row in range(GRID_SIZE):\n", " for col in range(GRID_SIZE):\n", " x0, y0 = col * CELL_SIZE, row * CELL_SIZE\n", " x1, y1 = x0 + CELL_SIZE, y0 + CELL_SIZE\n", " fill = \"#334155\" if (row, col) in simulator.walls else \"#f8fafc\"\n", " draw.rectangle([x0, y0, x1, y1], fill=fill, outline=\"#cbd5e1\")\n", "\n", " target_id = simulator.destination if simulator.carrying else simulator.package_location\n", " for depot_id, (row, col) in enumerate(simulator.depots):\n", " x0, y0 = col * CELL_SIZE + 8, row * CELL_SIZE + 8\n", " x1, y1 = x0 + CELL_SIZE - 16, y0 + CELL_SIZE - 16\n", " color = DEPOT_COLORS[depot_id]\n", " draw.rounded_rectangle([x0, y0, x1, y1], radius=10, fill=color)\n", " draw.text((x0 + 14, y0 + 9), DEPOT_NAMES[depot_id], fill=\"white\")\n", " if depot_id == target_id:\n", " draw.rounded_rectangle([x0 - 4, y0 - 4, x1 + 4, y1 + 4], radius=14, outline=\"#111827\", width=4)\n", "\n", " row, col = simulator.agent_pos\n", " cx, cy = col * CELL_SIZE + CELL_SIZE // 2, row * CELL_SIZE + CELL_SIZE // 2\n", " draw.ellipse([cx - 18, cy - 18, cx + 18, cy + 18], fill=\"#111827\")\n", " draw.text((cx - 5, cy - 8), \"T\", fill=\"white\")\n", " if simulator.carrying:\n", " draw.rectangle([cx + 10, cy - 24, cx + 25, cy - 9], fill=\"#f97316\", outline=\"#9a3412\")\n", "\n", " package = \"in robot\" if simulator.carrying else DEPOT_NAMES[simulator.package_location]\n", " footer = f\"step {step:02d} | action: {action_name} | package: {package} -> {DEPOT_NAMES[simulator.destination]}\"\n", " draw.rectangle([0, GRID_SIZE * CELL_SIZE, width, height], fill=\"#e2e8f0\")\n", " draw.text((12, GRID_SIZE * CELL_SIZE + 14), footer, fill=\"#0f172a\")\n", " return image\n", "\n", "\n", "def show_episode_gif(scenario, actions, path=\"episode.gif\", duration=450):\n", " \"\"\"Save and display an animated GIF for one action sequence.\"\"\"\n", " simulator = DeliverySimulator8x8()\n", " simulator.reset(scenario)\n", " frames = [draw_episode_frame(simulator)]\n", " for step, action in enumerate(actions, start=1):\n", " simulator.step(action)\n", " frames.append(draw_episode_frame(simulator, step, ACTION_NAMES[action]))\n", " frames[0].save(path, save_all=True, append_images=frames[1:], duration=duration, loop=0)\n", " display(NotebookImage(filename=path))\n", "\n" ] }, { "cell_type": "markdown", "id": "93720bc4", "metadata": { "id": "93720bc4" }, "source": [ "## 4. Dataset\n", "\n", "### 4.1 Provided Training Data\n", "\n", "You are provided with expert demonstrations saved in `data/train_demos.pkl`.\n", "\n", "Each trajectory contains observations and expert actions from one successful delivery episode.\n", "\n", "**Data Format:**\n", "\n", "```python\n", "{\n", " \"trajectories\": [\n", " {\n", " \"layout_id\": str,\n", " \"episode_seed\": int,\n", " \"scenario\": dict,\n", " \"observations\": [\n", " {\n", " \"grid\": np.array, # shape: (6, 8, 8)\n", " \"vector\": np.array, # shape: (13,)\n", " \"action_mask\": np.array,# shape: (6,)\n", " \"state\": tuple\n", " },\n", " ...\n", " ],\n", " \"actions\": [int, ...], # action IDs 0-5\n", " \"success\": bool,\n", " \"num_steps\": int\n", " },\n", " ...\n", " ]\n", "}\n", "```\n", "\n", "### 4.2 Validation and Test Scenarios\n", "\n", "You are also provided with:\n", "\n", "- `data/valid_scenarios.pkl`\n", "- `data/test_scenarios.pkl`\n", "\n", "These files contain delivery scenarios without expert action labels. They are used to run your trained model and check complete-episode success.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "53bd4d78", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "53bd4d78", "outputId": "fa942225-df29-469f-f7de-a16bf9684a93" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Loaded data\n", " training demonstrations: 400\n", " validation scenarios: 200\n", " test scenarios: 1600\n", " training state-action samples: 5327\n", " average demonstration length: 13.32\n", " expert success rate: 100.0%\n" ] } ], "source": [ "with (DATA_DIR / \"train_demos.pkl\").open(\"rb\") as f:\n", " train_data = pickle.load(f)\n", "with (DATA_DIR / \"valid_scenarios.pkl\").open(\"rb\") as f:\n", " valid_scenarios = pickle.load(f)\n", "with (DATA_DIR / \"test_scenarios.pkl\").open(\"rb\") as f:\n", " test_scenarios = pickle.load(f)\n", "\n", "train_trajectories = train_data[\"trajectories\"]\n", "steps = [t[\"num_steps\"] for t in train_trajectories]\n", "\n", "print(\"Loaded data\")\n", "print(\" training demonstrations:\", len(train_trajectories))\n", "print(\" validation scenarios:\", len(valid_scenarios))\n", "print(\" test scenarios:\", len(test_scenarios))\n", "print(\" training state-action samples:\", sum(steps))\n", "print(\" average demonstration length:\", f\"{np.mean(steps):.2f}\")\n", "print(\" expert success rate:\", f\"{100 * np.mean([t['success'] for t in train_trajectories]):.1f}%\")\n" ] }, { "cell_type": "code", "execution_count": null, "id": "787aadc4", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 940 }, "id": "787aadc4", "outputId": "d2d83396-90f4-4081-d085-a1fb81984f3c" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Example trajectory\n", " layout_id: train_0000\n", " episode_seed: 100000\n", " num_steps: 23\n", " actions: ['north', 'north', 'north', 'east', 'east', 'east', 'east', 'east', 'pickup', 'south', 'west', 'south', 'south', 'south', 'south', 'south', 'west', 'west', 'west', 'west', 'west', 'west', 'dropoff']\n", "\n", "Observation\n", " grid shape: (6, 8, 8)\n", " vector shape: (13,)\n", " valid actions: ['south', 'north', 'east']\n", "\n", "Initial frame\n", " . . . . . . . A\n", " . # . . E # D .\n", " . . . . . . . #\n", " . # T . . # . .\n", " F . . # # . . .\n", " . . . . . # . .\n", " B . . . . . . .\n", " . . . . . . . .\n", "package=A, destination=B\n", "\n", "Animated example\n" ] }, { "output_type": "display_data", "data": { "image/gif": "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\n", "text/plain": [ "" ] }, "metadata": {} } ], "source": [ "example = train_trajectories[0]\n", "print(\"Example trajectory\")\n", "print(\" layout_id:\", example[\"layout_id\"])\n", "print(\" episode_seed:\", example[\"episode_seed\"])\n", "print(\" num_steps:\", example[\"num_steps\"])\n", "print(\" actions:\", [ACTION_NAMES[a] for a in example[\"actions\"]])\n", "\n", "obs0 = example[\"observations\"][0]\n", "print(\"\\nObservation\")\n", "print(\" grid shape:\", obs0[\"grid\"].shape)\n", "print(\" vector shape:\", obs0[\"vector\"].shape)\n", "print(\" valid actions:\", [ACTION_NAMES[i] for i, ok in enumerate(obs0[\"action_mask\"]) if ok])\n", "\n", "simulator = DeliverySimulator8x8()\n", "simulator.reset(example[\"scenario\"])\n", "print(\"\\nInitial frame\")\n", "print(simulator.render())\n", "\n", "print(\"\\nAnimated example\")\n", "show_episode_gif(example[\"scenario\"], example[\"actions\"], path=\"expert_demo.gif\")\n", "\n" ] }, { "cell_type": "markdown", "id": "e339fe9e", "metadata": { "id": "e339fe9e" }, "source": [ "## 5. Task\n", "\n", "### 5.1 Objective\n", "\n", "Train a behavioral cloning action model that:\n", "\n", "1. Takes the current observation as input.\n", "2. Predicts the expert's next action.\n", "3. Runs step by step in a full delivery episode.\n", "4. Achieves high success rate on validation and test scenarios.\n", "\n", "### 5.2 Input and Output\n", "\n", "**Input observation:**\n", "\n", "- `grid`: `6 x 8 x 8` tensor with walls, depots, robot position, package position, destination, and carrying flag.\n", "- `vector`: 13 numerical features with normalized position and target information.\n", "- `action_mask`: 6 binary values showing which actions are currently valid.\n", "\n", "**Output action:**\n", "\n", "A single integer from `0` to `5`:\n", "\n", "| id | action |\n", "|---:|---|\n", "| 0 | south |\n", "| 1 | north |\n", "| 2 | east |\n", "| 3 | west |\n", "| 4 | pickup |\n", "| 5 | dropoff |\n", "\n", "### 5.3 Training Approach\n", "\n", "Behavioral cloning is supervised learning:\n", "\n", "1. Extract `(observation, expert_action)` pairs from demonstrations.\n", "2. Train a neural network classifier.\n", "3. Use cross-entropy loss between predicted action logits and expert actions.\n", "4. Run the trained model in complete episodes.\n", "\n", "### 5.4 Improving Beyond the Baseline\n", "\n", "The baseline below is intentionally simple. Better solutions may come from better input representation, a model that matches the structure of the task, stronger training, and careful analysis of failed episodes.\n" ] }, { "cell_type": "markdown", "id": "242d91d8", "metadata": { "id": "242d91d8" }, "source": [ "## 6. Submission\n", "\n", "### 6.1 What to Submit\n", "\n", "Submit a notebook that produces a file named `predictions.zip` containing:\n", "\n", "1. `predictions.jsonl` — predicted action sequences for all test scenarios.\n", "\n", "### 6.2 Prediction Format\n", "\n", "Each line in `predictions.jsonl` should be one JSON object:\n", "\n", "```json\n", "{\"layout_id\": \"test_0000\", \"episode_seed\": 300000, \"actions\": [1, 1, 2, 4, 0, 5]}\n", "```\n", "\n", "**Fields:**\n", "\n", "- `layout_id`: scenario layout identifier.\n", "- `episode_seed`: scenario seed.\n", "- `actions`: list of action IDs, each integer from `0` to `5`.\n", "\n", "### 6.3 How Evaluation Works\n", "\n", "1. The evaluator reads your predicted actions.\n", "2. For each test scenario, it starts from the provided scenario state.\n", "3. It replays your actions step by step.\n", "4. Success means the package is delivered to the destination.\n", "\n", "### 6.4 Constraints\n", "\n", "- Use the provided demonstrations for training.\n", "- Do not use expert action labels for validation or test scenarios.\n", "- Do not generate additional expert trajectories with search, planning, or another expert model.\n", "- Your final prediction process should be deterministic.\n", "- Your submitted notebook should generate `predictions.zip` from scratch.\n", "- Rule-based or hard-coded solutions may be reviewed by the Scientific Committee.\n" ] }, { "cell_type": "markdown", "id": "7fd0fd7a", "metadata": { "id": "7fd0fd7a" }, "source": [ "## 7. Scoring\n", "\n", "### 7.1 Evaluation Metric\n", "\n", "**Success Rate (SR):**\n", "\n", "```text\n", "SR = (# successful delivery episodes) / (# total episodes)\n", "```\n", "\n", "An episode is successful if the package is delivered to the destination within the step limit.\n", "\n", "### 7.2 Diagnostics\n", "\n", "The notebook also reports:\n", "\n", "- `avg_steps`: average number of steps used per episode.\n", "- `avg_invalid_pickup_or_dropoff`: average number of invalid pickup/dropoff attempts.\n", "\n", "These diagnostics are not a replacement for success rate, but they help debug model behavior.\n" ] }, { "cell_type": "markdown", "id": "d546ff67", "metadata": { "id": "d546ff67" }, "source": [ "## 8. Baseline & Training\n", "\n", "Below is a complete baseline implementation using a simple MLP.\n", "\n", "**Baseline Key Limitations:**\n", "\n", "- The grid is flattened, so spatial structure is mostly lost.\n", "- Rare actions such as `pickup` and `dropoff` are harder to learn.\n", "- Action masking is used only during inference, not during training.\n", "- The architecture is small and intended only as a starting point.\n", "\n", "**Your task:** improve the model and training procedure to achieve better episode success.\n" ] }, { "cell_type": "markdown", "id": "2d0f1d6b", "metadata": { "id": "2d0f1d6b" }, "source": [ "### 8.1 Create Supervised Training Samples\n" ] }, { "cell_type": "code", "execution_count": null, "id": "fcbb6de5", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fcbb6de5", "outputId": "65984f15-7fa3-4b60-84ec-a2c2ee859db7" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Created dataset\n", " state-action samples: 5327\n", " feature dimension: 397\n", " first action: 1 north\n", " action counts: {'north': 1148, 'east': 1120, 'pickup': 400, 'south': 1066, 'west': 1193, 'dropoff': 400}\n" ] } ], "source": [ "def flatten_observation(obs):\n", " \"\"\"Flatten one observation into a feature vector.\"\"\"\n", " return np.concatenate([\n", " obs[\"grid\"].astype(np.float32).reshape(-1),\n", " obs[\"vector\"].astype(np.float32),\n", " ])\n", "\n", "\n", "class DeliveryDemoDataset(Dataset):\n", " \"\"\"Store demonstration steps as supervised examples.\"\"\"\n", "\n", " def __init__(self, trajectories):\n", " \"\"\"Collect all observation-action pairs.\"\"\"\n", " self.samples = [\n", " (obs, int(action))\n", " for trajectory in trajectories\n", " for obs, action in zip(trajectory[\"observations\"], trajectory[\"actions\"], strict=True)\n", " ]\n", "\n", " def __len__(self):\n", " \"\"\"Return the number of supervised examples.\"\"\"\n", " return len(self.samples)\n", "\n", " def __getitem__(self, idx):\n", " \"\"\"Return one feature vector and action label.\"\"\"\n", " obs, action = self.samples[idx]\n", " return (\n", " torch.tensor(flatten_observation(obs), dtype=torch.float32),\n", " torch.tensor(action, dtype=torch.long),\n", " )\n", "\n", "\n", "train_dataset = DeliveryDemoDataset(train_trajectories)\n", "train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)\n", "\n", "x0, y0 = train_dataset[0]\n", "action_counts = Counter(int(train_dataset[i][1]) for i in range(len(train_dataset)))\n", "print(\"Created dataset\")\n", "print(\" state-action samples:\", len(train_dataset))\n", "print(\" feature dimension:\", x0.numel())\n", "print(\" first action:\", int(y0), ACTION_NAMES[int(y0)])\n", "print(\" action counts:\", {ACTION_NAMES[k]: v for k, v in action_counts.items()})\n" ] }, { "cell_type": "markdown", "id": "23a688a5", "metadata": { "id": "23a688a5" }, "source": [ "### 8.2 Define Action Model\n", "\n", "This baseline uses a small MLP. Stronger solutions should preserve the `8 x 8` spatial structure.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "ddb5a11c", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ddb5a11c", "outputId": "bb6b4fa6-561b-4fb4-cef2-5ea2031797a6" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "SimpleMLPActionModel(\n", " (net): Sequential(\n", " (0): Linear(in_features=397, out_features=128, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=128, out_features=128, bias=True)\n", " (3): ReLU()\n", " (4): Linear(in_features=128, out_features=6, bias=True)\n", " )\n", ")\n", "parameters: 68230\n" ] } ], "source": [ "class SimpleMLPActionModel(nn.Module):\n", " \"\"\"Predict the next action from flattened observation features.\"\"\"\n", "\n", " def __init__(self, input_dim, hidden_dim=128, n_actions=6):\n", " \"\"\"Create a two-hidden-layer MLP.\"\"\"\n", " super().__init__()\n", " self.net = nn.Sequential(\n", " nn.Linear(input_dim, hidden_dim),\n", " nn.ReLU(),\n", " nn.Linear(hidden_dim, hidden_dim),\n", " nn.ReLU(),\n", " nn.Linear(hidden_dim, n_actions),\n", " )\n", "\n", " def forward(self, x):\n", " \"\"\"Return action logits.\"\"\"\n", " return self.net(x)\n", "\n", "\n", "model = SimpleMLPActionModel(input_dim=x0.numel()).to(DEVICE)\n", "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", "criterion = nn.CrossEntropyLoss()\n", "\n", "print(model)\n", "print(\"parameters:\", sum(p.numel() for p in model.parameters()))\n" ] }, { "cell_type": "markdown", "id": "996d499b", "metadata": { "id": "996d499b" }, "source": [ "### 8.3 Train the Action Model\n" ] }, { "cell_type": "code", "execution_count": null, "id": "ec584450", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 174, "referenced_widgets": [ "59dbaeda1223489c8111b1453a91fe0b", "8dd32ccd43a74764994ec88ba88c1644", "13f56156bd7b4d07b877c8144b275c5e", "9aa9ff04bede4043842f8c05dbd2286a", "cbf81fe3aa194e9b9476ed27f8e0cd31", "4b7b11fbe9114eb5a67e19f9f49b7c2b", "a9215a078b2443d88a903639fd5e5d6b", "4978e5e0a2e04a7aaa121718963f3c18", "4d26c0e03e2e4f8c8b32284a779691c2", "b2d542c8ca2547faaf793efb9099a181", "1da536984fb546f9857f5f2556be1dfc" ] }, "id": "ec584450", "outputId": "fa77f116-376f-484a-d945-bd7d98796bcd" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ " 0%| | 0/30 [00:00" ] }, "metadata": {} } ], "source": [ "example_run = run_episode(valid_scenarios[0], mlp_action_model, render=True)\n", "print(\"success:\", example_run[\"success\"])\n", "print(\"steps:\", example_run[\"steps\"])\n", "print(\"invalid pickup/dropoff:\", example_run[\"invalid_pickup_or_dropoff\"])\n", "print(\"actions:\", [ACTION_NAMES[a] for a in example_run[\"actions\"]])\n", "print(\"initial frame:\")\n", "print(example_run[\"frames\"][0])\n", "print(\"final frame:\")\n", "print(example_run[\"frames\"][-1])\n", "\n", "print(\"animated rollout:\")\n", "show_episode_gif(valid_scenarios[0], example_run[\"actions\"], path=\"model_rollout.gif\")\n" ] }, { "cell_type": "markdown", "id": "0fe5ae71", "metadata": { "id": "0fe5ae71" }, "source": [ "### 8.6 Generate Submission Files\n", "\n", "The test set contains scenarios without expert actions. A prediction is a list of actions for each scenario.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "36fb909e", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000, "referenced_widgets": [ "0162387cc7fd46839d2545d81780f346", "1093831c900b4d01994ffc5d84e2834c", "2b40f2d3139347d188392751bebe3b0e", "5285a15fbf7c4de8bcd50395ae8baf62", "6b9420768d6e48b89539253121c2895c", "9f9560ee2f0b40c3ae864f8dfeef760a", "4997a9b601094b779cc4a0bcc9e03faf", "6371153f7c0a477b9b6a08e60cad48ae", "5dd242c01fe848c8a822e93113fde5d7", "672c38d036e946b089cd5325ee811936", "39a9470fce5e43cd8d888cc4c7e6e94b" ] }, "id": "36fb909e", "outputId": "cf67b943-f402-43ef-86f8-997d2c12ef14" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "Generating predictions: 0%| | 0/5 [00:00