diff --git a/labs/rl_decision/lab_cql_offline_minigrid/README.md b/labs/rl_decision/lab_cql_offline_minigrid/README.md new file mode 100644 index 0000000..feb96f5 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/README.md @@ -0,0 +1,64 @@ +# lab · CQL on an 8×8 offline-RL gridworld + +> 最小但忠实的 CQL（Conservative Q-Learning, Kumar et al. 2020）复现。8×8 离散网格、固定 10 000 条离线数据、三个 trainer（BC / DQN / CQL）共用同一个 MLP critic，整个 notebook 在 CPU 上 < 2 分钟跑完。 + +## Quickstart + +```bash +cd labs/rl_decision/lab_cql_offline_minigrid +pip install -r requirements.txt + +# (可选) 单独跑某个 trainer，每个 < 20s： +python -m src.dataset # 收集并保存 data/offline_dataset.pt +python -m src.trainer_bc # data/bc.pt +python -m src.trainer_dqn # data/dqn.pt +python -m src.trainer_cql # data/cql.pt (alpha=auto) +python -m src.trainer_cql --alpha-mode fixed --alpha-fixed 5.0 # ablation +python -m src.trainer_cql --alpha-mode zero # = DQN + +# 端到端故事 (~80 秒)： +jupyter nbconvert --execute --to notebook --inplace notebook.ipynb +``` + +## What this lab proves + +- **离线 DQN 会过估计 OOD 动作。** Cell 3 / 4 的 `q_overestimation.png` 右栏直接画出 `Q_OOD − Q_seen`：DQN 翻正到 +0.45；CQL 一路压到 −1.3。 +- **CQL 的 log-sum-exp 罚项把 Q 牢牢保留在数据流形内。** OOD-density 图（cell 5）显示 CQL 选的 greedy 动作在行为策略下的概率比 DQN 高，并且不再像 DQN 那样塌缩到右+下两个动作。 +- **α 自适应 > 任何固定 α。** Ablation 直接对比 α=0 / fixed-5 / auto；α=0（=DQN）的评估曲线在 ±0.85 之间剧烈反复，fixed-5 把 Q_seen 推到 3.6（过保守），auto 把 α 自动调到 ~0.6，Q 量级与真实回报最接近。 +- **CQL ≈ BC 在这个 trivial 任务上**：环境太小，BC 的 mode-cloning 已经足以取到最优；这正是 CQL 论文反复强调的——CQL 的真正价值在 D4RL / 真实驾驶等更难任务里。本 lab 把 *机理* 跑清楚；scaling 留给 stretch goal。 + +## 文件契约 + +``` +. +├── README.md +├── notebook.ipynb ← 7-cell 可执行故事 +├── paper.md ← 250-token 蒸馏，链接 paper_cql 卡片 +├── requirements.txt +├── src/ +│ ├── __init__.py +│ ├── env.py ← 8×8 稀疏奖励网格 + 10% slip +│ ├── dataset.py ← 50% random + 50% ε-greedy expert 收集器 +│ ├── model.py ← shared QNet MLP（BC / DQN / CQL 共用） +│ ├── trainer_bc.py ← 交叉熵 BC（默认 full dataset） +│ ├── trainer_dqn.py ← TD(0) + target net，纯离线 +│ ├── trainer_cql.py ← TD + log-sum-exp 罚项，α 自适应 (Lagrangian) +│ ├── viz.py ← 所有 matplotlib 绘图 +│ └── seeds.py +├── assets/ ← notebook 生成的 PNG +│ ├── action_histogram.png +│ ├── q_overestimation.png ← 核心图：DQN 发散 / CQL 守恒 +│ ├── ood_action_density.png ← 行为策略下 greedy 动作的密度 +│ ├── eval_returns.png ← BC / DQN / CQL 评估曲线 +│ ├── ablation_alpha.png ← α=0 / fixed-5 / auto +│ └── ablation_alpha_traj.png ← α 与 gap 的轨迹 +└── data/ + ├── offline_dataset.pt ← 10k 条离线 transition + ├── bc.pt / dqn.pt / cql.pt ← 三个 trainer 的 checkpoint +``` + +## Three stretch goals（也写在 notebook 末尾） + +1. **奖励改成纯稀疏 +1（去掉 step penalty）+ `max_steps=200`**：让 Q 没有边界压制，DQN 的发散尺度真正放飞；CQL 的 `log-sum-exp` 应该仍能把它压住。 +2. **加 IQL 做对照**：复用 `dataset.py` 与 `model.py`，写 `trainer_iql.py`，用 expectile 回归（τ=0.7）与 KL-policy extraction。CQL = 惩罚 OOD，IQL = 避开 OOD，两路线的核心实务对比。 +3. **数据规模扫描**：让 `n_transitions` 在 {500, 1k, 2k, 5k, 10k, 20k} 上扫描，画三条算法的最终评估对数据量曲线——CQL 的样本复杂度优势才是真正的研究题。 diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/ablation_alpha.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/ablation_alpha.png new file mode 100644 index 0000000..48601c8 Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/ablation_alpha.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/action_histogram.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/action_histogram.png new file mode 100644 index 0000000..2547b2d Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/action_histogram.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/eval_returns.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/eval_returns.png new file mode 100644 index 0000000..2c79cf0 Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/eval_returns.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/ood_action_density.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/ood_action_density.png new file mode 100644 index 0000000..ff606e7 Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/ood_action_density.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation.png new file mode 100644 index 0000000..e8aca63 Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation_dqn_only.png b/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation_dqn_only.png new file mode 100644 index 0000000..289271d Binary files /dev/null and b/labs/rl_decision/lab_cql_offline_minigrid/assets/q_overestimation_dqn_only.png differ diff --git a/labs/rl_decision/lab_cql_offline_minigrid/notebook.ipynb b/labs/rl_decision/lab_cql_offline_minigrid/notebook.ipynb new file mode 100644 index 0000000..486b2dd --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/notebook.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro", + "metadata": {}, + "source": [ + "# lab · CQL on a tiny offline-RL gridworld\n", + "\n", + "在固定数据集上跑 DQN，Q 值会因为 Bellman 备份去查询数据外动作而被推到天上去；CQL 在普通的 TD 损失上加一项 `log-sum-exp Q − E_{a∼D}[Q]`，把数据外动作的 Q 值压低，把数据内动作的 Q 值留住，得到的 Q 是真值的一个下界。本 lab 用一个 8×8 网格世界把这条故事跑出来：\n", + "\n", + "1. 用 50% 随机策略 + 50% ε-greedy 专家（ε=0.3）收集 10 000 条离线数据。\n", + "2. 用同一份数据训练 BC / DQN / CQL，三者用同一个 MLP 作为 critic（架构完全相同，只是损失函数不同）。\n", + "3. 看 Q-overestimation panel：DQN 在 ~1 500 步时出现 OOD > seen 的反转，CQL 一直保持 OOD ≤ seen。\n", + "4. 看 OOD 行为密度：DQN 把 mass 集中在专家偏好的右+下；CQL 分布更接近行为策略。\n", + "5. 看 greedy 评估：BC≈CQL≈最优 0.85；DQN 因 Q 振荡而表现剧烈不稳。\n", + "6. ablation：α=0（=DQN）、α 固定=5、α 自适应——自适应最稳。\n", + "\n", + "> 链接：[paper_cql](../../../docs/data/cards/extended/paper_cql.md)。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell-imports", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:20:41.068881Z", + "iopub.status.busy": "2026-05-27T17:20:41.068659Z", + "iopub.status.idle": "2026-05-27T17:20:42.537399Z", + "shell.execute_reply": "2026-05-27T17:20:42.536550Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch 2.12.0+cpu · cpu threads 4\n" + ] + } + ], + "source": [ + "# Cell 0 — imports & paths\n", + "import os, sys, time\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ROOT = Path.cwd()\n", + "DATA, ASSETS = ROOT / 'data', ROOT / 'assets'\n", + "DATA.mkdir(exist_ok=True); ASSETS.mkdir(exist_ok=True)\n", + "if str(ROOT) not in sys.path:\n", + " sys.path.insert(0, str(ROOT))\n", + "\n", + "from src.dataset import (\n", + " DatasetConfig, OfflineDataset, action_histogram,\n", + " collect_offline_dataset, state_action_support,\n", + ")\n", + "from src.env import N_ACTIONS, make_env\n", + "from src.model import QNet\n", + "from src.trainer_bc import BCConfig, train_bc\n", + "from src.trainer_dqn import DQNConfig, train_dqn\n", + "from src.trainer_cql import CQLConfig, train_cql\n", + "from src.viz import (\n", + " plot_action_histogram, plot_eval_returns,\n", + " plot_ood_action_density, plot_q_overestimation,\n", + ")\n", + "\n", + "SEED = 0\n", + "print('torch', torch.__version__, '· cpu threads', torch.get_num_threads())" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-1", + "metadata": {}, + "source": [ + "## Cell 1 — 收集离线数据集，画行为策略的动作直方图\n", + "\n", + "离线数据集 = 50% 完全随机 + 50% ε-greedy 专家（ε=0.3）。专家走右下；随机一边覆盖空白格子，一边把动作直方图拉平。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:20:42.540750Z", + "iopub.status.busy": "2026-05-27T17:20:42.540471Z", + "iopub.status.idle": "2026-05-27T17:20:43.911617Z", + "shell.execute_reply": "2026-05-27T17:20:43.910883Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "collected 10000 transitions in 1.4s\n", + "random half action counts: [1244, 1245, 1228, 1283]\n", + "expert half action counts: [363, 2336, 1905, 396]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Cell 1 — collect offline dataset + plot action histogram\n", + "t0 = time.time()\n", + "ds_cfg = DatasetConfig(seed=SEED)\n", + "ds = collect_offline_dataset(ds_cfg)\n", + "ds.save(str(DATA / 'offline_dataset.pt'))\n", + "hist = action_histogram(ds)\n", + "plot_action_histogram(hist, str(ASSETS / 'action_histogram.png'))\n", + "print(f'collected {len(ds)} transitions in {time.time() - t0:.1f}s')\n", + "print('random half action counts:', hist['random'].tolist())\n", + "print('expert half action counts:', hist['expert'].tolist())\n", + "from IPython.display import Image\n", + "Image(str(ASSETS / 'action_histogram.png'))" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-2", + "metadata": {}, + "source": [ + "## Cell 2 — 训练 BC 与离线 DQN\n", + "\n", + "两者都用同一份数据、同一个 MLP；区别只是损失：BC 是交叉熵，DQN 是 TD(0)。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:20:43.914292Z", + "iopub.status.busy": "2026-05-27T17:20:43.914010Z", + "iopub.status.idle": "2026-05-27T17:21:09.179797Z", + "shell.execute_reply": "2026-05-27T17:21:09.178484Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[BC] elapsed 10.2s · final eval = 0.851\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[DQN] elapsed 15.1s · final eval = 0.300\n", + "\n", + "Q_seen / Q_OOD over training (DQN):\n", + " step= 25 Q_seen=0.05 Q_OOD=0.04\n", + " step= 525 Q_seen=0.11 Q_OOD=0.36\n", + " step= 1025 Q_seen=0.21 Q_OOD=0.64\n", + " step= 1525 Q_seen=0.36 Q_OOD=0.80\n", + " step= 2025 Q_seen=0.59 Q_OOD=0.93\n", + " step= 2525 Q_seen=0.71 Q_OOD=0.95\n", + " step= 3025 Q_seen=0.80 Q_OOD=0.96\n", + " step= 3525 Q_seen=0.83 Q_OOD=0.96\n", + " step= 4025 Q_seen=0.85 Q_OOD=0.97\n", + " step= 4525 Q_seen=0.85 Q_OOD=0.96\n" + ] + } + ], + "source": [ + "# Cell 2 — train BC and offline DQN\n", + "t0 = time.time()\n", + "bc_model, bc_result = train_bc(ds, BCConfig(seed=SEED), verbose=False)\n", + "print(f'[BC] elapsed {time.time() - t0:.1f}s · final eval = {bc_result.eval_returns[-1][1]:.3f}')\n", + "\n", + "t0 = time.time()\n", + "dqn_model, dqn_result = train_dqn(ds, DQNConfig(seed=SEED), verbose=False)\n", + "print(f'[DQN] elapsed {time.time() - t0:.1f}s · final eval = {dqn_result.eval_returns[-1][1]:.3f}')\n", + "\n", + "print('\\nQ_seen / Q_OOD over training (DQN):')\n", + "for step, q in dqn_result.q_seen[::20]:\n", + " q_ood = dict(dqn_result.q_unseen).get(step, float(\"nan\"))\n", + " print(f' step={step:>5d} Q_seen={q:.2f} Q_OOD={q_ood:.2f}')" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-3", + "metadata": {}, + "source": [ + "## Cell 3 — Q-overestimation：DQN 偏离的可视化\n", + "\n", + "左 / 中：DQN 与 CQL（下一格会跑）的 Q 在数据内 / 数据外 (s,a) 上的均值。右图直接画差值 `Q_OOD − Q_seen`：正数表示模型把没见过的动作估得比见过的更高（textbook 的离线-RL 失败模式）。这里先生成 DQN 的曲线，CQL 在下一格补齐。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cell-3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:21:09.182555Z", + "iopub.status.busy": "2026-05-27T17:21:09.182345Z", + "iopub.status.idle": "2026-05-27T17:21:09.534838Z", + "shell.execute_reply": "2026-05-27T17:21:09.533672Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Cell 3 — quick look at DQN's overestimation (CQL added in next cell)\n", + "dqn_only = {'DQN': {'q_seen': dqn_result.q_seen, 'q_unseen': dqn_result.q_unseen}}\n", + "plot_q_overestimation(dqn_only, str(ASSETS / 'q_overestimation_dqn_only.png'),\n", + " title='DQN alone: Q_OOD soon exceeds Q_seen')\n", + "from IPython.display import Image\n", + "Image(str(ASSETS / 'q_overestimation_dqn_only.png'))" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-4", + "metadata": {}, + "source": [ + "## Cell 4 — 训练 CQL（α 自适应），重画 Q-overestimation\n", + "\n", + "CQL 损失：`L_CQL = L_DQN + α · (logsumexp_a Q(s,a) − E_{a∼D}[Q(s,a)])`。α 用 Lagrangian 自适应：当 `gap > target_gap=5.0` 时增大 α，反之减小。\n", + "\n", + "重画三图，红/绿对比：DQN 的差值翻正了，CQL 的差值始终 ≤ 0。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:21:09.537078Z", + "iopub.status.busy": "2026-05-27T17:21:09.536858Z", + "iopub.status.idle": "2026-05-27T17:21:24.506260Z", + "shell.execute_reply": "2026-05-27T17:21:24.505221Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[CQL] elapsed 14.6s · final eval = 0.851 · final α = 0.626\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Cell 4 — train CQL (auto-alpha) + redraw Q-overestimation\n", + "t0 = time.time()\n", + "cql_model, cql_result = train_cql(ds, CQLConfig(seed=SEED), verbose=False)\n", + "print(f'[CQL] elapsed {time.time() - t0:.1f}s · final eval = {cql_result.eval_returns[-1][1]:.3f}'\n", + " f' · final α = {cql_result.alphas[-1]:.3f}')\n", + "\n", + "panels = {\n", + " 'DQN': {'q_seen': dqn_result.q_seen, 'q_unseen': dqn_result.q_unseen},\n", + " 'CQL': {'q_seen': cql_result.q_seen, 'q_unseen': cql_result.q_unseen},\n", + "}\n", + "plot_q_overestimation(panels, str(ASSETS / 'q_overestimation.png'))\n", + "from IPython.display import Image\n", + "Image(str(ASSETS / 'q_overestimation.png'))" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-5", + "metadata": {}, + "source": [ + "## Cell 5 — 评估 rollouts：BC / DQN / CQL\n", + "\n", + "每个 trainer 在训练循环里每 100 步跑 20 个 greedy episodes。把曲线叠起来；另外画一张行为-策略密度图：模型选的动作在行为策略下的概率均值（越高越接近数据分布）。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:21:24.508903Z", + "iopub.status.busy": "2026-05-27T17:21:24.508708Z", + "iopub.status.idle": "2026-05-27T17:21:24.909560Z", + "shell.execute_reply": "2026-05-27T17:21:24.908619Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "method | final eval | wallclock (s)\n", + "----------------------------------------\n", + "BC | 0.851 | 10.2\n", + "DQN | 0.300 | 15.1\n", + "CQL | 0.851 | 14.6\n" + ] + } + ], + "source": [ + "# Cell 5 — evaluation rollouts + OOD action density\n", + "plot_eval_returns({\n", + " 'BC': bc_result.eval_returns,\n", + " 'DQN': dqn_result.eval_returns,\n", + " 'CQL': cql_result.eval_returns,\n", + "}, str(ASSETS / 'eval_returns.png'))\n", + "plot_ood_action_density(ds, {'BC': bc_model, 'DQN': dqn_model, 'CQL': cql_model},\n", + " str(ASSETS / 'ood_action_density.png'))\n", + "\n", + "from IPython.display import Image, display\n", + "display(Image(str(ASSETS / 'eval_returns.png')))\n", + "display(Image(str(ASSETS / 'ood_action_density.png')))\n", + "\n", + "rows = [\n", + " ('BC', bc_result.eval_returns[-1][1], bc_result.elapsed_s),\n", + " ('DQN', dqn_result.eval_returns[-1][1], dqn_result.elapsed_s),\n", + " ('CQL', cql_result.eval_returns[-1][1], cql_result.elapsed_s),\n", + "]\n", + "print(f'{\"method\":<5} | {\"final eval\":>10} | {\"wallclock (s)\":>14}')\n", + "print('-' * 40)\n", + "for n, e, w in rows:\n", + " print(f'{n:<5} | {e:10.3f} | {w:14.1f}')" + ] + }, + { + "cell_type": "markdown", + "id": "md-cell-6", + "metadata": {}, + "source": "## Cell 6 — ablation：α=0 / α=fixed-5 / α=auto\n\nα=0 等价于直接跑离线 DQN；α 固定=5 是论文 CQL 的常用手动选择；α=auto 用 Lagrangian dual 自适应。在这个 8×8 小网格上 fixed-5 与 auto 在最终评估上都能稳定到 0.85（任务太小，正则化代价不致命），而 α=0 的曲线则在 +0.85 与 −0.50 之间剧烈反复——同样的 Q-net 同样的数据，仅仅是去掉了 `log-sum-exp − E_D[Q]` 项，就让 greedy 策略在每次评估都可能跳到一条新的 OOD 通道。\n\nauto 与 fixed 的 *表面* 差异在这里被环境压窄，但量化指标已经能看出来：auto 跑完 α≈0.6，Q_seen≈2.9；fixed-5 把 Q_seen 推到 3.6+ 而 Q_OOD 也被压到 ~1.9——保守过头会让 TD 损失被淹没。CQL 论文反复强调 \"fixed-α 在不同任务间需要扫\", auto 是论文真正推荐的设置。下面把三条评估曲线叠起来看 α=0 的不稳定，再单独看 α 与 gap 的轨迹。" + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-27T17:21:24.911629Z", + "iopub.status.busy": "2026-05-27T17:21:24.911396Z", + "iopub.status.idle": "2026-05-27T17:21:54.636117Z", + "shell.execute_reply": "2026-05-27T17:21:54.634954Z" + } + }, + "outputs": [], + "source": "# Cell 6 — alpha ablation\nfrom src.viz import plot_alpha_gap_trajectories\nt0 = time.time()\n_, abl_zero = train_cql(ds, CQLConfig(alpha_mode='zero', seed=SEED), verbose=False)\n_, abl_fixed = train_cql(ds, CQLConfig(alpha_mode='fixed', alpha_fixed=5.0, seed=SEED), verbose=False)\nabl_auto = cql_result # already trained\nprint(f'ablation total elapsed {time.time() - t0:.1f}s')\n\nplot_eval_returns({\n 'alpha=0 (DQN)': abl_zero.eval_returns,\n 'CQL-fixed-5': abl_fixed.eval_returns,\n 'CQL-auto': abl_auto.eval_returns,\n}, str(ASSETS / 'ablation_alpha.png'),\n title='CQL ablation · α=0 vs α=fixed-5 vs α=auto')\n\nplot_alpha_gap_trajectories({\n 'alpha=0 (DQN)': {'alphas': abl_zero.alphas, 'cql_gaps': abl_zero.cql_gaps},\n 'CQL-fixed-5': {'alphas': abl_fixed.alphas, 'cql_gaps': abl_fixed.cql_gaps},\n 'CQL-auto': {'alphas': abl_auto.alphas, 'cql_gaps': abl_auto.cql_gaps},\n}, str(ASSETS / 'ablation_alpha_traj.png'))\n\nfrom IPython.display import Image, display\ndisplay(Image(str(ASSETS / 'ablation_alpha.png')))\ndisplay(Image(str(ASSETS / 'ablation_alpha_traj.png')))\n\nprint(f'\\n final eval | final Q_seen | final Q_OOD')\nfor n, r in [('alpha=0 (DQN)', abl_zero), ('CQL-fixed-5', abl_fixed), ('CQL-auto', abl_auto)]:\n print(f'{n:<14} {r.eval_returns[-1][1]:>10.3f} | {r.q_seen[-1][1]:>12.2f} | {r.q_unseen[-1][1]:>10.2f}')" + }, + { + "cell_type": "markdown", + "id": "md-final", + "metadata": {}, + "source": [ + "## Three stretch goals\n", + "\n", + "1. **把奖励改为稀疏 +1（去掉 step penalty）**：当前的 `-0.01/step` 让最优 Q ≈ 0.86，DQN 的发散尺度被边界压住；把 step penalty 设为 0 并增大 `max_steps` 到 200，可以观察 DQN 的 Q 值真正放飞——同时 CQL 的 `log-sum-exp` 项仍能压住。\n", + "2. **加 IQL 作为第四个 trainer**：复用 `src/dataset.py`、`src/model.py`，写一个 `trainer_iql.py`，用 expectile 回归（τ=0.7）和 KL 正则化的策略提取。和 CQL 做对照——『惩罚 OOD』vs『避开 OOD』。\n", + "3. **scaling law**：让 `n_transitions` 在 {500, 1k, 2k, 5k, 10k, 20k} 上扫描，画 BC / DQN / CQL 的最终评估对数据量的曲线。CQL 应该在小数据上和 BC 同水平，而 DQN 在小数据上崩溃最重——离线 RL 的样本复杂度是 CQL 真正的研究题。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/labs/rl_decision/lab_cql_offline_minigrid/paper.md b/labs/rl_decision/lab_cql_offline_minigrid/paper.md new file mode 100644 index 0000000..c687250 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/paper.md @@ -0,0 +1,31 @@ +# 把 Q-learning 关进数据的笼子里：CQL 在一个 8×8 网格上的最小复现 + +链接 Atlas 卡片：[paper_cql](../../../docs/data/cards/extended/paper_cql.md)。 + +离线 RL 的核心难题是 Bellman 备份会去查询数据集没覆盖的动作，让 $Q(s, a^{\text{OOD}})$ 在没有数据修正的情况下被乐观抬高，进而把策略推向真实世界中 catastrophic 的动作。Kumar et al. 2020 的 CQL 给出了一个干净的修补：在普通的 TD 损失上加一项 +$$ +\alpha \, \mathbb{E}_{s \sim D}\!\Big[\log\!\sum_{a}\exp Q(s,a) - \mathbb{E}_{a\sim\hat\pi_\beta(\cdot \mid s)} Q(s, a)\Big], +$$ +即对所有动作做 log-sum-exp，再减去数据集行为策略下 $Q$ 的期望。第一项把 *所有* 动作的 $Q$ 压低，第二项把 *数据内* 动作的 $Q$ 拉回来——净效果是数据外动作被显著压低，数据内动作几乎不动。这正好对应论文证明的 "学到的 $Q$ 是真实 $Q$ 的逐点下界"。 + +本 lab 用一个 8×8 离散网格世界把这条理论故事跑成可见的图： + +1. **数据**：50% 随机 + 50% ε-greedy 专家（ε=0.3），共 10 000 条；专家直奔右下角，随机覆盖死角；环境 10% slip 让评估时的 trajectory 必然偏离训练数据的 deterministic 主线。 +2. **模型**：同一个两层 MLP critic（hidden=128），分别用 BC（对动作做交叉熵）、离线 DQN（TD(0) + target net）、CQL（TD + log-sum-exp 项）训练 5 000 步，batch=256，Adam lr=3e-4。 +3. **CQL 实现细节**：α 用 Lagrangian dual 自适应（target gap=5.0，dual lr=1e-4）；α=0 / α=fixed-5 / α=auto 在 ablation 中三选一对比。 +4. **诊断**：每 25 步统计 `Q` 在数据内 (s,a) 与数据外 (s,a) 上的均值，并把两者的差 `Q_OOD − Q_seen` 当作 "过估计 gap"；每 100 步跑 20 个 greedy episodes 评估。 +5. **故事**：DQN 的过估计 gap 在 ~1 500 步翻正到 +0.45，之后即使 TD 损失收敛到 ≈ 0，greedy 评估仍在 0.85 与 −0.50 之间剧烈反复（Q 在 OOD 上被高估，每次 argmax 都可能指向新的 OOD 通道）；CQL 的 gap 一直 ≤ 0 并继续下降到 −1.3，评估稳定停在 0.85。BC 通过 mode-cloning 也能达到 0.85，但其 Q-net 没有显式 *回报* 概念，只是把行为策略的众数复制了一遍——若把 ε 调到 0.7 或换更高 slip 的环境就会暴露 BC 无法 *推理* 的本性（stretch goal #3）。 + +```mermaid +flowchart LR + D[(offline dataset / 10k transitions / random + epsilon-greedy expert)] + D --> BC[BC / cross-entropy on actions] + D --> DQN[DQN / TD(0) with target net] + D --> CQL[CQL / TD + alpha * (logsumexp - E_D Q)] + BC --> Eval[greedy eval / 20 episodes] + DQN --> Eval + CQL --> Eval + CQL <-- alpha (Lagrangian, target gap=5) --> Dual[dual update] +``` + +更广义地说，CQL 与 [IQL](../../../docs/data/cards/extended/paper_iql.md) 形成 "惩罚 OOD vs 避开 OOD" 的对照，与 [Decision Transformer](../../../docs/data/cards/extended/paper_decision_transformer.md) 形成 "价值函数 vs 序列建模" 的对照。本 lab 是 [paradigm_offline_rl](../../../docs/data/cards/extended/paradigm_offline_rl.md) 的最小入口；下一站建议复现 IQL 跑同一份数据集做横向对比。 diff --git a/labs/rl_decision/lab_cql_offline_minigrid/requirements.txt b/labs/rl_decision/lab_cql_offline_minigrid/requirements.txt new file mode 100644 index 0000000..65d791f --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/requirements.txt @@ -0,0 +1,7 @@ +numpy==2.1.3 +matplotlib==3.10.9 +torch==2.12.0 +nbformat==5.10.4 +nbconvert==7.17.1 +ipykernel==6.30.1 +jupyter==1.1.1 diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/__init__.py b/labs/rl_decision/lab_cql_offline_minigrid/src/__init__.py new file mode 100644 index 0000000..ebf7137 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/__init__.py @@ -0,0 +1 @@ +"""Offline-RL reproduction lab: BC vs DQN vs CQL on an 8x8 gridworld.""" diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/dataset.py b/labs/rl_decision/lab_cql_offline_minigrid/src/dataset.py new file mode 100644 index 0000000..a3b0698 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/dataset.py @@ -0,0 +1,219 @@ +"""Collect and save the offline dataset. + +Composition (mirrors common offline-RL benchmark splits): + * 50% random policy — uniform over the 4 actions. + * 50% epsilon-greedy expert with epsilon=0.3. + +Approximate total transitions: ``DEFAULT_TRANSITIONS = 10_000``. Episodes are +short (max 50 steps), so this is roughly 200-300 episodes per source. + +The saved file is a torch checkpoint with the per-transition tensors and the +empirical action histogram conditioned on each state — the latter is what the +CQL regulariser needs (E[Q(s, a)] under the data distribution) and what the +OOD-action density plot consumes. + +Run standalone:: + + python -m src.dataset +""" + +from __future__ import annotations + +import argparse +import os +from dataclasses import dataclass, field, asdict +from pathlib import Path + +import numpy as np +import torch + +from .env import GRID_SIZE, N_ACTIONS, GridWorld, expert_action, make_env +from .seeds import seed_everything + + +# --------------------------------------------------------------------------- +# Config +# --------------------------------------------------------------------------- +DEFAULT_TRANSITIONS = 10_000 +EXPERT_EPS = 0.3 + + +@dataclass +class DatasetConfig: + n_transitions: int = DEFAULT_TRANSITIONS + expert_eps: float = EXPERT_EPS + random_fraction: float = 0.5 + max_episode_steps: int = 50 + seed: int = 0 + + +# --------------------------------------------------------------------------- +# Rollout helpers +# --------------------------------------------------------------------------- +def _rollout( + env: GridWorld, + policy: str, + expert_eps: float, + rng: np.random.Generator, + max_steps: int, +) -> list[tuple[np.ndarray, int, float, np.ndarray, bool]]: + """Run a single episode under either the random or expert epsilon-greedy policy. + + Returns a list of (s, a, r, s', done) tuples. + """ + transitions: list[tuple[np.ndarray, int, float, np.ndarray, bool]] = [] + obs = env.reset() + for _ in range(max_steps): + pos = np.argmax(obs) + row, col = int(pos // env.size), int(pos % env.size) + if policy == "random": + action = int(rng.integers(0, N_ACTIONS)) + elif policy == "expert": + if rng.random() < expert_eps: + action = int(rng.integers(0, N_ACTIONS)) + else: + action = int(expert_action(row, col, env.size)) + else: + raise ValueError(policy) + next_obs, reward, done, _ = env.step(action) + transitions.append((obs.copy(), action, reward, next_obs.copy(), done)) + obs = next_obs + if done: + break + return transitions + + +@dataclass +class OfflineDataset: + obs: torch.Tensor # (N, obs_dim) float32 + actions: torch.Tensor # (N,) int64 + rewards: torch.Tensor # (N,) float32 + next_obs: torch.Tensor # (N, obs_dim) float32 + dones: torch.Tensor # (N,) float32 + source: torch.Tensor # (N,) int64 — 0=random, 1=expert (for analysis) + config: dict = field(default_factory=dict) + + def __len__(self) -> int: + return int(self.obs.shape[0]) + + def save(self, path: str) -> None: + Path(os.path.dirname(path)).mkdir(parents=True, exist_ok=True) + torch.save( + { + "obs": self.obs, + "actions": self.actions, + "rewards": self.rewards, + "next_obs": self.next_obs, + "dones": self.dones, + "source": self.source, + "config": self.config, + }, + path, + ) + + @classmethod + def load(cls, path: str) -> "OfflineDataset": + ckpt = torch.load(path, map_location="cpu", weights_only=False) + return cls( + obs=ckpt["obs"], + actions=ckpt["actions"], + rewards=ckpt["rewards"], + next_obs=ckpt["next_obs"], + dones=ckpt["dones"], + source=ckpt["source"], + config=ckpt.get("config", {}), + ) + + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- +def collect_offline_dataset(cfg: DatasetConfig | None = None) -> OfflineDataset: + cfg = cfg or DatasetConfig() + seed_everything(cfg.seed) + rng = np.random.default_rng(cfg.seed) + + obs_buf: list[np.ndarray] = [] + next_obs_buf: list[np.ndarray] = [] + action_buf: list[int] = [] + reward_buf: list[float] = [] + done_buf: list[float] = [] + source_buf: list[int] = [] + + n_random_target = int(cfg.n_transitions * cfg.random_fraction) + n_expert_target = cfg.n_transitions - n_random_target + + env = make_env(seed=cfg.seed) + # First fill the random half, then the expert half. + for target_count, policy_name, source_id in [ + (n_random_target, "random", 0), + (n_expert_target, "expert", 1), + ]: + collected = 0 + while collected < target_count: + trans = _rollout(env, policy_name, cfg.expert_eps, rng, cfg.max_episode_steps) + for s, a, r, sp, d in trans: + if collected >= target_count: + break + obs_buf.append(s) + action_buf.append(a) + reward_buf.append(r) + next_obs_buf.append(sp) + done_buf.append(float(d)) + source_buf.append(source_id) + collected += 1 + + ds = OfflineDataset( + obs=torch.from_numpy(np.stack(obs_buf, axis=0).astype(np.float32)), + actions=torch.tensor(action_buf, dtype=torch.long), + rewards=torch.tensor(reward_buf, dtype=torch.float32), + next_obs=torch.from_numpy(np.stack(next_obs_buf, axis=0).astype(np.float32)), + dones=torch.tensor(done_buf, dtype=torch.float32), + source=torch.tensor(source_buf, dtype=torch.long), + config=asdict(cfg), + ) + return ds + + +# --------------------------------------------------------------------------- +# Analysis helpers (used by the notebook and the plotting cell) +# --------------------------------------------------------------------------- +def state_action_support(ds: OfflineDataset, n_states: int, n_actions: int = N_ACTIONS) -> np.ndarray: + """Return an (n_states, n_actions) binary mask of which (s,a) appear in the dataset. + + 1.0 = at least one transition with that (s, a). 0.0 = OOD for the dataset. + """ + state_idx = ds.obs.argmax(dim=1).cpu().numpy() # one-hot -> state id + actions = ds.actions.cpu().numpy() + mask = np.zeros((n_states, n_actions), dtype=np.float32) + mask[state_idx, actions] = 1.0 + return mask + + +def action_histogram(ds: OfflineDataset, by_source: bool = True) -> dict[str, np.ndarray]: + """Build per-source action counts (random vs expert) for cell-1 visualisation.""" + actions = ds.actions.cpu().numpy() + source = ds.source.cpu().numpy() + out: dict[str, np.ndarray] = {} + if by_source: + for label, sid in [("random", 0), ("expert", 1)]: + mask = source == sid + out[label] = np.bincount(actions[mask], minlength=N_ACTIONS) + out["all"] = np.bincount(actions, minlength=N_ACTIONS) + return out + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--n", type=int, default=DEFAULT_TRANSITIONS) + parser.add_argument("--out", type=str, default="data/offline_dataset.pt") + parser.add_argument("--seed", type=int, default=0) + args = parser.parse_args() + + cfg = DatasetConfig(n_transitions=args.n, seed=args.seed) + ds = collect_offline_dataset(cfg) + ds.save(args.out) + hist = action_histogram(ds) + print(f"[dataset] saved {len(ds)} transitions -> {args.out}") + print(f"[dataset] action histogram (random) = {hist['random'].tolist()}") + print(f"[dataset] action histogram (expert) = {hist['expert'].tolist()}") diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/env.py b/labs/rl_decision/lab_cql_offline_minigrid/src/env.py new file mode 100644 index 0000000..b860ab3 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/env.py @@ -0,0 +1,144 @@ +"""Tiny 8x8 discrete gridworld with sparse terminal reward. + +Design choices (kept minimal so the textbook story is clear): + * Grid is 8x8 = 64 discrete states (one-hot encoded for the Q-net). + * Actions: 0=up, 1=right, 2=down, 3=left. Bumping into a wall is a no-op. + * Reward: small step penalty (-0.01) every step; +1 on reaching the goal; + episode terminates on goal or at ``max_steps`` (default 50). + * Start = (0, 0) top-left; goal = (7, 7) bottom-right. Manhattan distance 14 + -> optimal greedy return roughly 1 - 14 * 0.01 = 0.86, so Q-values for the + optimal policy stay in a small bounded range. Any TD-bootstrap divergence + above ~10 is therefore obviously broken, which is exactly the visual story + we want from the DQN cell. + +The env is implemented from scratch (no Gymnasium dependency) to keep the lab +self-contained and trivially CPU-friendly. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + + +GRID_SIZE = 8 +N_ACTIONS = 4 +ACTION_DELTAS = np.array( + [ + [-1, 0], # 0: up + [0, 1], # 1: right + [1, 0], # 2: down + [0, -1], # 3: left + ], + dtype=np.int64, +) + + +@dataclass +class EnvSpec: + obs_dim: int + n_actions: int + grid_size: int + + +class GridWorld: + """An 8x8 deterministic gridworld with a sparse +1 terminal reward. + + Observation is a flat one-hot of length GRID_SIZE * GRID_SIZE so the Q-net + can be a plain MLP. (Choosing one-hot over (row, col) integers also avoids + any spurious spatial smoothness — we want Q to be learned per-cell.) + """ + + def __init__( + self, + size: int = GRID_SIZE, + max_steps: int = 50, + step_penalty: float = -0.01, + goal_reward: float = 1.0, + slip_prob: float = 0.1, + seed: int | None = None, + ) -> None: + self.size = size + self.max_steps = max_steps + self.step_penalty = step_penalty + self.goal_reward = goal_reward + # With probability ``slip_prob`` the executed action is replaced by a + # uniform random one. Small but non-zero stochasticity is enough to + # force the trained policy off the canonical expert trajectory at + # evaluation, exposing BC's lack of recovery behaviour. + self.slip_prob = slip_prob + self.start = (0, 0) + self.goal = (size - 1, size - 1) + self._rng = np.random.default_rng(seed) + self._pos = np.array(self.start, dtype=np.int64) + self._t = 0 + + # ---- API --------------------------------------------------------------- + def reset(self, seed: int | None = None) -> np.ndarray: + if seed is not None: + self._rng = np.random.default_rng(seed) + self._pos = np.array(self.start, dtype=np.int64) + self._t = 0 + return self._obs() + + def step(self, action: int) -> tuple[np.ndarray, float, bool, dict]: + assert 0 <= int(action) < N_ACTIONS, f"action {action} out of range" + # Slip: with probability ``slip_prob`` substitute a uniform random action. + if self.slip_prob > 0.0 and self._rng.random() < self.slip_prob: + executed = int(self._rng.integers(0, N_ACTIONS)) + else: + executed = int(action) + dr, dc = ACTION_DELTAS[executed] + nr = int(np.clip(self._pos[0] + dr, 0, self.size - 1)) + nc = int(np.clip(self._pos[1] + dc, 0, self.size - 1)) + self._pos = np.array([nr, nc], dtype=np.int64) + self._t += 1 + + at_goal = (nr, nc) == self.goal + reward = self.goal_reward if at_goal else self.step_penalty + done = at_goal or (self._t >= self.max_steps) + info: dict = {"at_goal": at_goal, "t": self._t} + return self._obs(), float(reward), bool(done), info + + # ---- helpers ----------------------------------------------------------- + @property + def n_states(self) -> int: + return self.size * self.size + + def state_index(self) -> int: + return int(self._pos[0] * self.size + self._pos[1]) + + def _obs(self) -> np.ndarray: + vec = np.zeros(self.n_states, dtype=np.float32) + vec[self.state_index()] = 1.0 + return vec + + def spec(self) -> EnvSpec: + return EnvSpec(obs_dim=self.n_states, n_actions=N_ACTIONS, grid_size=self.size) + + +def make_env(seed: int | None = None) -> GridWorld: + """Factory mirroring the other labs' env.py signature.""" + return GridWorld(seed=seed) + + +# --------------------------------------------------------------------------- +# A tabular expert that gives a near-optimal policy on this gridworld. We use +# it during dataset collection (with epsilon-greedy noise) so the offline data +# is realistic mixed-quality. +# --------------------------------------------------------------------------- +def expert_action(row: int, col: int, size: int = GRID_SIZE) -> int: + """Greedy action toward the bottom-right goal. + + Ties broken arbitrarily but deterministically (prefer 'right' over 'down') + so the expert produces a single canonical trajectory in the absence of + noise. The mix of right-vs-down across noisy rollouts gives the offline + dataset enough coverage to make BC non-trivial. + """ + goal = size - 1 + if col < goal: + return 1 # right + if row < goal: + return 2 # down + return 1 # already at goal; arbitrary diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/model.py b/labs/rl_decision/lab_cql_offline_minigrid/src/model.py new file mode 100644 index 0000000..aa11efd --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/model.py @@ -0,0 +1,28 @@ +"""Shared Q-network MLP used by BC / DQN / CQL trainers. + +The same architecture is intentionally reused so that any difference in +calibration or evaluation return between the three trainers is attributable +to the loss function, not the model capacity. +""" + +from __future__ import annotations + +import torch +import torch.nn as nn + + +class QNet(nn.Module): + """Plain MLP from one-hot state to per-action values.""" + + def __init__(self, obs_dim: int, n_actions: int, hidden: int = 128): + super().__init__() + self.net = nn.Sequential( + nn.Linear(obs_dim, hidden), + nn.ReLU(), + nn.Linear(hidden, hidden), + nn.ReLU(), + nn.Linear(hidden, n_actions), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.net(x) diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/seeds.py b/labs/rl_decision/lab_cql_offline_minigrid/src/seeds.py new file mode 100644 index 0000000..b90e0f8 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/seeds.py @@ -0,0 +1,22 @@ +"""Deterministic seeding helpers (shared across BC/DQN/CQL trainers).""" + +from __future__ import annotations + +import os +import random + +import numpy as np +import torch + + +def seed_everything(seed: int = 0) -> None: + """Seed Python, NumPy, and PyTorch RNGs for reproducible runs. + + Single-threaded CPU keeps wall-clock predictable. + """ + os.environ["PYTHONHASHSEED"] = str(seed) + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.use_deterministic_algorithms(False) + torch.set_num_threads(1) diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_bc.py b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_bc.py new file mode 100644 index 0000000..bef7e6f --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_bc.py @@ -0,0 +1,176 @@ +"""Behaviour cloning baseline. + +By default BC trains cross-entropy on the *full* mixed offline dataset (50% +random + 50% epsilon-greedy expert) — the standard offline-RL setting: BC +clones the behaviour policy, full stop. Because the behaviour policy is a +mixture, BC's learned policy is also a mixture, and its evaluation return +saturates well below optimal — which is the point. Set +``BCConfig.expert_only=True`` for the optimistic "BC on expert slice only" +variant, available as a stretch ablation. + +The Q-net here outputs action logits directly (same architecture as the DQN +and CQL critics so any return gap is loss-driven, not capacity-driven). + +Run standalone:: + + python -m src.trainer_bc +""" + +from __future__ import annotations + +import argparse +import os +import time +from dataclasses import dataclass, field, asdict +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .dataset import OfflineDataset +from .env import N_ACTIONS, make_env +from .model import QNet +from .seeds import seed_everything + + +# --------------------------------------------------------------------------- +# Config +# --------------------------------------------------------------------------- +@dataclass +class BCConfig: + grad_steps: int = 5_000 + batch_size: int = 256 + lr: float = 3e-4 + hidden: int = 128 + eval_every: int = 100 + eval_episodes: int = 20 + max_eval_steps: int = 50 + seed: int = 0 + expert_only: bool = False # train on the full mixed dataset (default offline-RL setting) + + +@dataclass +class BCResult: + losses: list[float] = field(default_factory=list) + eval_returns: list[tuple[int, float]] = field(default_factory=list) + elapsed_s: float = 0.0 + config: dict = field(default_factory=dict) + + +# --------------------------------------------------------------------------- +# Evaluation +# --------------------------------------------------------------------------- +@torch.no_grad() +def evaluate_greedy(model: QNet, n_episodes: int, max_steps: int, seed: int = 4242) -> float: + """Run greedy episodes and return mean return. + + BC's QNet outputs action logits; argmax = greedy action. We share this + helper across trainers so all three are evaluated identically. + """ + env = make_env(seed=seed) + total = 0.0 + for ep in range(n_episodes): + obs = env.reset(seed=seed + ep) + ep_ret = 0.0 + for _ in range(max_steps): + x = torch.from_numpy(obs).unsqueeze(0) + a = int(model(x).argmax(dim=1).item()) + obs, r, done, _ = env.step(a) + ep_ret += float(r) + if done: + break + total += ep_ret + return total / n_episodes + + +# --------------------------------------------------------------------------- +# Training loop +# --------------------------------------------------------------------------- +def train_bc( + dataset: OfflineDataset, + cfg: BCConfig | None = None, + verbose: bool = True, +) -> tuple[QNet, BCResult]: + cfg = cfg or BCConfig() + seed_everything(cfg.seed) + + obs_dim = int(dataset.obs.shape[1]) + model = QNet(obs_dim, N_ACTIONS, cfg.hidden) + opt = torch.optim.Adam(model.parameters(), lr=cfg.lr) + + # Pick the slice we train on. + if cfg.expert_only: + mask = (dataset.source == 1).numpy() + else: + mask = np.ones(len(dataset), dtype=bool) + idx_pool = np.flatnonzero(mask) + assert len(idx_pool) >= cfg.batch_size, "not enough samples for BC batch" + + rng = np.random.default_rng(cfg.seed) + result = BCResult(config=asdict(cfg)) + t0 = time.time() + + for step in range(1, cfg.grad_steps + 1): + batch_idx = rng.choice(idx_pool, size=cfg.batch_size, replace=True) + s = dataset.obs[batch_idx] + a = dataset.actions[batch_idx] + logits = model(s) + loss = F.cross_entropy(logits, a) + opt.zero_grad() + loss.backward() + opt.step() + result.losses.append(float(loss.item())) + + if step % cfg.eval_every == 0: + r_eval = evaluate_greedy(model, cfg.eval_episodes, cfg.max_eval_steps) + result.eval_returns.append((step, r_eval)) + if verbose: + print(f"[BC] step={step:>5d} loss={loss.item():.4f} eval={r_eval:6.3f}") + + result.elapsed_s = time.time() - t0 + return model, result + + +# --------------------------------------------------------------------------- +# Persistence +# --------------------------------------------------------------------------- +def save_checkpoint(model: QNet, result: BCResult, path: str) -> None: + Path(os.path.dirname(path)).mkdir(parents=True, exist_ok=True) + torch.save( + { + "model_state": model.state_dict(), + "losses": result.losses, + "eval_returns": result.eval_returns, + "elapsed_s": result.elapsed_s, + "config": result.config, + }, + path, + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="data/offline_dataset.pt") + parser.add_argument("--ckpt", type=str, default="data/bc.pt") + parser.add_argument("--steps", type=int, default=None) + args = parser.parse_args() + + if not os.path.exists(args.dataset): + # Lazily collect the dataset if missing — supports `python -m src.trainer_bc` + # from a fresh checkout. + from .dataset import DatasetConfig, collect_offline_dataset + print(f"[BC] dataset {args.dataset} missing; collecting...") + ds = collect_offline_dataset(DatasetConfig()) + ds.save(args.dataset) + else: + ds = OfflineDataset.load(args.dataset) + + cfg = BCConfig() + if args.steps is not None: + cfg.grad_steps = args.steps + model, result = train_bc(ds, cfg) + save_checkpoint(model, result, args.ckpt) + final = result.eval_returns[-1][1] if result.eval_returns else float("nan") + print(f"[BC] done in {result.elapsed_s:.1f}s · final-eval={final:.3f} · saved {args.ckpt}") diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_cql.py b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_cql.py new file mode 100644 index 0000000..48b8dd3 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_cql.py @@ -0,0 +1,268 @@ +"""Conservative Q-Learning (CQL) on the fixed offline dataset. + +We implement the discrete-action CQL(H) variant from Kumar et al. 2020: + + L_CQL = L_DQN + alpha * E_s [ log sum_a exp Q(s, a) - E_{a~D}[Q(s, a)] ] + +The bracketed term pushes the log-partition function down (all actions) and +pulls the data-action Q up — the net effect is a conservative lower bound on +the in-data Q values and a *very* strong push-down on out-of-distribution +actions, which is the whole point. + +Alpha is auto-tuned by Lagrangian dual gradient ascent with target gap 5.0 +(``target_gap``): the gap is the size of the CQL regulariser (averaged over +the batch). If it's above target, alpha rises; if below, alpha falls. This +matches the published CQL implementation and tends to outperform any +hand-picked fixed alpha. + +Run standalone:: + + python -m src.trainer_cql +""" + +from __future__ import annotations + +import argparse +import os +import time +from dataclasses import dataclass, field, asdict +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .dataset import OfflineDataset, state_action_support +from .env import N_ACTIONS, make_env +from .model import QNet +from .seeds import seed_everything + + +# --------------------------------------------------------------------------- +# Config +# --------------------------------------------------------------------------- +@dataclass +class CQLConfig: + grad_steps: int = 5_000 + batch_size: int = 256 + gamma: float = 0.99 + lr: float = 3e-4 + hidden: int = 128 + target_update: int = 200 + grad_clip: float = 10.0 + + # CQL-specific + alpha_init: float = 1.0 + alpha_lr: float = 1e-4 # dual learning rate for the Lagrangian + target_gap: float = 5.0 # target value of the CQL penalty term + alpha_mode: str = "auto" # one of {"auto", "fixed", "zero"} + alpha_fixed: float = 5.0 # used when alpha_mode == "fixed" + alpha_min: float = 0.0 + alpha_max: float = 50.0 + + eval_every: int = 100 + eval_episodes: int = 20 + max_eval_steps: int = 50 + log_q_every: int = 25 + seed: int = 0 + + +@dataclass +class CQLResult: + losses: list[float] = field(default_factory=list) + cql_gaps: list[float] = field(default_factory=list) + alphas: list[float] = field(default_factory=list) + eval_returns: list[tuple[int, float]] = field(default_factory=list) + q_seen: list[tuple[int, float]] = field(default_factory=list) + q_unseen: list[tuple[int, float]] = field(default_factory=list) + q_max_per_state: list[tuple[int, float]] = field(default_factory=list) + elapsed_s: float = 0.0 + config: dict = field(default_factory=dict) + + +# --------------------------------------------------------------------------- +# Helpers shared with the DQN trainer (re-implemented to keep the file standalone) +# --------------------------------------------------------------------------- +@torch.no_grad() +def evaluate_greedy(model: QNet, n_episodes: int, max_steps: int, seed: int = 4242) -> float: + env = make_env(seed=seed) + total = 0.0 + for ep in range(n_episodes): + obs = env.reset(seed=seed + ep) + ep_ret = 0.0 + for _ in range(max_steps): + x = torch.from_numpy(obs).unsqueeze(0) + a = int(model(x).argmax(dim=1).item()) + obs, r, done, _ = env.step(a) + ep_ret += float(r) + if done: + break + total += ep_ret + return total / n_episodes + + +def _log_q_stats(q: QNet, state_table: torch.Tensor, support_mask: torch.Tensor) -> tuple[float, float, float]: + with torch.no_grad(): + q_all = q(state_table) + seen = q_all[support_mask > 0.5] + unseen = q_all[support_mask <= 0.5] + q_seen_mean = float(seen.mean().item()) if seen.numel() > 0 else float("nan") + q_unseen_mean = float(unseen.mean().item()) if unseen.numel() > 0 else float("nan") + q_max_mean = float(q_all.max(dim=1).values.mean().item()) + return q_seen_mean, q_unseen_mean, q_max_mean + + +# --------------------------------------------------------------------------- +# Training loop +# --------------------------------------------------------------------------- +def train_cql( + dataset: OfflineDataset, + cfg: CQLConfig | None = None, + verbose: bool = True, +) -> tuple[QNet, CQLResult]: + cfg = cfg or CQLConfig() + seed_everything(cfg.seed) + + obs_dim = int(dataset.obs.shape[1]) + n_states = obs_dim + q = QNet(obs_dim, N_ACTIONS, cfg.hidden) + q_target = QNet(obs_dim, N_ACTIONS, cfg.hidden) + q_target.load_state_dict(q.state_dict()) + opt = torch.optim.Adam(q.parameters(), lr=cfg.lr) + + # Alpha is parameterised through ``log_alpha`` so gradient updates keep it + # positive automatically. For ``alpha_mode != "auto"`` the optimizer is + # never stepped, so the value is effectively frozen. + log_alpha = torch.tensor(np.log(max(cfg.alpha_init, 1e-8)), requires_grad=True) + alpha_opt = torch.optim.Adam([log_alpha], lr=cfg.alpha_lr) + + support = state_action_support(dataset, n_states, N_ACTIONS) + support_t = torch.from_numpy(support) + state_table = torch.eye(n_states, dtype=torch.float32) + + rng = np.random.default_rng(cfg.seed) + n = len(dataset) + result = CQLResult(config=asdict(cfg)) + t0 = time.time() + + for step in range(1, cfg.grad_steps + 1): + idx = rng.integers(0, n, size=cfg.batch_size) + s = dataset.obs[idx] + a = dataset.actions[idx] + r = dataset.rewards[idx] + s2 = dataset.next_obs[idx] + d = dataset.dones[idx] + + # Standard DQN TD loss + with torch.no_grad(): + target_max = q_target(s2).max(dim=1).values + y = r + (1.0 - d) * cfg.gamma * target_max + q_all = q(s) # (B, n_actions) + q_sa = q_all.gather(1, a.unsqueeze(1)).squeeze(1) + td_loss = F.smooth_l1_loss(q_sa, y) + + # CQL conservative penalty: log sum exp Q(s, .) - E_{a~D}[Q(s, a)] + logsumexp_q = torch.logsumexp(q_all, dim=1) # (B,) + cql_term = (logsumexp_q - q_sa).mean() # scalar + + # Alpha (Lagrangian dual variable for "cql_term <= target_gap") + if cfg.alpha_mode == "auto": + alpha = log_alpha.exp().clamp(cfg.alpha_min, cfg.alpha_max) + elif cfg.alpha_mode == "fixed": + alpha = torch.tensor(cfg.alpha_fixed) + elif cfg.alpha_mode == "zero": + alpha = torch.tensor(0.0) + else: + raise ValueError(cfg.alpha_mode) + + total_loss = td_loss + alpha.detach() * cql_term + opt.zero_grad() + total_loss.backward() + nn.utils.clip_grad_norm_(q.parameters(), cfg.grad_clip) + opt.step() + + # Dual update: increase alpha if cql_term > target_gap + if cfg.alpha_mode == "auto": + # gradient ascent on alpha * (cql_term - target_gap) + alpha_loss = -(log_alpha.exp() * (cql_term.detach() - cfg.target_gap)) + alpha_opt.zero_grad() + alpha_loss.backward() + alpha_opt.step() + with torch.no_grad(): + log_alpha.clamp_(np.log(max(cfg.alpha_min, 1e-8) + 1e-12), np.log(cfg.alpha_max)) + + result.losses.append(float(total_loss.item())) + result.cql_gaps.append(float(cql_term.item())) + result.alphas.append(float(alpha.item())) + + if step % cfg.target_update == 0: + q_target.load_state_dict(q.state_dict()) + + if step % cfg.log_q_every == 0: + q_seen, q_unseen, q_max = _log_q_stats(q, state_table, support_t) + result.q_seen.append((step, q_seen)) + result.q_unseen.append((step, q_unseen)) + result.q_max_per_state.append((step, q_max)) + + if step % cfg.eval_every == 0: + r_eval = evaluate_greedy(q, cfg.eval_episodes, cfg.max_eval_steps) + result.eval_returns.append((step, r_eval)) + if verbose: + q_seen, q_unseen, _ = _log_q_stats(q, state_table, support_t) + print( + f"[CQL/{cfg.alpha_mode}] step={step:>5d} td={td_loss.item():.4f} " + f"gap={cql_term.item():.2f} alpha={alpha.item():.2f} " + f"Q_seen={q_seen:.2f} Q_OOD={q_unseen:.2f} eval={r_eval:6.3f}" + ) + + result.elapsed_s = time.time() - t0 + return q, result + + +# --------------------------------------------------------------------------- +# Persistence +# --------------------------------------------------------------------------- +def save_checkpoint(q: QNet, result: CQLResult, path: str) -> None: + Path(os.path.dirname(path)).mkdir(parents=True, exist_ok=True) + torch.save( + { + "model_state": q.state_dict(), + "losses": result.losses, + "cql_gaps": result.cql_gaps, + "alphas": result.alphas, + "eval_returns": result.eval_returns, + "q_seen": result.q_seen, + "q_unseen": result.q_unseen, + "q_max_per_state": result.q_max_per_state, + "elapsed_s": result.elapsed_s, + "config": result.config, + }, + path, + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="data/offline_dataset.pt") + parser.add_argument("--ckpt", type=str, default="data/cql.pt") + parser.add_argument("--alpha-mode", type=str, default="auto", choices=["auto", "fixed", "zero"]) + parser.add_argument("--alpha-fixed", type=float, default=5.0) + parser.add_argument("--steps", type=int, default=None) + args = parser.parse_args() + + if not os.path.exists(args.dataset): + from .dataset import DatasetConfig, collect_offline_dataset + print(f"[CQL] dataset {args.dataset} missing; collecting...") + ds = collect_offline_dataset(DatasetConfig()) + ds.save(args.dataset) + else: + ds = OfflineDataset.load(args.dataset) + + cfg = CQLConfig(alpha_mode=args.alpha_mode, alpha_fixed=args.alpha_fixed) + if args.steps is not None: + cfg.grad_steps = args.steps + q, result = train_cql(ds, cfg) + save_checkpoint(q, result, args.ckpt) + final = result.eval_returns[-1][1] if result.eval_returns else float("nan") + print(f"[CQL] done in {result.elapsed_s:.1f}s · final-eval={final:.3f} · saved {args.ckpt}") diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_dqn.py b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_dqn.py new file mode 100644 index 0000000..8e2e619 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/trainer_dqn.py @@ -0,0 +1,224 @@ +"""Vanilla DQN run on the fixed offline dataset (no environment interaction). + +This is the classic "naive offline RL" failure mode that motivates CQL: +because the Bellman backup bootstraps via ``max_a Q(s', a)``, any action the +behaviour policy never tried gets its Q value pushed up unchecked. With no +data to correct that signal, the Q-function diverges on out-of-distribution +actions and the greedy policy chases the inflated values. + +We log two Q-statistics every step so the notebook can render the +"DQN overestimates, CQL stays calibrated" panel: + * mean ``Q(s, a)`` on (state, action) pairs that *are* in the dataset. + * mean ``Q(s, a)`` on the *complementary* OOD set of (s, a) pairs. + +Run standalone:: + + python -m src.trainer_dqn +""" + +from __future__ import annotations + +import argparse +import os +import time +from dataclasses import dataclass, field, asdict +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .dataset import OfflineDataset, state_action_support +from .env import N_ACTIONS, make_env +from .model import QNet +from .seeds import seed_everything + + +# --------------------------------------------------------------------------- +# Config +# --------------------------------------------------------------------------- +@dataclass +class DQNConfig: + grad_steps: int = 5_000 + batch_size: int = 256 + gamma: float = 0.99 + lr: float = 3e-4 + hidden: int = 128 + target_update: int = 200 # hard copy theta_target <- theta every C steps + grad_clip: float = 10.0 + eval_every: int = 100 + eval_episodes: int = 20 + max_eval_steps: int = 50 + log_q_every: int = 25 # how often to record Q-stats for the divergence plot + seed: int = 0 + + +@dataclass +class DQNResult: + losses: list[float] = field(default_factory=list) + eval_returns: list[tuple[int, float]] = field(default_factory=list) + q_seen: list[tuple[int, float]] = field(default_factory=list) + q_unseen: list[tuple[int, float]] = field(default_factory=list) + q_max_per_state: list[tuple[int, float]] = field(default_factory=list) + elapsed_s: float = 0.0 + config: dict = field(default_factory=dict) + + +# --------------------------------------------------------------------------- +# Evaluation +# --------------------------------------------------------------------------- +@torch.no_grad() +def evaluate_greedy(model: QNet, n_episodes: int, max_steps: int, seed: int = 4242) -> float: + env = make_env(seed=seed) + total = 0.0 + for ep in range(n_episodes): + obs = env.reset(seed=seed + ep) + ep_ret = 0.0 + for _ in range(max_steps): + x = torch.from_numpy(obs).unsqueeze(0) + a = int(model(x).argmax(dim=1).item()) + obs, r, done, _ = env.step(a) + ep_ret += float(r) + if done: + break + total += ep_ret + return total / n_episodes + + +# --------------------------------------------------------------------------- +# Q-statistics helpers +# --------------------------------------------------------------------------- +def _state_table(n_states: int) -> torch.Tensor: + eye = torch.eye(n_states, dtype=torch.float32) + return eye + + +def _log_q_stats( + q: QNet, + state_table: torch.Tensor, + support_mask: torch.Tensor, +) -> tuple[float, float, float]: + """Mean Q over in-dataset (s,a), mean Q over OOD (s,a), max-Q averaged over states.""" + with torch.no_grad(): + q_all = q(state_table) # (n_states, n_actions) + seen = q_all[support_mask > 0.5] + unseen = q_all[support_mask <= 0.5] + q_seen_mean = float(seen.mean().item()) if seen.numel() > 0 else float("nan") + q_unseen_mean = float(unseen.mean().item()) if unseen.numel() > 0 else float("nan") + q_max_mean = float(q_all.max(dim=1).values.mean().item()) + return q_seen_mean, q_unseen_mean, q_max_mean + + +# --------------------------------------------------------------------------- +# Training loop +# --------------------------------------------------------------------------- +def train_dqn( + dataset: OfflineDataset, + cfg: DQNConfig | None = None, + verbose: bool = True, +) -> tuple[QNet, DQNResult]: + cfg = cfg or DQNConfig() + seed_everything(cfg.seed) + + obs_dim = int(dataset.obs.shape[1]) + n_states = obs_dim # one-hot encoding => obs_dim == n_states + q = QNet(obs_dim, N_ACTIONS, cfg.hidden) + q_target = QNet(obs_dim, N_ACTIONS, cfg.hidden) + q_target.load_state_dict(q.state_dict()) + opt = torch.optim.Adam(q.parameters(), lr=cfg.lr) + + support = state_action_support(dataset, n_states, N_ACTIONS) + support_t = torch.from_numpy(support) + state_table = _state_table(n_states) + + rng = np.random.default_rng(cfg.seed) + n = len(dataset) + result = DQNResult(config=asdict(cfg)) + t0 = time.time() + + for step in range(1, cfg.grad_steps + 1): + idx = rng.integers(0, n, size=cfg.batch_size) + s = dataset.obs[idx] + a = dataset.actions[idx] + r = dataset.rewards[idx] + s2 = dataset.next_obs[idx] + d = dataset.dones[idx] + + with torch.no_grad(): + target_max = q_target(s2).max(dim=1).values + y = r + (1.0 - d) * cfg.gamma * target_max + q_sa = q(s).gather(1, a.unsqueeze(1)).squeeze(1) + td_loss = F.smooth_l1_loss(q_sa, y) + + opt.zero_grad() + td_loss.backward() + nn.utils.clip_grad_norm_(q.parameters(), cfg.grad_clip) + opt.step() + result.losses.append(float(td_loss.item())) + + if step % cfg.target_update == 0: + q_target.load_state_dict(q.state_dict()) + + if step % cfg.log_q_every == 0: + q_seen, q_unseen, q_max = _log_q_stats(q, state_table, support_t) + result.q_seen.append((step, q_seen)) + result.q_unseen.append((step, q_unseen)) + result.q_max_per_state.append((step, q_max)) + + if step % cfg.eval_every == 0: + r_eval = evaluate_greedy(q, cfg.eval_episodes, cfg.max_eval_steps) + result.eval_returns.append((step, r_eval)) + if verbose: + q_seen, q_unseen, _ = _log_q_stats(q, state_table, support_t) + print( + f"[DQN] step={step:>5d} loss={td_loss.item():.4f} " + f"Q_seen={q_seen:.2f} Q_OOD={q_unseen:.2f} eval={r_eval:6.3f}" + ) + + result.elapsed_s = time.time() - t0 + return q, result + + +# --------------------------------------------------------------------------- +# Persistence +# --------------------------------------------------------------------------- +def save_checkpoint(q: QNet, result: DQNResult, path: str) -> None: + Path(os.path.dirname(path)).mkdir(parents=True, exist_ok=True) + torch.save( + { + "model_state": q.state_dict(), + "losses": result.losses, + "eval_returns": result.eval_returns, + "q_seen": result.q_seen, + "q_unseen": result.q_unseen, + "q_max_per_state": result.q_max_per_state, + "elapsed_s": result.elapsed_s, + "config": result.config, + }, + path, + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="data/offline_dataset.pt") + parser.add_argument("--ckpt", type=str, default="data/dqn.pt") + parser.add_argument("--steps", type=int, default=None) + args = parser.parse_args() + + if not os.path.exists(args.dataset): + from .dataset import DatasetConfig, collect_offline_dataset + print(f"[DQN] dataset {args.dataset} missing; collecting...") + ds = collect_offline_dataset(DatasetConfig()) + ds.save(args.dataset) + else: + ds = OfflineDataset.load(args.dataset) + + cfg = DQNConfig() + if args.steps is not None: + cfg.grad_steps = args.steps + q, result = train_dqn(ds, cfg) + save_checkpoint(q, result, args.ckpt) + final = result.eval_returns[-1][1] if result.eval_returns else float("nan") + print(f"[DQN] done in {result.elapsed_s:.1f}s · final-eval={final:.3f} · saved {args.ckpt}") diff --git a/labs/rl_decision/lab_cql_offline_minigrid/src/viz.py b/labs/rl_decision/lab_cql_offline_minigrid/src/viz.py new file mode 100644 index 0000000..e5a67d3 --- /dev/null +++ b/labs/rl_decision/lab_cql_offline_minigrid/src/viz.py @@ -0,0 +1,277 @@ +"""Plotting helpers — three canonical figures plus utility curves. + +Every plot uses pure matplotlib (no seaborn) so figures reproduce identically +across machines without extra dependencies. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import Iterable, Mapping, Sequence + +import matplotlib.pyplot as plt +import numpy as np +import torch + +from .dataset import OfflineDataset, state_action_support +from .env import N_ACTIONS, make_env +from .model import QNet + + +_ACTION_LABELS = ["up", "right", "down", "left"] + + +# --------------------------------------------------------------------------- +# Curves +# --------------------------------------------------------------------------- +def _smooth(x: np.ndarray, window: int = 25) -> np.ndarray: + if len(x) < window: + return x + kernel = np.ones(window) / window + return np.convolve(x, kernel, mode="valid") + + +def plot_action_histogram( + counts: Mapping[str, np.ndarray], + out_path: str, + title: str = "Offline dataset action histogram", +) -> None: + """Side-by-side bars: action distribution for random vs expert halves.""" + sources = [k for k in counts.keys() if k != "all"] + x = np.arange(N_ACTIONS) + width = 0.8 / max(1, len(sources)) + fig, ax = plt.subplots(figsize=(6.4, 3.6)) + colors = {"random": "#888888", "expert": "#1f77b4"} + for i, src in enumerate(sources): + offset = (i - (len(sources) - 1) / 2) * width + ax.bar(x + offset, counts[src], width=width, label=src, color=colors.get(src, None)) + ax.set_xticks(x) + ax.set_xticklabels(_ACTION_LABELS) + ax.set_ylabel("transitions") + ax.set_xlabel("action") + ax.set_title(title) + ax.legend() + ax.grid(axis="y", alpha=0.3) + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + fig.tight_layout() + fig.savefig(out_path, bbox_inches="tight", dpi=120) + plt.close(fig) + + +# --------------------------------------------------------------------------- +# Q-overestimation panel +# --------------------------------------------------------------------------- +def plot_q_overestimation( + runs: Mapping[str, dict], + out_path: str, + title: str = "Q-overestimation: in-data actions vs OOD actions", +) -> None: + """Three-panel figure that visualises the central CQL claim. + + ``runs`` maps a label (e.g. "DQN", "CQL") to a dict with keys ``q_seen`` + and ``q_unseen``, each a list of (step, mean_Q). + + * Left — mean Q on (s, a) that appear in the dataset. + * Mid — mean Q on (s, a) that are out-of-distribution. + * Right — the overestimation gap (Q_OOD - Q_seen): positive means the + model has learned to value unseen actions higher than seen + ones (the canonical offline-RL failure mode). DQN's gap goes + positive; CQL's stays at or below zero — the textbook claim. + """ + fig, axes = plt.subplots(1, 3, figsize=(13.5, 4), sharex=True) + palette = {"DQN": "#d62728", "CQL": "#2ca02c", "BC": "#9467bd"} + for label, run in runs.items(): + c = palette.get(label, None) + seen = np.asarray(run["q_seen"]) # (T, 2) + unseen = np.asarray(run["q_unseen"]) + if seen.size == 0: + continue + axes[0].plot(seen[:, 0], seen[:, 1], label=label, color=c, linewidth=2.0) + axes[1].plot(unseen[:, 0], unseen[:, 1], label=label, color=c, linewidth=2.0) + gap = unseen[:, 1] - seen[:, 1] + axes[2].plot(seen[:, 0], gap, label=label, color=c, linewidth=2.0) + + axes[0].set_title("Mean Q on (s,a) IN dataset") + axes[1].set_title("Mean Q on (s,a) OUT of dataset") + axes[2].set_title("Overestimation gap: Q_OOD − Q_seen") + for ax in axes[:2]: + ax.axhline(0.86, ls=":", color="grey", alpha=0.7, label="opt. return ≈ 0.86") + axes[2].axhline(0.0, ls=":", color="grey", alpha=0.7, label="conservative (≤ 0)") + for ax in axes: + ax.set_xlabel("gradient step") + ax.grid(alpha=0.3) + ax.legend(loc="best", fontsize=8) + axes[0].set_ylabel("mean Q(s, a)") + fig.suptitle(title) + fig.tight_layout() + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_path, bbox_inches="tight", dpi=120) + plt.close(fig) + + +# --------------------------------------------------------------------------- +# OOD action density +# --------------------------------------------------------------------------- +@torch.no_grad() +def _greedy_action_histogram(model: QNet, n_states: int) -> np.ndarray: + """Argmax-action histogram across all 64 states.""" + state_table = torch.eye(n_states, dtype=torch.float32) + q = model(state_table) + actions = q.argmax(dim=1).cpu().numpy() + return np.bincount(actions, minlength=N_ACTIONS) + + +def _per_state_action_counts(dataset: OfflineDataset, n_states: int) -> np.ndarray: + """(n_states, n_actions) array of observed counts in the offline dataset.""" + state_idx = dataset.obs.argmax(dim=1).cpu().numpy() + actions = dataset.actions.cpu().numpy() + counts = np.zeros((n_states, N_ACTIONS), dtype=np.float64) + np.add.at(counts, (state_idx, actions), 1.0) + return counts + + +def plot_ood_action_density( + dataset: OfflineDataset, + models: Mapping[str, QNet], + out_path: str, + title: str = "Action choice vs behaviour-policy density", + low_density_threshold: float = 0.05, +) -> None: + """Two-panel figure. + + * Left — marginal action histogram (dataset vs each model's greedy pick). + * Right — average behaviour-policy probability of each model's greedy + action, conditioned on the state. For each state we form the + behaviour-policy marginal pi_beta(a | s) from the offline data + counts; then we look up pi_beta(a* | s) for the model's greedy + a*. A score near 0 means the model picks actions the data + strongly avoids (the OOD failure); a score near 1 means the + model stays inside the support. + """ + dataset_hist = np.bincount(dataset.actions.cpu().numpy(), minlength=N_ACTIONS).astype(np.float64) + dataset_hist /= dataset_hist.sum() + + n_states = int(dataset.obs.shape[1]) + counts = _per_state_action_counts(dataset, n_states) + visited = counts.sum(axis=1) > 0 + # Lapace smoothing so OOD = small but non-zero + smoothed = counts + 1e-3 + pi_beta = smoothed / smoothed.sum(axis=1, keepdims=True) + + model_hists: dict[str, np.ndarray] = {} + mean_density: dict[str, float] = {} + low_density_share: dict[str, float] = {} + for name, m in models.items(): + h = _greedy_action_histogram(m, n_states).astype(np.float64) + model_hists[name] = h / h.sum() if h.sum() > 0 else h + with torch.no_grad(): + state_table = torch.eye(n_states, dtype=torch.float32) + greedy = m(state_table).argmax(dim=1).cpu().numpy() + # Use only visited states for a fair comparison + probs = pi_beta[np.arange(n_states), greedy][visited] + mean_density[name] = float(probs.mean()) + low_density_share[name] = float((probs < low_density_threshold).mean()) + + fig, axes = plt.subplots(1, 2, figsize=(11.5, 4)) + + x = np.arange(N_ACTIONS) + width = 0.8 / (1 + len(model_hists)) + palette = {"DQN": "#d62728", "CQL": "#2ca02c", "BC": "#9467bd"} + series = [("dataset", dataset_hist, "#444444")] + [ + (name, model_hists[name], palette.get(name)) for name in model_hists + ] + for i, (label, vals, c) in enumerate(series): + offset = (i - (len(series) - 1) / 2) * width + axes[0].bar(x + offset, vals, width=width, label=label, color=c) + axes[0].set_xticks(x) + axes[0].set_xticklabels(_ACTION_LABELS) + axes[0].set_ylabel("share of greedy picks") + axes[0].set_xlabel("action") + axes[0].set_title("Marginal action histogram") + axes[0].legend() + axes[0].grid(axis="y", alpha=0.3) + + names = list(mean_density.keys()) + bars = axes[1].bar(names, [mean_density[n] for n in names], + color=[palette.get(n, "#888888") for n in names]) + axes[1].set_ylabel(r"mean $\pi_\beta(a^\star \,|\, s)$ across visited states") + axes[1].set_title("How likely is each model's greedy action under the behaviour policy?") + axes[1].set_ylim(0, 1.0) + for b, n in zip(bars, names): + axes[1].text(b.get_x() + b.get_width() / 2, b.get_height() + 0.02, + f"{mean_density[n]:.2f}\n({100*low_density_share[n]:.0f}%<{low_density_threshold})", + ha="center", va="bottom", fontsize=9) + axes[1].grid(axis="y", alpha=0.3) + + fig.suptitle(title) + fig.tight_layout() + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_path, bbox_inches="tight", dpi=120) + plt.close(fig) + + +# --------------------------------------------------------------------------- +# Evaluation returns +# --------------------------------------------------------------------------- +def plot_eval_returns( + runs: Mapping[str, Sequence[tuple[int, float]]], + out_path: str, + title: str = "Greedy evaluation return over training", +) -> None: + fig, ax = plt.subplots(figsize=(7.2, 4)) + palette = {"DQN": "#d62728", "CQL": "#2ca02c", "BC": "#9467bd", + "CQL-auto": "#2ca02c", "CQL-fixed-5": "#ff7f0e", "alpha=0 (DQN)": "#d62728"} + for label, curve in runs.items(): + arr = np.asarray(list(curve)) # (T, 2) + if arr.size == 0: + continue + ax.plot(arr[:, 0], arr[:, 1], marker="o", linewidth=2.0, + color=palette.get(label, None), label=label) + ax.axhline(0.86, ls="--", color="grey", alpha=0.6, label="optimal ≈ 0.86") + ax.set_xlabel("gradient step") + ax.set_ylabel("mean return (20 episodes)") + ax.set_title(title) + ax.grid(alpha=0.3) + ax.legend(loc="best") + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + fig.tight_layout() + fig.savefig(out_path, bbox_inches="tight", dpi=120) + plt.close(fig) + + +# --------------------------------------------------------------------------- +# CQL diagnostics (alpha and gap over training) — for the ablation cell +# --------------------------------------------------------------------------- +def plot_alpha_gap_trajectories( + runs: Mapping[str, dict], + out_path: str, + title: str = "CQL diagnostics · alpha and gap trajectories", +) -> None: + """Two-panel figure: per-step alpha and per-step CQL gap for each run. + + ``runs`` maps label -> {"alphas": list[float], "cql_gaps": list[float]}. + """ + fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharex=True) + palette = {"CQL-auto": "#2ca02c", "CQL-fixed-5": "#ff7f0e", "alpha=0 (DQN)": "#d62728"} + for label, run in runs.items(): + a = np.asarray(run["alphas"], dtype=np.float64) + g = np.asarray(run["cql_gaps"], dtype=np.float64) + steps = np.arange(1, len(a) + 1) + c = palette.get(label) + axes[0].plot(steps, a, label=label, color=c, linewidth=2.0) + axes[1].plot(steps[: len(_smooth(g, 50))], _smooth(g, 50), label=label, color=c, linewidth=2.0) + axes[0].set_ylabel(r"$\alpha$") + axes[0].set_title(r"Lagrangian multiplier $\alpha$ over training") + axes[0].axhline(5.0, ls=":", color="#ff7f0e", alpha=0.5, label="fixed=5") + axes[1].set_ylabel(r"CQL gap = $\log\sum_a\exp Q - \mathbb{E}_{a\sim D}[Q]$") + axes[1].axhline(5.0, ls=":", color="grey", alpha=0.5, label="target=5") + axes[1].set_title("CQL gap (smoothed, window=50)") + for ax in axes: + ax.set_xlabel("gradient step") + ax.grid(alpha=0.3) + ax.legend(loc="best", fontsize=8) + fig.suptitle(title) + fig.tight_layout() + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_path, bbox_inches="tight", dpi=120) + plt.close(fig) diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/README.md b/labs/world_models/lab_dreamer_cartpole_pixels/README.md new file mode 100644 index 0000000..14285fd --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/README.md @@ -0,0 +1,62 @@ +# lab · Dreamer-style 世界模型 on CartPole 像素 + +一个最小但忠实的 Dreamer 风格复现：智能体只能看到 64×64 RGB 像素， +先学一个 RSSM 世界模型，再在世界模型的 latent imagination 里训练 +actor-critic。总训练时间 ≤ 8 分钟（CPU 笔记本，单线程）。 + +## 快速开始 + +```bash +cd labs/world_models/lab_dreamer_cartpole_pixels +pip install -r requirements.txt + +# 仅训练世界模型（在随机轨迹上演示重建） +python -m src.world_model # → data/world_model.pt + +# 完整 Dreamer 循环（WM + actor-critic in imagination） +python -m src.policy # → data/dreamer.pt + +# 或运行完整 narrative +jupyter nbconvert --execute --to notebook --inplace notebook.ipynb +``` + +执行 notebook 后会在 `assets/` 下生成三张图： + +- `reconstruction_grid.png` — 4 条 10 帧 strip，real 在上、reconstructed 在下； +- `latent_vs_real_rollout.png` — 同一动作序列下 15 步 latent rollout vs. 真实环境 rollout，下面附 per-step pixel MSE； +- `return_vs_steps.png` — 策略评估回报随真实环境步数的曲线。 + +## 这个 lab 证明了什么 + +- **WM 学会了视觉动力学**：reconstruction strip 显示重建图像跟随真实 cart/pole 的位置与角度； +- **策略完全在 imagination 中改进**：actor-critic 从未直接看到像素，只看 (h_t, z_t)； +- **重建质量决定上限**：长 horizon rollout 的 pixel MSE 单调增长，这条曲线就是世界模型的"梦境寿命"，policy 在 imagination 里能挖到的回报受它约束。 + +## 文件契约 + +``` +. +├── README.md +├── notebook.ipynb ← 12-cell narrative +├── paper.md ← 250 字蒸馏（链 paper_world_models / paper_dreamer_v2 / paper_dreamer_v3） +├── requirements.txt +├── src/ +│ ├── __init__.py +│ ├── env.py ← CartPole-v1 + 64×64 RGB renderer (numpy, 不依赖 pygame) +│ ├── world_model.py ← Encoder + RSSM (h_t deterministic + z_t Gaussian) + Decoder + reward/continue heads +│ ├── trainer.py ← 给 notebook 用的薄 facade +│ ├── policy.py ← Actor-Critic in latent imagination + λ-return + continue 折扣 +│ ├── viz.py ← reconstruction strips / latent vs. real / 回报曲线 +│ └── seeds.py +├── assets/ ← notebook 产出的 PNG +└── data/ ← checkpoint +``` + +## 三条 stretch goals + +1. **离散 RSSM**：把 `world_model.RSSM` 的 stochastic state 换成 32-categorical + + straight-through 估计（Dreamer V2 主 trick），通常能让 KL 项更稳定。 +2. **Domain randomisation**：在 `env.py` 的 renderer 里随机化背景/杆颜色/cart 大小， + 测试 WM 在视觉扰动下能否仍然 generalise。 +3. **环境升级**：把 `make_pixel_cartpole` 换成 MountainCar 或 Acrobot 的像素版， + 检查 reward 稀疏性如何放大 WM 误差对策略学习的影响。 diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/notebook.ipynb b/labs/world_models/lab_dreamer_cartpole_pixels/notebook.ipynb new file mode 100644 index 0000000..e8f8d5f --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/notebook.ipynb @@ -0,0 +1,186 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro-md", + "metadata": {}, + "source": [ + "# lab · Dreamer 风格世界模型 on CartPole 像素\n", + "\n", + "三张 Atlas 卡片汇聚于此：[World Models](../../docs/data/cards/paper_world_models.md) (Ha & Schmidhuber 2018) 提出\"在脑里学开车\"的思路；[DreamerV2](../../docs/data/cards/extended/paper_dreamer_v2.md) 把 latent 换成 RSSM 并加上 KL balancing；[DreamerV3](../../docs/data/cards/extended/paper_dreamer_v3.md) 把这套配方推到一组超参跨域通用。\n", + "\n", + "## What this proves\n", + "\n", + "1. **WM 学到了视觉动力学**：从 64×64 RGB 像素出发，3 层 CNN encoder + RSSM (h 200-d GRU + z 32-d Gaussian) + 转置卷积 decoder + reward/continue heads 在 5 分钟内把重建误差压到肉眼可分辨的水平。\n", + "2. **策略完全在 imagination 中改进**：actor-critic 从未直接看到像素，只看潜在的 (h, z)。每个外循环采集 12 条真实轨迹，用它们更新 WM，再在 imagination 里跑 50 次 λ-return 回归更新 actor/critic。\n", + "3. **重建质量界定了可达回报**：当 15 步开环 rollout 的 pixel MSE 越来越大，actor 想象出来的回报越来越不可信——这就是 \"梦境寿命\" 对策略改进的硬上限。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "imports", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 1 - imports & seeding\n", + "import os, sys, time\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Headless render for any pygame fallback - we never call it but be safe.\n", + "os.environ.setdefault('SDL_VIDEODRIVER', 'dummy')\n", + "\n", + "ROOT = Path('.').resolve()\n", + "if str(ROOT) not in sys.path:\n", + " sys.path.insert(0, str(ROOT))\n", + "\n", + "from src.seeds import seed_everything\n", + "from src.world_model import WMConfig, WorldModel, SequenceBuffer, collect_random_episode\n", + "from src.policy import PolicyConfig, DreamerTrainer, train_dreamer, save_checkpoint, load_checkpoint\n", + "from src.env import make_pixel_cartpole\n", + "from src import viz\n", + "\n", + "SEED = 0\n", + "seed_everything(SEED)\n", + "ASSETS = Path('assets'); ASSETS.mkdir(exist_ok=True)\n", + "DATA = Path('data'); DATA.mkdir(exist_ok=True)\n", + "print('torch', torch.__version__, '· seed', SEED)" + ] + }, + { + "cell_type": "markdown", + "id": "wm-md", + "metadata": {}, + "source": [ + "## 1. 先学一个能重建的世界模型\n", + "\n", + "我们采集 60 条随机策略轨迹（约 1500 步真实环境数据），训练 5 个 epoch（共 125 次梯度更新）的 RSSM。损失：reconstruction + reward + continue + KL（balancing α=0.8）。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "train-wm", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 2 - train the world model in isolation on a random buffer\n", + "from src.trainer import train_wm_only\n", + "\n", + "wm_cfg = WMConfig(epochs=5, standalone_episodes=60, standalone_max_steps_per_ep=40)\n", + "t0 = time.time()\n", + "wm_run = train_wm_only(wm_cfg, verbose=False)\n", + "wm = wm_run['model']\n", + "print(f'[WM-only] trained in {time.time() - t0:.1f}s · final recon = {wm_run[\"losses\"][-1][\"recon\"]:.2f} · final KL = {wm_run[\"losses\"][-1][\"kl\"]:.2f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "recon-strips", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 3 - reconstruction strips: 4 rollouts, real on top, reconstructed below\n", + "from src.viz import reconstruction_strips\n", + "out = reconstruction_strips(wm, env_seed=SEED, n_strips=4, strip_len=10, out_path=ASSETS / 'reconstruction_grid.png')\n", + "print('saved', out)\n", + "from IPython.display import Image\n", + "Image(str(out))" + ] + }, + { + "cell_type": "markdown", + "id": "policy-md", + "metadata": {}, + "source": [ + "## 2. 在 imagination 里训练 actor-critic\n", + "\n", + "完整 Dreamer 循环 8 轮：每轮采集 12 条真实轨迹（≈ 数百 env steps），更新 WM 18 次，再从 buffer 采样 latent 起点，按 actor 想象 12 步，求 λ-return，更新 actor 和 critic 50 次。整个过程预算 ≤ 6 分钟。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "train-dreamer", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 4 - full Dreamer cycle (WM + AC in imagination)\n", + "seed_everything(SEED)\n", + "pol_cfg = PolicyConfig(n_cycles=8, episodes_per_cycle=12, seed=SEED)\n", + "wm_cfg2 = WMConfig(seed=SEED)\n", + "t0 = time.time()\n", + "trainer = train_dreamer(wm_cfg=wm_cfg2, pol_cfg=pol_cfg, verbose=True)\n", + "print(f'\\n[Dreamer] wall = {time.time() - t0:.1f}s')\n", + "print(f'[Dreamer] final cycle mean return = {trainer.history[\"returns\"][-1]:.1f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "return-curve", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 5 - return-vs-env-steps curve\n", + "from src.viz import return_curve\n", + "out = return_curve(trainer.history, out_path=ASSETS / 'return_vs_steps.png')\n", + "print('saved', out)\n", + "Image(str(out))" + ] + }, + { + "cell_type": "markdown", + "id": "latent-md", + "metadata": {}, + "source": [ + "## 3. Latent rollout vs. real rollout — \"梦境寿命\"\n", + "\n", + "从同一个起始观察出发，用同一段动作序列在真实环境和 WM 的 latent 空间里各跑 15 步。底下那条 pixel-MSE 曲线就是 WM 误差随 horizon 增长的经验证据——这是 imagination 能买回多少 policy improvement 的硬上限。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "latent-vs-real", + "metadata": {}, + "outputs": [], + "source": [ + "# Cell 6 - 15-step latent rollout next to real rollout\n", + "from src.viz import latent_vs_real_rollout\n", + "out = latent_vs_real_rollout(trainer.wm, env_seed=SEED + 13, horizon=15, out_path=ASSETS / 'latent_vs_real_rollout.png')\n", + "print('saved', out)\n", + "Image(str(out))" + ] + }, + { + "cell_type": "markdown", + "id": "wrap-md", + "metadata": {}, + "source": [ + "## 三条 stretch goals\n", + "\n", + "1. **离散 RSSM**：把 `world_model.RSSM` 的 stochastic state 换成 32-categorical + straight-through，复现 DreamerV2 的核心 trick。通常对 KL 项更稳定。\n", + "2. **Domain randomisation**：在 `env._render_cartpole_state` 里随机化背景颜色、cart 尺寸或杆颜色，测试 WM 是否仍能 generalise（论文里这一类扰动是检验 latent 是否捕捉到 task-relevant 信息的标准做法）。\n", + "3. **MountainCar / Acrobot**：把 `make_pixel_cartpole` 替换成 MountainCar 的像素版。reward 稀疏会让 reward head 失去训练信号——同样的 RSSM 在更稀疏的反馈下能跑多远？" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/paper.md b/labs/world_models/lab_dreamer_cartpole_pixels/paper.md new file mode 100644 index 0000000..566b0bd --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/paper.md @@ -0,0 +1,40 @@ +# 从像素到 imagination：一棵世界模型谱系的最小复现 + +三张 Atlas 卡片汇聚于此：[paper_world_models](../../docs/data/cards/paper_world_models.md) +（Ha & Schmidhuber 2018）首次把 VAE+MDN-RNN 当作"脑内模拟器"，在 latent 空间内训练 +controller；[paper_dreamer_v2](../../docs/data/cards/extended/paper_dreamer_v2.md) +把 latent 换成 RSSM——deterministic GRU 隐状态 $h_t$ + 离散随机 $z_t$， +配合 KL balancing 让 prior 追 posterior；[paper_dreamer_v3](../../docs/data/cards/extended/paper_dreamer_v3.md) +则用 symlog/TwoHot 等规范化把这套配方从研究原型变成统一超参的通用基线。 + +本 lab 复现的最小核心： + +1. **encoder**：3 层 CNN，64×64×3 → 256-d； +2. **RSSM**：GRU 200-d $h_t$ + 32-d Gaussian $z_t$（V1 风格简化，比 V2 categorical 更便宜，本质动力学一致）； +3. **decoder**：转置卷积镜像 encoder； +4. **reward head & continue head**：(h, z) → 标量； +5. **损失**：$\mathcal{L} = \text{recon} + \text{reward} + \text{continue} + \alpha\,\mathrm{KL}(q\|\text{sg}(p)) + (1-\alpha)\,\mathrm{KL}(\text{sg}(q)\|p)$，$\alpha=0.8$； +6. **actor-critic**：仅在 imagine 出来的 (h, z) 轨迹上训练，回报用 λ-return ($\lambda=0.95$)，并按 continue 头预测的 $\gamma\cdot p(\text{cont})$ 折扣。 + +```mermaid +flowchart LR + obs["o_t (64×64 RGB)"] --> enc["CNN encoder"] + enc --> embed["256-d embed"] + embed --> post["posterior q(z_t|h_t,o_t)"] + h["h_t = GRU(h_{t-1}, z_{t-1}, a_{t-1})"] --> post + h --> prior["prior p(z_t|h_t)"] + post --> z["z_t ~ N(mu, sigma)"] + z --> dec["transposed-conv decoder"] + z --> rh["reward head"] + z --> ch["continue head"] + prior <-->|KL balancing α=0.8| post + z --> img["latent imagination rollout"] + img --> ac["actor + critic (λ-return)"] + ac --> pol["policy"] + pol -->|sample real episodes| obs +``` + +三条进化主轴清晰可见：**像素→latent 压缩**让规划可负担、 +**RSSM**让 latent 动力学可学习、**continue head + λ-return**让 imagination 不至于无限乐观。 +后续 lab 可以沿任意一条加深：换 categorical 潜变量、加 symlog/TwoHot、 +或把环境推到稀疏奖励来逼出世界模型的局限。 diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/requirements.txt b/labs/world_models/lab_dreamer_cartpole_pixels/requirements.txt new file mode 100644 index 0000000..0ce0ae3 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/requirements.txt @@ -0,0 +1,8 @@ +numpy==2.1.3 +matplotlib==3.10.9 +torch==2.12.0 +gymnasium==1.2.1 +nbformat==5.10.4 +nbconvert==7.17.1 +ipykernel==6.30.1 +jupyter==1.1.1 diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/__init__.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/__init__.py new file mode 100644 index 0000000..6876483 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/__init__.py @@ -0,0 +1 @@ +"""Dreamer-style world model reproduction lab on CartPole pixels.""" diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/env.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/env.py new file mode 100644 index 0000000..3f0ae46 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/env.py @@ -0,0 +1,139 @@ +"""CartPole-v1 wrapped to emit 64x64 RGB observations. + +We avoid the pygame-based ``render_mode='rgb_array'`` path because it is slow +and pulls in optional dependencies. Instead we draw the cart+pole into a +64x64x3 ``uint8`` array directly from the underlying 4-d state, which is +deterministic, CPU-friendly, and produces visually clean reconstructions for +the autoencoder to model. + +The wrapper exposes: +- ``PixelCartPole.reset()`` -> (obs, info) where ``obs`` is ``float32`` 3x64x64 in [0,1]. +- ``PixelCartPole.step(action)`` -> (obs, reward, terminated, truncated, info). +- ``PixelCartPole.render_state(state)`` -> static helper to render an arbitrary state. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + +import gymnasium as gym +import numpy as np + +IMG_SIZE = 64 +ACTION_DIM = 2 # CartPole has two discrete actions. + + +@dataclass +class PixelObs: + """Canonical observation specs for downstream models.""" + + channels: int = 3 + height: int = IMG_SIZE + width: int = IMG_SIZE + + +def _render_cartpole_state(state: np.ndarray, size: int = IMG_SIZE) -> np.ndarray: + """Render a CartPole state into a HxWx3 uint8 image. + + State layout (Gymnasium): [cart_x, cart_v, pole_theta, pole_omega]. + Cart x is bounded in roughly [-2.4, 2.4]; we map that to [0, size). + The pole length in image units is fixed; the angle drives its end point. + """ + x = float(state[0]) + theta = float(state[2]) + + img = np.full((size, size, 3), 250, dtype=np.uint8) # near-white background + + # Ground line + ground_y = int(size * 0.7) + img[ground_y : ground_y + 1, :, :] = 60 + + # Cart geometry + x_range = 2.4 * 1.05 # add a little margin so cart never clips fully + cart_cx = int((x + x_range) / (2 * x_range) * size) + cart_cx = max(6, min(size - 7, cart_cx)) + cart_half_w = 8 + cart_half_h = 4 + cy0 = ground_y - cart_half_h + cy1 = ground_y + cart_half_h + cx0 = max(0, cart_cx - cart_half_w) + cx1 = min(size, cart_cx + cart_half_w) + # Dark slate cart + img[cy0:cy1, cx0:cx1, 0] = 40 + img[cy0:cy1, cx0:cx1, 1] = 60 + img[cy0:cy1, cx0:cx1, 2] = 100 + + # Pole - draw with simple line rasterisation (Bresenham-like via linspace). + pole_len_px = int(size * 0.35) + base_x = cart_cx + base_y = cy0 + # In Gymnasium CartPole the pole sticks up; theta>0 is leaning right. + end_x = base_x + int(np.sin(theta) * pole_len_px) + end_y = base_y - int(np.cos(theta) * pole_len_px) + n_steps = max(abs(end_x - base_x), abs(end_y - base_y)) + 1 + xs = np.linspace(base_x, end_x, n_steps).astype(int) + ys = np.linspace(base_y, end_y, n_steps).astype(int) + # Thicken the line by drawing a 3x3 cross at each sampled pixel. + for dx in (-1, 0, 1): + for dy in (-1, 0, 1): + xx = np.clip(xs + dx, 0, size - 1) + yy = np.clip(ys + dy, 0, size - 1) + img[yy, xx, 0] = 200 + img[yy, xx, 1] = 80 + img[yy, xx, 2] = 30 + + return img + + +class PixelCartPole: + """Thin wrapper around CartPole-v1 yielding 64x64 RGB observations. + + We deliberately do NOT use ``gym.make("CartPole-v1", render_mode="rgb_array")`` + because that pulls pygame and renders a 600x400 frame we would have to + downsample. The state-based render is faster (~30us) and pixel-stable. + """ + + observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(3, IMG_SIZE, IMG_SIZE), dtype=np.float32) + action_space = gym.spaces.Discrete(ACTION_DIM) + + def __init__(self, seed: int | None = None): + # We keep render_mode=None so gymnasium doesn't try to import pygame. + self._env = gym.make("CartPole-v1") + self._seed = seed + self._last_state = np.zeros(4, dtype=np.float32) + + def reset(self, seed: int | None = None) -> tuple[np.ndarray, dict]: + s = seed if seed is not None else self._seed + obs_state, info = self._env.reset(seed=s) + self._last_state = obs_state.astype(np.float32) + return self._render(self._last_state), info + + def step(self, action: int) -> tuple[np.ndarray, float, bool, bool, dict]: + obs_state, reward, terminated, truncated, info = self._env.step(int(action)) + self._last_state = obs_state.astype(np.float32) + return self._render(self._last_state), float(reward), bool(terminated), bool(truncated), info + + @property + def state(self) -> np.ndarray: + """Expose the underlying 4-d state for visualisation / debug only.""" + return self._last_state.copy() + + def close(self) -> None: + self._env.close() + + @staticmethod + def _render(state: np.ndarray) -> np.ndarray: + rgb = _render_cartpole_state(state) + # Channel-first float32 in [0, 1] for direct conversion to torch tensor. + return (rgb.astype(np.float32) / 255.0).transpose(2, 0, 1) + + @classmethod + def render_state(cls, state: np.ndarray) -> np.ndarray: + """Return CHW float32 image for an arbitrary 4-d state (debug).""" + return cls._render(np.asarray(state, dtype=np.float32)) + + +def make_pixel_cartpole(seed: int | None = None) -> PixelCartPole: + """Factory matching the style of the DQN/PPO lab.""" + return PixelCartPole(seed=seed) diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/policy.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/policy.py new file mode 100644 index 0000000..e971776 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/policy.py @@ -0,0 +1,446 @@ +"""Actor-critic trained purely in the world model's latent imagination. + +This is the second half of the Dreamer recipe. We: +1. Collect real environment data with the current (or random) policy. +2. Train the world model on observation sequences. +3. Sample starting latents from the buffer, imagine fixed-horizon rollouts + under the actor, compute lambda-returns from the predicted rewards and + critic, and update actor+critic by backprop through imagination. +4. Iterate 8 outer cycles. + +Running ``python -m src.policy`` performs the full Dreamer cycle and saves +``data/dreamer.pt`` with the world model + actor + critic weights. +""" + +from __future__ import annotations + +import math +import os +import time +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from src.env import ACTION_DIM, make_pixel_cartpole +from src.seeds import seed_everything +from src.world_model import ( + SequenceBuffer, + WMConfig, + WorldModel, + collect_random_episode, +) + + +# ----------------------------- Hyperparameters ------------------------------ # + + +@dataclass +class PolicyConfig: + """All Dreamer hyperparameters at the top so the notebook can override. + + The defaults are tuned so that ``python -m src.policy`` completes in + roughly 6 minutes on a 2-thread CPU laptop. Loosen any time budget at + your own risk. + """ + + # Outer loop + n_cycles: int = 8 # repeats of (collect -> train WM -> train AC) + episodes_per_cycle: int = 12 # real env trajectories collected each cycle + max_steps_per_episode: int = 100 # cap so a useless policy can't stall the loop + + # World-model training inside a cycle + wm_updates_per_cycle: int = 18 # gradient steps on the WM each cycle + wm_pretrain_updates: int = 60 # extra WM updates in the very first cycle + wm_seq_len: int = 20 # T in WM minibatches + wm_batch_size: int = 8 # B in WM minibatches + + # Actor-critic + ac_hidden: int = 200 + actor_lr: float = 1e-4 + critic_lr: float = 3e-4 + imagine_horizon: int = 12 + imagine_batch: int = 32 # number of trajectories imagined per AC update + ac_updates_per_cycle: int = 50 # gradient steps on actor+critic each cycle + gamma: float = 0.99 + lambda_: float = 0.95 # GAE/lambda-return mixing + actor_entropy: float = 0.005 + + # Init epsilon for the first cycle - actions are uniform random before any AC training. + initial_random_steps: int = 500 + + # Reproducibility / IO + seed: int = 0 + + +# ----------------------------- Actor & Critic ------------------------------- # + + +class Actor(nn.Module): + """Discrete-action stochastic policy over (h, z).""" + + def __init__(self, in_dim: int, action_dim: int, hidden: int): + super().__init__() + self.net = nn.Sequential( + nn.Linear(in_dim, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, action_dim), + ) + + def forward(self, feat: torch.Tensor) -> torch.distributions.Categorical: + logits = self.net(feat) + return torch.distributions.Categorical(logits=logits) + + +class Critic(nn.Module): + """Scalar value V(h, z).""" + + def __init__(self, in_dim: int, hidden: int): + super().__init__() + self.net = nn.Sequential( + nn.Linear(in_dim, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, 1), + ) + + def forward(self, feat: torch.Tensor) -> torch.Tensor: + return self.net(feat).squeeze(-1) + + +# --------------------------- Lambda-return helper --------------------------- # + + +def lambda_return( + rewards: torch.Tensor, # (H, B) imagined rewards + values: torch.Tensor, # (H, B) bootstrap values at each step + bootstrap: torch.Tensor, # (B,) value at H (terminal bootstrap) + gamma: float, + lam: float, + continues: torch.Tensor | None = None, # (H, B) per-step continuation prob +) -> torch.Tensor: + """Compute V^{lambda}_t recursively, as in Dreamer's paper. + + The effective discount at step t is ``gamma * continues[t]`` so the + return is auto-truncated when the world model predicts termination. + + Returns a tensor of shape (H, B) where index t is the lambda-return + starting from step t with terminal bootstrap V(s_H) = ``bootstrap``. + """ + H = rewards.shape[0] + if continues is None: + continues = torch.ones_like(rewards) + # Per-step effective discount. + disc = gamma * continues # (H, B) + next_values = torch.cat([values[1:], bootstrap.unsqueeze(0)], dim=0) # (H, B) + inputs = rewards + disc * (1 - lam) * next_values # (H, B) + returns = torch.zeros_like(rewards) + acc = bootstrap + for t in reversed(range(H)): + acc = inputs[t] + disc[t] * lam * acc + returns[t] = acc + return returns + + +# ------------------------------ Cycle driver -------------------------------- # + + +class DreamerTrainer: + """Coordinates env collection, WM training, and AC training in a cycle.""" + + def __init__(self, wm_cfg: WMConfig, pol_cfg: PolicyConfig): + # Reconcile WM config with the policy's expected dimensions. + wm_cfg.seq_len = pol_cfg.wm_seq_len + wm_cfg.batch_size = pol_cfg.wm_batch_size + self.wm_cfg = wm_cfg + self.pol_cfg = pol_cfg + + self.wm = WorldModel(wm_cfg) + feat_dim = wm_cfg.deter_dim + wm_cfg.stoch_dim + self.actor = Actor(feat_dim, wm_cfg.action_dim, pol_cfg.ac_hidden) + self.critic = Critic(feat_dim, pol_cfg.ac_hidden) + + self.wm_opt = torch.optim.Adam(self.wm.parameters(), lr=wm_cfg.lr, weight_decay=wm_cfg.weight_decay) + self.actor_opt = torch.optim.Adam(self.actor.parameters(), lr=pol_cfg.actor_lr) + self.critic_opt = torch.optim.Adam(self.critic.parameters(), lr=pol_cfg.critic_lr) + + self.buffer = SequenceBuffer(max_episodes=200, seq_len=wm_cfg.seq_len) + self.env = make_pixel_cartpole(seed=pol_cfg.seed) + self.rng = np.random.default_rng(pol_cfg.seed) + + # Diagnostics accumulated across the run. + self.history = { + "env_steps": [], + "returns": [], # rolling mean of recent real-env episode returns + "raw_returns": [], # raw per-episode returns + "raw_steps": [], # cumulative env-step at episode end + "wm_recon": [], + "wm_kl": [], + "wm_reward": [], + "actor_loss": [], + "critic_loss": [], + "cycle_wall": [], + } + self._total_env_steps = 0 + + # ---------- env interaction ---------- # + + def _act(self, obs_np: np.ndarray, explore: bool) -> int: + """Pick an action from the current policy, using a 1-step posterior.""" + obs_t = torch.from_numpy(obs_np).unsqueeze(0) # (1, 3, H, W) + with torch.no_grad(): + h0, z0 = self.wm.initial_latent(obs_t) + feat = torch.cat([h0, z0], dim=-1) + dist = self.actor(feat) + a = dist.sample() if explore else dist.probs.argmax(dim=-1) + return int(a.item()) + + def collect_episodes(self, n_episodes: int, use_random: bool) -> tuple[list[float], int]: + """Collect ``n_episodes`` trajectories; returns (per-episode returns, env steps).""" + returns = [] + steps = 0 + for _ in range(n_episodes): + o, _ = self.env.reset() + obs_list, act_list, rew_list, term_list = [], [], [], [] + ep_return = 0.0 + for _ in range(self.pol_cfg.max_steps_per_episode): + if use_random or self._total_env_steps < self.pol_cfg.initial_random_steps: + a = int(self.env.action_space.sample()) + else: + a = self._act(o, explore=True) + obs_list.append(o) + no, r, term, trunc, _ = self.env.step(a) + act_list.append(a); rew_list.append(r); term_list.append(bool(term)) + ep_return += r + steps += 1 + self._total_env_steps += 1 + o = no + if term or trunc: + break + self.buffer.add_episode(obs_list, act_list, rew_list, term_list) + returns.append(ep_return) + self.history["raw_returns"].append(ep_return) + self.history["raw_steps"].append(self._total_env_steps) + return returns, steps + + # ---------- world model training ---------- # + + def update_world_model(self, n_updates: int) -> dict[str, float]: + agg = {"recon": 0.0, "reward": 0.0, "kl": 0.0} + for _ in range(n_updates): + batch = self.buffer.sample(self.wm_cfg.batch_size, self.rng) + out = self.wm.compute_loss(batch) + self.wm_opt.zero_grad() + out["loss"].backward() + torch.nn.utils.clip_grad_norm_(self.wm.parameters(), self.wm_cfg.grad_clip) + self.wm_opt.step() + agg["recon"] += float(out["recon"].item()) + agg["reward"] += float(out["reward"].item()) + agg["kl"] += float(out["kl"].item()) + n = max(1, n_updates) + return {k: v / n for k, v in agg.items()} + + # ---------- actor-critic training in imagination ---------- # + + def _sample_initial_latents(self, batch_size: int) -> tuple[torch.Tensor, torch.Tensor]: + """Encode buffer slices and grab posterior (h, z) at random per-episode + timesteps as imagination starts. We bias toward earlier timesteps so + the actor never imagines from terminal (post-fall) states - those have + no recoverable action and produce zero advantage.""" + with torch.no_grad(): + batch = self.buffer.sample(batch_size, self.rng) + embeds = self.wm.encoder(batch["obs"]) + states = self.wm.rssm.observe(embeds, batch["act"]) + T, B = states["h"].shape[:2] + # Bias starting points toward the first half of each window so the + # actor has room to demonstrate balance behaviour in imagination. + max_t = max(2, T // 2) + ts = self.rng.integers(1, max_t, size=B) + ts_t = torch.from_numpy(ts).long() + h_init = states["h"][ts_t, torch.arange(B)].detach() + z_init = states["z"][ts_t, torch.arange(B)].detach() + return h_init, z_init + + def update_actor_critic(self, n_updates: int) -> dict[str, float]: + cfg = self.pol_cfg + H = cfg.imagine_horizon + # Freeze WM during AC updates - we backprop through its dynamics but + # do NOT update its weights. + for p in self.wm.parameters(): + p.requires_grad_(False) + + agg = {"actor": 0.0, "critic": 0.0} + for _ in range(n_updates): + init_h, init_z = self._sample_initial_latents(cfg.imagine_batch) + B = init_h.shape[0] + + # Imagine H steps. Actions sampled from the actor at each step; + # rewards from the WM reward head; values from the critic. + # The actor's gradient flows only through the REINFORCE log-prob + # below (advantage is detached). The critic's gradient flows + # through `values = critic(feat)` for each step. + h, z = init_h, init_z + feats, log_probs, entropies, rewards, continues = [], [], [], [], [] + for t in range(H): + feat = torch.cat([h, z], dim=-1) + dist = self.actor(feat) + a = dist.sample() + log_p = dist.log_prob(a) + ent = dist.entropy() + a_oh = F.one_hot(a, num_classes=ACTION_DIM).float() + step_out = self.wm.rssm.step(h, z, a_oh, embed=None) + h, z = step_out["h"], step_out["z"] + feats.append(feat) + rewards.append(self.wm.reward_head(h, z)) + continues.append(torch.sigmoid(self.wm.continue_head(h, z))) + log_probs.append(log_p) + entropies.append(ent) + + # values predicted at each visited state (excluding init); we also + # need a bootstrap value at H. + final_feat = torch.cat([h, z], dim=-1) + values = torch.stack([self.critic(f) for f in feats], dim=0) # (H, B) + bootstrap = self.critic(final_feat) # (B,) + rewards_t = torch.stack(rewards, dim=0).detach() # (H, B) - stop-grad + continues_t = torch.stack(continues, dim=0).detach() # (H, B) - stop-grad + log_probs_t = torch.stack(log_probs, dim=0) # (H, B) + entropies_t = torch.stack(entropies, dim=0) # (H, B) + + returns = lambda_return( + rewards_t, values, bootstrap, cfg.gamma, cfg.lambda_, continues=continues_t, + ) + + # Cumulative discount along the trajectory so steps past predicted + # termination contribute little to the actor / critic loss. + with torch.no_grad(): + disc = torch.cumprod( + torch.cat([torch.ones(1, B), continues_t[:-1] * cfg.gamma], dim=0), + dim=0, + ) + + # Actor loss: REINFORCE on imagined advantages, normalised so the + # gradient magnitude is scale-free. This is the Dreamer V2 style + # update for discrete actions. The critic baseline reduces variance + # and the entropy term keeps exploration alive while learning. + adv = (returns.detach() - values.detach()) + adv = (adv - adv.mean()) / (adv.std() + 1e-6) + reinforce_term = -(disc * log_probs_t * adv).mean() + entropy_term = -cfg.actor_entropy * (disc * entropies_t).mean() + actor_loss = reinforce_term + entropy_term + + # Critic loss: regress to lambda-returns (stop-grad on targets). + critic_loss = (disc * (values - returns.detach()).pow(2)).mean() + + # Separate backward passes (actor's graph and critic's graph share + # imagined features, so we retain the graph on the first pass). + self.actor_opt.zero_grad() + actor_loss.backward(retain_graph=True) + torch.nn.utils.clip_grad_norm_(self.actor.parameters(), 10.0) + self.actor_opt.step() + + self.critic_opt.zero_grad() + critic_loss.backward() + torch.nn.utils.clip_grad_norm_(self.critic.parameters(), 10.0) + self.critic_opt.step() + + agg["actor"] += float(actor_loss.item()) + agg["critic"] += float(critic_loss.item()) + + for p in self.wm.parameters(): + p.requires_grad_(True) + + n = max(1, n_updates) + return {k: v / n for k, v in agg.items()} + + # ---------- end-to-end driver ---------- # + + def run(self, verbose: bool = True) -> dict: + cfg = self.pol_cfg + wall_start = time.time() + for cycle in range(cfg.n_cycles): + t_cycle = time.time() + use_random = (cycle == 0) + returns, _ = self.collect_episodes(cfg.episodes_per_cycle, use_random=use_random) + + # Give the WM a head start in cycle 0 so the first AC update sees + # a model that already encodes coherent dynamics rather than noise. + n_wm = cfg.wm_updates_per_cycle + (cfg.wm_pretrain_updates if cycle == 0 else 0) + wm_metrics = self.update_world_model(n_wm) + ac_metrics = self.update_actor_critic(cfg.ac_updates_per_cycle) + + self.history["env_steps"].append(self._total_env_steps) + self.history["returns"].append(float(np.mean(returns))) + self.history["wm_recon"].append(wm_metrics["recon"]) + self.history["wm_kl"].append(wm_metrics["kl"]) + self.history["wm_reward"].append(wm_metrics["reward"]) + self.history["actor_loss"].append(ac_metrics["actor"]) + self.history["critic_loss"].append(ac_metrics["critic"]) + self.history["cycle_wall"].append(time.time() - t_cycle) + + if verbose: + print( + f"[Dreamer] cycle={cycle+1}/{cfg.n_cycles} " + f"env_steps={self._total_env_steps} " + f"return(avg{cfg.episodes_per_cycle})={np.mean(returns):.1f} " + f"recon={wm_metrics['recon']:.1f} kl={wm_metrics['kl']:.2f} " + f"actor={ac_metrics['actor']:.3f} critic={ac_metrics['critic']:.3f} " + f"({time.time()-t_cycle:.1f}s)" + ) + + elapsed = time.time() - wall_start + if verbose: + print(f"[Dreamer] total wall-clock = {elapsed:.1f}s") + self.history["total_wall"] = elapsed + return self.history + + +def save_checkpoint(trainer: DreamerTrainer, path: str | os.PathLike) -> None: + torch.save({ + "wm": trainer.wm.state_dict(), + "actor": trainer.actor.state_dict(), + "critic": trainer.critic.state_dict(), + "wm_cfg": trainer.wm_cfg.__dict__, + "pol_cfg": trainer.pol_cfg.__dict__, + "history": trainer.history, + }, path) + + +def load_checkpoint(path: str | os.PathLike, wm_cfg: WMConfig, pol_cfg: PolicyConfig) -> DreamerTrainer: + trainer = DreamerTrainer(wm_cfg, pol_cfg) + ckpt = torch.load(path, map_location="cpu", weights_only=False) + trainer.wm.load_state_dict(ckpt["wm"]) + trainer.actor.load_state_dict(ckpt["actor"]) + trainer.critic.load_state_dict(ckpt["critic"]) + trainer.history = ckpt.get("history", trainer.history) + return trainer + + +def train_dreamer( + wm_cfg: WMConfig | None = None, + pol_cfg: PolicyConfig | None = None, + verbose: bool = True, +) -> DreamerTrainer: + wm_cfg = wm_cfg or WMConfig() + pol_cfg = pol_cfg or PolicyConfig() + seed_everything(pol_cfg.seed) + + trainer = DreamerTrainer(wm_cfg, pol_cfg) + trainer.run(verbose=verbose) + + data_dir = Path(__file__).resolve().parent.parent / "data" + data_dir.mkdir(exist_ok=True) + ckpt_path = data_dir / "dreamer.pt" + save_checkpoint(trainer, ckpt_path) + if verbose: + print(f"[Dreamer] checkpoint saved to {ckpt_path}") + return trainer + + +if __name__ == "__main__": + train_dreamer() diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/seeds.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/seeds.py new file mode 100644 index 0000000..9b94b33 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/seeds.py @@ -0,0 +1,23 @@ +"""Deterministic seeding helpers for the Dreamer lab.""" + +from __future__ import annotations + +import os +import random + +import numpy as np +import torch + + +def seed_everything(seed: int = 0) -> None: + """Seed Python, NumPy, and PyTorch RNGs for reproducible runs. + + Note: Gymnasium env determinism also requires ``env.reset(seed=...)``. + """ + os.environ["PYTHONHASHSEED"] = str(seed) + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.use_deterministic_algorithms(False) + # Single-threaded CPU keeps training fast and reproducible. + torch.set_num_threads(1) diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/trainer.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/trainer.py new file mode 100644 index 0000000..5c6ad29 --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/trainer.py @@ -0,0 +1,39 @@ +"""Notebook-facing facade that bundles the WM and policy training calls. + +Keeps the notebook narrative concise: one helper to train the world model +on a fixed buffer, one helper to run the full Dreamer cycle. +""" + +from __future__ import annotations + +from dataclasses import asdict +from pathlib import Path +from typing import Any + +import numpy as np +import torch + +from src.policy import DreamerTrainer, PolicyConfig, save_checkpoint, train_dreamer +from src.seeds import seed_everything +from src.world_model import ( + SequenceBuffer, + WMConfig, + WorldModel, + collect_random_episode, + train_world_model_only, +) + + +def train_wm_only(cfg: WMConfig | None = None, verbose: bool = True) -> dict[str, Any]: + """Train the world model in isolation on a random-policy buffer.""" + cfg = cfg or WMConfig() + return train_world_model_only(cfg, verbose=verbose) + + +def train_full_dreamer( + wm_cfg: WMConfig | None = None, + pol_cfg: PolicyConfig | None = None, + verbose: bool = True, +) -> DreamerTrainer: + """End-to-end Dreamer training cycle (WM + actor-critic in imagination).""" + return train_dreamer(wm_cfg=wm_cfg, pol_cfg=pol_cfg, verbose=verbose) diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/viz.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/viz.py new file mode 100644 index 0000000..1de4e5e --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/viz.py @@ -0,0 +1,203 @@ +"""Visualisation helpers for the Dreamer-style CartPole-pixels lab. + +Three figures are produced by the notebook: + +- ``reconstruction_grid``: 4 strips of 10 consecutive frames each, real on + top and the world model's reconstruction below. +- ``latent_vs_real_rollout``: side-by-side comparison of a 15-step rollout + in the real environment vs. the same action sequence played out in the + world model's latent space (decoded back into pixels each step). +- ``return_curve``: the policy's evaluation return as a function of real + environment steps, plus an annotation of the random-policy baseline. +""" + +from __future__ import annotations + +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import torch + +from src.env import IMG_SIZE, ACTION_DIM, PixelCartPole, make_pixel_cartpole +from src.world_model import WorldModel + + +# ----------------------------- Reconstruction ------------------------------ # + + +def reconstruction_strips( + wm: WorldModel, + env_seed: int, + n_strips: int = 4, + strip_len: int = 10, + out_path: str | Path = "assets/reconstruction_grid.png", +) -> Path: + """Collect ``n_strips`` rollouts and plot real vs. reconstructed frames.""" + wm.eval() + fig, axes = plt.subplots( + n_strips * 2, + strip_len, + figsize=(strip_len * 0.85, n_strips * 2 * 0.85), + squeeze=False, + ) + for s in range(n_strips): + env = make_pixel_cartpole(seed=env_seed + s * 7) + o, _ = env.reset() + obs_list, act_list = [o], [] + # Random policy is fine here: we are testing reconstruction, not control. + for _ in range(strip_len - 1): + a = int(env.action_space.sample()) + no, _, term, trunc, _ = env.step(a) + obs_list.append(no) + act_list.append(a) + if term or trunc: + break + # Pad if the episode ended early. + while len(obs_list) < strip_len: + obs_list.append(obs_list[-1]) + act_list.append(0) + + obs_t = torch.from_numpy(np.stack(obs_list, axis=0)).unsqueeze(1) # (T, 1, 3, H, W) + act_t = torch.tensor([0] + act_list[: strip_len - 1], dtype=torch.long).unsqueeze(1) # (T, 1) + + with torch.no_grad(): + embeds = wm.encoder(obs_t) + states = wm.rssm.observe(embeds, act_t) + feat = torch.cat([states["h"], states["z"]], dim=-1) + recon = wm.decoder(feat) # (T, 1, 3, H, W) + + for t in range(strip_len): + real_img = obs_t[t, 0].permute(1, 2, 0).clamp(0, 1).numpy() + recon_img = recon[t, 0].permute(1, 2, 0).clamp(0, 1).numpy() + axes[2 * s, t].imshow(real_img); axes[2 * s, t].axis("off") + axes[2 * s + 1, t].imshow(recon_img); axes[2 * s + 1, t].axis("off") + if t == 0: + axes[2 * s, 0].set_ylabel("real", fontsize=8, rotation=0, labelpad=22) + axes[2 * s + 1, 0].set_ylabel("recon", fontsize=8, rotation=0, labelpad=22) + env.close() + + plt.suptitle("Real (top of each pair) vs. world-model reconstruction (bottom)", fontsize=10) + plt.tight_layout() + out_path = Path(out_path) + out_path.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(out_path, dpi=130, bbox_inches="tight") + plt.close(fig) + return out_path + + +# --------------------- Latent rollout vs. real rollout --------------------- # + + +def latent_vs_real_rollout( + wm: WorldModel, + env_seed: int, + horizon: int = 15, + out_path: str | Path = "assets/latent_vs_real_rollout.png", + actions: list[int] | None = None, +) -> Path: + """Compare a 15-step real rollout with a 15-step latent rollout from same start. + + The plot has two rows: real frames on top, decoded latent frames below. + A second mini-plot below shows the per-step pixel-MSE growing with the + rollout horizon - the empirical 'long-time consistency' demonstration. + """ + wm.eval() + env = make_pixel_cartpole(seed=env_seed) + o, _ = env.reset() + + # Pick an action sequence (deterministic for reproducibility). + if actions is None: + rng = np.random.default_rng(env_seed) + actions = [int(rng.integers(0, ACTION_DIM)) for _ in range(horizon - 1)] + + real_obs = [o] + for a in actions: + no, _, term, trunc, _ = env.step(a) + real_obs.append(no) + if term or trunc: + # Pad by repeating the last real frame so shapes line up. + while len(real_obs) < horizon: + real_obs.append(real_obs[-1]) + break + while len(real_obs) < horizon: + # If the episode never terminated we may still be short; pad. + real_obs.append(real_obs[-1]) + env.close() + + real_t = torch.from_numpy(np.stack(real_obs, axis=0)).unsqueeze(1) # (H, 1, 3, *) + + # Encode the first frame, then imagine forward with the given actions. + with torch.no_grad(): + h, z = wm.initial_latent(real_t[0]) + feats = [torch.cat([h, z], dim=-1)] + for a in actions: + a_t = torch.tensor([a], dtype=torch.long) + out = wm.rssm.step(h, z, a_t, embed=None) + h, z = out["h"], out["z"] + feats.append(torch.cat([h, z], dim=-1)) + feat_t = torch.stack(feats, dim=0) # (H, 1, deter+stoch) + latent_obs = wm.decoder(feat_t) # (H, 1, 3, H_im, W_im) + + # Per-step pixel MSE between real and latent rollout. + mse_per_step = ((real_t - latent_obs) ** 2).mean(dim=(1, 2, 3, 4)).cpu().numpy() + + fig = plt.figure(figsize=(horizon * 0.75, 4.2)) + gs = fig.add_gridspec(3, horizon, height_ratios=[1, 1, 0.9]) + for t in range(horizon): + ax_r = fig.add_subplot(gs[0, t]) + ax_r.imshow(real_t[t, 0].permute(1, 2, 0).clamp(0, 1).numpy()); ax_r.axis("off") + ax_l = fig.add_subplot(gs[1, t]) + ax_l.imshow(latent_obs[t, 0].permute(1, 2, 0).clamp(0, 1).numpy()); ax_l.axis("off") + if t == 0: + ax_r.set_title("real", fontsize=8, loc="left") + ax_l.set_title("latent", fontsize=8, loc="left") + + ax_err = fig.add_subplot(gs[2, :]) + ax_err.plot(np.arange(horizon), mse_per_step, marker="o", color="#d62728") + ax_err.set_xlabel("horizon (steps after start)") + ax_err.set_ylabel("pixel MSE") + ax_err.set_title("World-model drift over a 15-step open-loop rollout") + ax_err.grid(alpha=0.3) + + plt.tight_layout() + out_path = Path(out_path) + out_path.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(out_path, dpi=130, bbox_inches="tight") + plt.close(fig) + return out_path + + +# ----------------------------- Return curve -------------------------------- # + + +def return_curve( + history: dict, + out_path: str | Path = "assets/return_vs_steps.png", + title: str = "Dreamer-style policy return vs. real-env steps", +) -> Path: + """Plot per-episode returns (raw + smoothed) against cumulative env steps.""" + steps = np.asarray(history.get("raw_steps", []), dtype=float) + returns = np.asarray(history.get("raw_returns", []), dtype=float) + + fig, ax = plt.subplots(figsize=(7.5, 4.0)) + if len(steps) > 0: + ax.plot(steps, returns, color="grey", alpha=0.4, label="per-episode") + w = max(1, min(15, len(returns) // 4)) + if len(returns) >= w: + kern = np.ones(w) / w + sm = np.convolve(returns, kern, mode="valid") + ax.plot(steps[w - 1:], sm, color="#1f77b4", lw=2.0, label=f"moving avg (w={w})") + + ax.set_xlabel("real environment steps") + ax.set_ylabel("episode return") + ax.set_title(title) + ax.grid(alpha=0.3) + ax.legend() + plt.tight_layout() + + out_path = Path(out_path) + out_path.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(out_path, dpi=130, bbox_inches="tight") + plt.close(fig) + return out_path diff --git a/labs/world_models/lab_dreamer_cartpole_pixels/src/world_model.py b/labs/world_models/lab_dreamer_cartpole_pixels/src/world_model.py new file mode 100644 index 0000000..a7d2e7c --- /dev/null +++ b/labs/world_models/lab_dreamer_cartpole_pixels/src/world_model.py @@ -0,0 +1,588 @@ +"""Dreamer-style world model: CNN encoder + RSSM (h_t, z_t) + decoder + reward head. + +This is a minimal but faithful reproduction of the Dreamer V1 RSSM, simplified +to fit a CPU-only budget: +- 64x64x3 -> CNN encoder -> 256-d feature. +- GRUCell maintains a 200-d deterministic state h_t. +- Stochastic state z_t is a 32-d Gaussian (V1-style). +- Prior p(z_t | h_t) and posterior q(z_t | h_t, o_t) are diagonal Gaussians. +- Decoder is a transposed-conv mirror of the encoder. +- Reward head is a small MLP on concat(h_t, z_t). + +Loss: + L = recon + reward + alpha * KL(q || sg(p)) + (1 - alpha) * KL(sg(q) || p) +with alpha = 0.8 (KL balancing, Dreamer V2 trick that also stabilises V1). + +Running ``python -m src.world_model`` collects a tiny dataset from a random +policy and trains the world model in isolation, demonstrating that pixels +become reconstructable in ~1 minute on a laptop. +""" + +from __future__ import annotations + +import math +import os +import time +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +# Local imports - use absolute paths so `python -m src.world_model` works. +from src.env import IMG_SIZE, ACTION_DIM, make_pixel_cartpole +from src.seeds import seed_everything + + +# ----------------------------- Hyperparameters ------------------------------ # + + +@dataclass +class WMConfig: + """All world-model hyperparameters live here so the notebook can tweak them. + + Hidden sizes are deliberately small to fit a CPU budget (<= 8 min total). + """ + + # Architecture + embed_dim: int = 256 + deter_dim: int = 200 # h_t width (GRU hidden) + stoch_dim: int = 32 # z_t dimensionality + hidden_dim: int = 200 # generic MLP width inside RSSM/heads + action_dim: int = ACTION_DIM + img_size: int = IMG_SIZE + + # Optimisation + lr: float = 6e-4 + weight_decay: float = 1e-6 + batch_size: int = 16 + seq_len: int = 32 + epochs: int = 5 # passes over the buffer per outer cycle + grad_clip: float = 100.0 + + # Loss weights + recon_weight: float = 1.0 + reward_weight: float = 1.0 + continue_weight: float = 1.0 + kl_weight: float = 1.0 + kl_balancing: float = 0.8 # alpha in the balancing equation + free_nats: float = 1.0 # minimum KL per dim before it counts toward the loss + + # Reproducibility + seed: int = 0 + + # Stand-alone training defaults (used by `python -m src.world_model`) + standalone_episodes: int = 60 + standalone_max_steps_per_ep: int = 60 + + +# ----------------------------- Replay storage ------------------------------- # + + +class SequenceBuffer: + """Stores variable-length episodes as channel-first float images. + + Sampling returns fixed-length sub-sequences ``(T, B, ...)`` suitable for + teacher-forced world-model training. We sample from any episode that is at + least ``seq_len`` long; shorter episodes are left in place but never drawn. + """ + + def __init__(self, max_episodes: int = 256, seq_len: int = 32): + self.max_episodes = max_episodes + self.seq_len = seq_len + self.episodes: list[dict[str, np.ndarray]] = [] + + def add_episode(self, obs: list[np.ndarray], act: list[int], rew: list[float], term: list[bool]) -> None: + ep = { + "obs": np.stack(obs, axis=0).astype(np.float32), # (T, 3, H, W) + "act": np.asarray(act, dtype=np.int64), # (T,) + "rew": np.asarray(rew, dtype=np.float32), # (T,) + "term": np.asarray(term, dtype=np.float32), # (T,) + } + self.episodes.append(ep) + if len(self.episodes) > self.max_episodes: + self.episodes.pop(0) + + def __len__(self) -> int: + return len(self.episodes) + + def total_steps(self) -> int: + return sum(int(ep["obs"].shape[0]) for ep in self.episodes) + + def sample(self, batch_size: int, rng: np.random.Generator) -> dict[str, torch.Tensor]: + # Filter to episodes long enough to yield a window. + eligible = [i for i, ep in enumerate(self.episodes) if ep["obs"].shape[0] >= self.seq_len] + if not eligible: + # Fallback: pad short episodes by repeating the last frame. + eligible = list(range(len(self.episodes))) + idxs = rng.choice(eligible, size=batch_size, replace=True) + + obs_b, act_b, rew_b, term_b = [], [], [], [] + for i in idxs: + ep = self.episodes[int(i)] + T = ep["obs"].shape[0] + if T >= self.seq_len: + start = int(rng.integers(0, T - self.seq_len + 1)) + sl = slice(start, start + self.seq_len) + obs_b.append(ep["obs"][sl]) + act_b.append(ep["act"][sl]) + rew_b.append(ep["rew"][sl]) + term_b.append(ep["term"][sl]) + else: + # Pad by repeating the last step. + pad = self.seq_len - T + obs_b.append(np.concatenate([ep["obs"], np.repeat(ep["obs"][-1:], pad, axis=0)], axis=0)) + act_b.append(np.concatenate([ep["act"], np.repeat(ep["act"][-1:], pad, axis=0)], axis=0)) + rew_b.append(np.concatenate([ep["rew"], np.zeros(pad, dtype=np.float32)], axis=0)) + term_b.append(np.concatenate([ep["term"], np.ones(pad, dtype=np.float32)], axis=0)) + + # Stack to (T, B, ...) layout - that's what RSSM unroll expects. + obs_t = torch.from_numpy(np.stack(obs_b, axis=1)) # (T, B, 3, H, W) + act_t = torch.from_numpy(np.stack(act_b, axis=1)) # (T, B) + rew_t = torch.from_numpy(np.stack(rew_b, axis=1)) # (T, B) + term_t = torch.from_numpy(np.stack(term_b, axis=1)) # (T, B) + return {"obs": obs_t, "act": act_t, "rew": rew_t, "term": term_t} + + +# ----------------------------- Network modules ------------------------------ # + + +class Encoder(nn.Module): + """3-conv-layer CNN: 64x64x3 -> 256-d feature vector.""" + + def __init__(self, embed_dim: int = 256): + super().__init__() + # 64 -> 32 -> 16 -> 8 + self.conv = nn.Sequential( + nn.Conv2d(3, 32, kernel_size=4, stride=2, padding=1), # 32x32 + nn.ReLU(inplace=True), + nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1), # 16x16 + nn.ReLU(inplace=True), + nn.Conv2d(64, 64, kernel_size=4, stride=2, padding=1), # 8x8 + nn.ReLU(inplace=True), + ) + # 64 * 8 * 8 = 4096 -> embed_dim + self.fc = nn.Linear(64 * 8 * 8, embed_dim) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # x: (..., 3, H, W) + lead_shape = x.shape[:-3] + x = x.reshape(-1, 3, IMG_SIZE, IMG_SIZE) + h = self.conv(x) + h = h.flatten(1) + h = F.relu(self.fc(h)) + return h.reshape(*lead_shape, -1) + + +class Decoder(nn.Module): + """Transposed-conv mirror of the encoder: (h, z) -> 3x64x64 image.""" + + def __init__(self, in_dim: int): + super().__init__() + self.fc = nn.Linear(in_dim, 64 * 8 * 8) + self.deconv = nn.Sequential( + nn.ConvTranspose2d(64, 64, kernel_size=4, stride=2, padding=1), # 16x16 + nn.ReLU(inplace=True), + nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1), # 32x32 + nn.ReLU(inplace=True), + nn.ConvTranspose2d(32, 3, kernel_size=4, stride=2, padding=1), # 64x64 + ) + + def forward(self, feat: torch.Tensor) -> torch.Tensor: + # feat: (..., in_dim) + lead_shape = feat.shape[:-1] + x = self.fc(feat.reshape(-1, feat.shape[-1])) + x = F.relu(x) + x = x.view(-1, 64, 8, 8) + x = self.deconv(x) + # Sigmoid so output lives in [0, 1] like the input. + x = torch.sigmoid(x) + return x.reshape(*lead_shape, 3, IMG_SIZE, IMG_SIZE) + + +class RSSM(nn.Module): + """Recurrent State-Space Model. + + State at time t consists of: + - deterministic h_t (GRU output, ``deter_dim``) + - stochastic z_t (sampled from posterior or prior, ``stoch_dim``) + + Transition: h_t = GRU(h_{t-1}, MLP([z_{t-1}, a_{t-1}])). + Prior: z_t ~ N(mu_p(h_t), sigma_p(h_t)). + Posterior: z_t ~ N(mu_q([h_t, embed_t]), sigma_q([h_t, embed_t])). + """ + + def __init__(self, cfg: WMConfig): + super().__init__() + self.cfg = cfg + self.deter_dim = cfg.deter_dim + self.stoch_dim = cfg.stoch_dim + self.action_dim = cfg.action_dim + h = cfg.hidden_dim + + # Prepare GRU input: MLP over (z_{t-1}, a_{t-1}). + self._pre_gru = nn.Sequential( + nn.Linear(cfg.stoch_dim + cfg.action_dim, h), + nn.ELU(inplace=True), + ) + self.gru = nn.GRUCell(h, cfg.deter_dim) + + # Prior MLP: h_t -> (mu, log_std). + self.prior_net = nn.Sequential( + nn.Linear(cfg.deter_dim, h), + nn.ELU(inplace=True), + nn.Linear(h, 2 * cfg.stoch_dim), + ) + # Posterior MLP: [h_t, embed_t] -> (mu, log_std). + self.post_net = nn.Sequential( + nn.Linear(cfg.deter_dim + cfg.embed_dim, h), + nn.ELU(inplace=True), + nn.Linear(h, 2 * cfg.stoch_dim), + ) + + # ----- low-level helpers ----- # + + def init_state(self, batch_size: int, device: torch.device) -> tuple[torch.Tensor, torch.Tensor]: + h = torch.zeros(batch_size, self.deter_dim, device=device) + z = torch.zeros(batch_size, self.stoch_dim, device=device) + return h, z + + @staticmethod + def _split(stats: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + mu, raw_std = stats.chunk(2, dim=-1) + # Softplus + small minimum keeps the dist non-degenerate. + std = F.softplus(raw_std) + 0.1 + return mu, std + + @staticmethod + def _sample(mu: torch.Tensor, std: torch.Tensor) -> torch.Tensor: + # Reparameterised Gaussian sample. + return mu + std * torch.randn_like(mu) + + def one_hot_action(self, a: torch.Tensor) -> torch.Tensor: + return F.one_hot(a.long(), num_classes=self.action_dim).float() + + # ----- the only two methods callers should need ----- # + + def step( + self, + prev_h: torch.Tensor, + prev_z: torch.Tensor, + prev_a: torch.Tensor, + embed: torch.Tensor | None = None, + ) -> dict[str, torch.Tensor]: + """Advance one step. + + If ``embed`` is provided, returns both prior and posterior stats and + samples z from the posterior (training). Otherwise samples from prior + (imagination). + """ + if prev_a.dim() == 1: + prev_a_oh = self.one_hot_action(prev_a) + else: + prev_a_oh = prev_a # already one-hot (used by imagination) + gru_in = self._pre_gru(torch.cat([prev_z, prev_a_oh], dim=-1)) + h = self.gru(gru_in, prev_h) + + prior_mu, prior_std = self._split(self.prior_net(h)) + + if embed is not None: + post_mu, post_std = self._split(self.post_net(torch.cat([h, embed], dim=-1))) + z = self._sample(post_mu, post_std) + return { + "h": h, "z": z, + "prior_mu": prior_mu, "prior_std": prior_std, + "post_mu": post_mu, "post_std": post_std, + } + z = self._sample(prior_mu, prior_std) + return {"h": h, "z": z, "prior_mu": prior_mu, "prior_std": prior_std} + + def observe( + self, + embeds: torch.Tensor, # (T, B, embed_dim) + actions: torch.Tensor, # (T, B) discrete actions + init: tuple[torch.Tensor, torch.Tensor] | None = None, + ) -> dict[str, torch.Tensor]: + """Teacher-forced rollout: stash all per-step distributions and samples.""" + T, B = embeds.shape[:2] + device = embeds.device + h, z = self.init_state(B, device) if init is None else init + + hs, zs = [], [] + prior_mus, prior_stds = [], [] + post_mus, post_stds = [], [] + + for t in range(T): + # Use previous action; at t=0 we plug a noop (zero action). + if t == 0: + a_prev = torch.zeros(B, dtype=torch.long, device=device) + else: + a_prev = actions[t - 1] + out = self.step(h, z, a_prev, embed=embeds[t]) + h, z = out["h"], out["z"] + hs.append(h); zs.append(z) + prior_mus.append(out["prior_mu"]); prior_stds.append(out["prior_std"]) + post_mus.append(out["post_mu"]); post_stds.append(out["post_std"]) + + stack = lambda xs: torch.stack(xs, dim=0) # noqa: E731 + return { + "h": stack(hs), "z": stack(zs), + "prior_mu": stack(prior_mus), "prior_std": stack(prior_stds), + "post_mu": stack(post_mus), "post_std": stack(post_stds), + } + + def imagine( + self, + init_h: torch.Tensor, + init_z: torch.Tensor, + actions: torch.Tensor, # (T, B) discrete OR (T, B, A) probabilities + horizon: int, + ) -> dict[str, torch.Tensor]: + """Open-loop rollout in the latent space. + + ``actions`` may be discrete indices (used by free rollouts) or already + one-hot soft probabilities (used by the actor during training). + """ + h, z = init_h, init_z + hs, zs = [], [] + for t in range(horizon): + a_t = actions[t] + if a_t.dim() == 1: + a_oh = self.one_hot_action(a_t) + else: + a_oh = a_t + out = self.step(h, z, a_oh, embed=None) + h, z = out["h"], out["z"] + hs.append(h); zs.append(z) + return {"h": torch.stack(hs, dim=0), "z": torch.stack(zs, dim=0)} + + +class RewardHead(nn.Module): + """Tiny MLP predicting the scalar reward from (h, z).""" + + def __init__(self, in_dim: int, hidden: int = 200): + super().__init__() + self.net = nn.Sequential( + nn.Linear(in_dim, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, 1), + ) + + def forward(self, h: torch.Tensor, z: torch.Tensor) -> torch.Tensor: + return self.net(torch.cat([h, z], dim=-1)).squeeze(-1) + + +class ContinueHead(nn.Module): + """Predicts P(episode continues to next step) given (h, z). + + Crucial for CartPole-pixels: without it the policy in imagination is + infinitely greedy because the reward head always predicts ~1. With it, + the lambda-return gets discounted whenever the WM thinks the pole is + about to fall, which gives the actor a real gradient toward balance. + """ + + def __init__(self, in_dim: int, hidden: int = 200): + super().__init__() + self.net = nn.Sequential( + nn.Linear(in_dim, hidden), + nn.ELU(inplace=True), + nn.Linear(hidden, 1), + ) + + def forward(self, h: torch.Tensor, z: torch.Tensor) -> torch.Tensor: + return self.net(torch.cat([h, z], dim=-1)).squeeze(-1) # raw logit + + +class WorldModel(nn.Module): + """Composite container: encoder + RSSM + decoder + reward head + continue head.""" + + def __init__(self, cfg: WMConfig): + super().__init__() + self.cfg = cfg + self.encoder = Encoder(cfg.embed_dim) + self.rssm = RSSM(cfg) + self.decoder = Decoder(cfg.deter_dim + cfg.stoch_dim) + self.reward_head = RewardHead(cfg.deter_dim + cfg.stoch_dim, cfg.hidden_dim) + self.continue_head = ContinueHead(cfg.deter_dim + cfg.stoch_dim, cfg.hidden_dim) + + # --------- forward used by training --------- # + + def compute_loss(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]: + cfg = self.cfg + obs = batch["obs"] # (T, B, 3, H, W) + act = batch["act"] # (T, B) + rew = batch["rew"] # (T, B) + term = batch["term"] # (T, B) - 1.0 at the terminal timestep + T, B = obs.shape[:2] + + embeds = self.encoder(obs) # (T, B, embed_dim) + states = self.rssm.observe(embeds, act) + h, z = states["h"], states["z"] # (T, B, *) + feat = torch.cat([h, z], dim=-1) + + # Reconstruction (Gaussian with unit variance, equivalent to MSE / 2). + recon = self.decoder(feat) # (T, B, 3, H, W) + recon_loss = F.mse_loss(recon, obs, reduction="none").sum(dim=(-1, -2, -3)) + recon_loss = recon_loss.mean() + + # Reward (Gaussian unit variance). + rew_pred = self.reward_head(h, z) + reward_loss = F.mse_loss(rew_pred, rew) + + # Continue (BCE on logits; target = 1 - terminal). + cont_logit = self.continue_head(h, z) + cont_target = 1.0 - term + continue_loss = F.binary_cross_entropy_with_logits(cont_logit, cont_target) + + # KL with balancing and free nats. + kl_q_to_p, kl_p_to_q = self._kl_balanced( + states["post_mu"], states["post_std"], + states["prior_mu"], states["prior_std"], + ) + kl_term = cfg.kl_balancing * kl_q_to_p + (1.0 - cfg.kl_balancing) * kl_p_to_q + # Free nats: clamp each dim individually before sum. + kl_term = torch.clamp(kl_term, min=cfg.free_nats) + kl_loss = kl_term.mean() + + total = ( + cfg.recon_weight * recon_loss + + cfg.reward_weight * reward_loss + + cfg.continue_weight * continue_loss + + cfg.kl_weight * kl_loss + ) + + return { + "loss": total, + "recon": recon_loss.detach(), + "reward": reward_loss.detach(), + "continue": continue_loss.detach(), + "kl": kl_loss.detach(), + "states": states, + "feat": feat, + "recon_img": recon.detach(), + } + + @staticmethod + def _kl_balanced( + mu_q: torch.Tensor, std_q: torch.Tensor, + mu_p: torch.Tensor, std_p: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Return (KL(q || sg(p)), KL(sg(q) || p)) summed across the latent dim. + + Each tensor is shape (T, B). KL between diagonal Gaussians: + KL(N(mu1,s1) || N(mu2,s2)) = log(s2/s1) + (s1^2 + (mu1-mu2)^2)/(2 s2^2) - 0.5 + """ + # stop-grad versions. + mu_p_sg = mu_p.detach() + std_p_sg = std_p.detach() + mu_q_sg = mu_q.detach() + std_q_sg = std_q.detach() + + def _kl(mu1, s1, mu2, s2): + return (torch.log(s2 / s1) + (s1.pow(2) + (mu1 - mu2).pow(2)) / (2 * s2.pow(2)) - 0.5).sum(-1) + + kl_q_to_p = _kl(mu_q, std_q, mu_p_sg, std_p_sg) # encourages posterior to stay close to fixed prior + kl_p_to_q = _kl(mu_p, std_p, mu_q_sg, std_q_sg) # encourages prior to chase the posterior + return kl_q_to_p, kl_p_to_q + + # --------- helpers used by the policy --------- # + + @torch.no_grad() + def encode_observations(self, obs: torch.Tensor) -> torch.Tensor: + return self.encoder(obs) + + @torch.no_grad() + def initial_latent(self, obs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """Encode a single observation and return (h_0, z_0). + + Uses a 1-step posterior with h initialised to zeros (sufficient for + warm-starting imagination rollouts from a sampled real state). + """ + B = obs.shape[0] + device = obs.device + h, z = self.rssm.init_state(B, device) + embed = self.encoder(obs) + # Pretend the previous action was a noop. + prev_a = torch.zeros(B, dtype=torch.long, device=device) + out = self.rssm.step(h, z, prev_a, embed=embed) + return out["h"], out["z"] + + +# ----------------------------- Random rollouts ------------------------------ # + + +def collect_random_episode(env, max_steps: int) -> tuple[list, list, list, list]: + obs_list, act_list, rew_list, term_list = [], [], [], [] + o, _ = env.reset() + for _ in range(max_steps): + a = int(env.action_space.sample()) + obs_list.append(o) + no, r, term, trunc, _ = env.step(a) + act_list.append(a); rew_list.append(r); term_list.append(bool(term)) + o = no + if term or trunc: + break + return obs_list, act_list, rew_list, term_list + + +# ----------------------------- Trainer entry -------------------------------- # + + +def train_world_model_only(cfg: WMConfig | None = None, verbose: bool = True) -> dict: + """Standalone WM training (no policy). Used by ``python -m src.world_model``.""" + cfg = cfg or WMConfig() + seed_everything(cfg.seed) + + env = make_pixel_cartpole(seed=cfg.seed) + buffer = SequenceBuffer(max_episodes=cfg.standalone_episodes * 2, seq_len=cfg.seq_len) + + for _ in range(cfg.standalone_episodes): + ep = collect_random_episode(env, cfg.standalone_max_steps_per_ep) + buffer.add_episode(*ep) + + wm = WorldModel(cfg) + opt = torch.optim.Adam(wm.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay) + rng = np.random.default_rng(cfg.seed) + + n_updates = cfg.epochs * 25 # 25 minibatches per epoch by default + losses = [] + t0 = time.time() + for step in range(n_updates): + batch = buffer.sample(cfg.batch_size, rng) + out = wm.compute_loss(batch) + opt.zero_grad() + out["loss"].backward() + torch.nn.utils.clip_grad_norm_(wm.parameters(), cfg.grad_clip) + opt.step() + losses.append({ + "loss": float(out["loss"].item()), + "recon": float(out["recon"].item()), + "reward": float(out["reward"].item()), + "kl": float(out["kl"].item()), + }) + if verbose and (step + 1) % 10 == 0: + print( + f"[WM] step={step+1:4d} total={losses[-1]['loss']:.3f} " + f"recon={losses[-1]['recon']:.3f} reward={losses[-1]['reward']:.3f} " + f"kl={losses[-1]['kl']:.3f}" + ) + elapsed = time.time() - t0 + + if verbose: + print(f"[WM] standalone training done in {elapsed:.1f}s · final recon={losses[-1]['recon']:.3f}") + + # Save WM-only checkpoint for the notebook. + data_dir = Path(__file__).resolve().parent.parent / "data" + data_dir.mkdir(exist_ok=True) + ckpt_path = data_dir / "world_model.pt" + torch.save({"model": wm.state_dict(), "cfg": cfg.__dict__, "losses": losses}, ckpt_path) + if verbose: + print(f"[WM] checkpoint saved to {ckpt_path}") + + return {"model": wm, "buffer": buffer, "losses": losses, "elapsed": elapsed} + + +if __name__ == "__main__": + train_world_model_only(WMConfig(), verbose=True)