"""11장 · RSSM 과 PlaNet — 그림만 보고 잠재 공간에서 계획해 진자 세우기.

무엇을 하나
    1. 무작위 행동으로 진자 그림 에피소드를 몇 개 모은다 (시드 에피소드).
    2. RSSM(결정 경로 h + 확률 경로 z) World Model 을 순차 ELBO 로 학습한다.
    3. 학습한 모델 안에서 CEM 으로 행동을 계획(PlaNet)해 새 에피소드를 모으고, 2 로 돌아간다.
    4. 학습 곡선, '상상 vs 진짜' 그림, 계획한 에피소드 그림을 저장한다.

실행
    python ch11_rssm_planet.py            # 본문 결과 (노트북 GPU 약 1시간 남짓. CPU 로는 하루 이상이라 GPU 권장)
    python ch11_rssm_planet.py --quick    # 연기 시험 (CPU 약 1분)

이 파일의 WorldModel · ReplayBuffer · LatentAgent · run_episode 는 12장(ch12_dreamer.py)이 그대로 가져다 쓴다.
"""

from __future__ import annotations

import argparse
import json
import os
import time
from dataclasses import asdict, dataclass

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from wm_envs import PixelPendulum


def get_device() -> str:
    if torch.cuda.is_available():
        return "cuda"
    if getattr(torch.backends, "mps", None) is not None and torch.backends.mps.is_available():
        return "mps"
    return "cpu"


# --8<-- [start:config]
@dataclass
class Config:
    # 환경
    action_repeat: int = 2  # 같은 행동을 2번 되풀이 → 한 에피소드 = 결정 100번
    # 데이터 수집 고리
    seed_episodes: int = 5  # S: 처음에 무작위 행동으로 모을 에피소드 수
    iterations: int = 100  # (학습 C 번 → 에피소드 1개 수집) 을 되풀이할 횟수
    train_steps: int = 100  # C: 수집 한 번 사이의 학습 횟수
    batch_size: int = 50  # B: 한 번에 뽑는 시퀀스 수
    seq_len: int = 50  # L: 시퀀스 길이
    # 모델 크기
    deter: int = 200  # h_t 의 크기 (GRU 은닉 상태)
    stoch: int = 30  # z_t 의 크기 (가우시안 잠재 변수)
    hidden: int = 200  # 작은 MLP 들의 너비
    depth: int = 32  # 합성곱 채널 수의 기본 단위
    min_std: float = 0.1  # z 분포의 최소 표준편차
    # 학습
    lr: float = 6e-4
    eps: float = 1e-4  # Adam 의 ε
    grad_clip: float = 100.0
    free_nats: float = 3.0  # KL 이 이 값보다 작으면 KL 로는 학습하지 않는다
    kl_scale: float = 1.0
    reward_scale: float = 0.1  # 보상 크기를 [-3.3, 0] 정도로 줄여서 학습한다
    # CEM 계획 (PlaNet 원 논문 값)
    plan_horizon: int = 12  # H
    plan_candidates: int = 1000  # J
    plan_iters: int = 10  # I
    plan_elites: int = 100  # K
    explore_noise: float = 0.3  # 수집할 때 행동에 더하는 가우시안 잡음
    # 평가
    eval_every: int = 10
    eval_episodes: int = 3
# --8<-- [end:config]


# --8<-- [start:preprocess]
def preprocess(obs: torch.Tensor) -> torch.Tensor:
    """uint8 그림(0~255) → 실수 [-0.5, 0.5]. 가운데를 0 에 맞추면 학습이 안정된다."""
    return obs.float() / 255.0 - 0.5
# --8<-- [end:preprocess]


# --8<-- [start:buffer]
class ReplayBuffer:
    """에피소드를 통째로 모아 두고, 길이 L 의 조각을 무작위로 뽑아 준다.

    에피소드 하나를 시각 t = 0..T 로 맞춰 저장한다 (관측이 T+1 개).
      obs[t]         : 시각 t 의 그림 o_t
      prev_action[t] : o_t 에 오기 직전에 한 행동 a_{t-1}  (t=0 이면 0)
      reward[t]      : o_t 에 도착하며 받은 보상 r_t        (t=0 이면 없음 → 0, 학습에서 뺀다)
      first[t]       : 에피소드의 첫 시각이면 1
    """

    def __init__(self, device: str):
        self.device = device
        self.episodes: list[dict] = []

    def add(self, ep: dict):
        T = len(ep["action"])
        act_dim = ep["action"].shape[1]
        prev_action = np.concatenate([np.zeros((1, act_dim), np.float32), ep["action"]], 0)
        reward = np.concatenate([np.zeros(1, np.float32), ep["reward"]], 0)
        first = np.zeros(T + 1, np.float32)
        first[0] = 1.0
        self.episodes.append(dict(obs=ep["obs"], prev_action=prev_action, reward=reward, first=first))

    @property
    def num_steps(self) -> int:
        return sum(len(e["reward"]) - 1 for e in self.episodes)

    def sample(self, batch_size: int, seq_len: int, rng: np.random.Generator) -> dict:
        chunks = {k: [] for k in ("obs", "prev_action", "reward", "first")}
        for _ in range(batch_size):
            ep = self.episodes[rng.integers(len(self.episodes))]
            start = rng.integers(0, len(ep["reward"]) - seq_len + 1)
            for k in chunks:
                chunks[k].append(ep[k][start : start + seq_len])
        out = {k: torch.as_tensor(np.stack(v), device=self.device) for k, v in chunks.items()}
        out["obs"] = preprocess(out["obs"])  # (B, L, 64, 64)
        return out
# --8<-- [end:buffer]


# --8<-- [start:encoder]
class Encoder(nn.Module):
    """그림 o_t (64×64) → 특징 벡터 e_t (1024). 합성곱 4층, 층마다 크기가 약 절반."""

    def __init__(self, depth: int = 32):
        super().__init__()
        d = depth
        self.net = nn.Sequential(
            nn.Conv2d(1, d, 4, stride=2), nn.ReLU(),  # 64 → 31
            nn.Conv2d(d, 2 * d, 4, stride=2), nn.ReLU(),  # 31 → 14
            nn.Conv2d(2 * d, 4 * d, 4, stride=2), nn.ReLU(),  # 14 → 6
            nn.Conv2d(4 * d, 8 * d, 4, stride=2), nn.ReLU(),  # 6 → 2
            nn.Flatten(),  # 8d × 2 × 2 = 32d
        )
        self.out_dim = 32 * d

    def forward(self, obs: torch.Tensor) -> torch.Tensor:
        lead = obs.shape[:-2]  # 앞쪽 (B, L) 등 아무 모양이나 받는다
        x = self.net(obs.reshape(-1, 1, 64, 64))
        return x.reshape(*lead, self.out_dim)
# --8<-- [end:encoder]


# --8<-- [start:decoder]
class Decoder(nn.Module):
    """특징 [h_t, z_t] → 그림의 평균 ô_t (64×64). 전치 합성곱 4층으로 1 → 5 → 13 → 30 → 64."""

    def __init__(self, feat_dim: int, depth: int = 32):
        super().__init__()
        d = depth
        self.fc = nn.Linear(feat_dim, 32 * d)
        self.net = nn.Sequential(
            nn.ConvTranspose2d(32 * d, 4 * d, 5, stride=2), nn.ReLU(),  # 1 → 5
            nn.ConvTranspose2d(4 * d, 2 * d, 5, stride=2), nn.ReLU(),  # 5 → 13
            nn.ConvTranspose2d(2 * d, d, 6, stride=2), nn.ReLU(),  # 13 → 30
            nn.ConvTranspose2d(d, 1, 6, stride=2),  # 30 → 64
        )
        self.depth = d

    def forward(self, feat: torch.Tensor) -> torch.Tensor:
        lead = feat.shape[:-1]
        x = self.fc(feat).reshape(-1, 32 * self.depth, 1, 1)
        return self.net(x).reshape(*lead, 64, 64)
# --8<-- [end:decoder]


def mlp(inp: int, hidden: int, out: int, layers: int = 2) -> nn.Sequential:
    mods, d = [], inp
    for _ in range(layers):
        mods += [nn.Linear(d, hidden), nn.ELU()]
        d = hidden
    mods.append(nn.Linear(d, out))
    return nn.Sequential(*mods)


# --8<-- [start:gauss-kl]
def gaussian_kl(mean_q, std_q, mean_p, std_p):
    """대각 가우시안 두 개의 KL(q ‖ p), 차원별 값 (3장에서 유도한 닫힌 꼴).

    KL = log(σ_p/σ_q) + (σ_q² + (μ_q − μ_p)²) / (2σ_p²) − 1/2
    """
    return (
        torch.log(std_p / std_q)
        + (std_q**2 + (mean_q - mean_p) ** 2) / (2 * std_p**2)
        - 0.5
    )
# --8<-- [end:gauss-kl]


# --8<-- [start:rssm]
class RSSM(nn.Module):
    """순환 상태 공간 모델 (Recurrent State-Space Model).

    결정 경로   h_t = f(h_{t-1}, z_{t-1}, a_{t-1})      ← GRU
    사전(prior) p(z_t | h_t)        = N(μ, σ²)        ← 그림을 보기 전의 예측
    사후(post)  q(z_t | h_t, e_t)   = N(μ', σ'²)      ← 그림 특징 e_t 까지 본 추측
    """

    def __init__(self, act_dim: int, embed_dim: int, deter=200, stoch=30, hidden=200, min_std=0.1):
        super().__init__()
        self.deter, self.stoch, self.min_std = deter, stoch, min_std
        self.inp = nn.Linear(stoch + act_dim, hidden)  # [z_{t-1}, a_{t-1}] → GRU 입력
        self.gru = nn.GRUCell(hidden, deter)
        self.prior_net = mlp(deter, hidden, 2 * stoch, layers=1)
        self.post_net = mlp(deter + embed_dim, hidden, 2 * stoch, layers=1)

    def initial(self, batch: int, device) -> tuple[torch.Tensor, torch.Tensor]:
        return torch.zeros(batch, self.deter, device=device), torch.zeros(batch, self.stoch, device=device)

    def _dist(self, x: torch.Tensor):
        mean, std = x.chunk(2, dim=-1)
        std = F.softplus(std) + self.min_std  # 표준편차는 늘 양수, 그리고 min_std 이상
        return mean, std

    def img_step(self, h, z, action, sample: bool = True):
        """그림 없이 한 스텝 상상한다: (h_{t-1}, z_{t-1}, a_{t-1}) → h_t, z_t ~ p(z_t | h_t)."""
        x = F.elu(self.inp(torch.cat([z, action], -1)))
        h = self.gru(x, h)
        mean, std = self._dist(self.prior_net(h))
        z = mean + std * torch.randn_like(std) if sample else mean  # 재매개변수화
        return h, z, mean, std

    def obs_step(self, h, z, action, embed):
        """그림을 보며 한 스텝: 사전으로 h_t 를 만든 뒤, 그림 특징 e_t 로 z_t 를 고쳐 잡는다."""
        h, _, prior_mean, prior_std = self.img_step(h, z, action)
        post_mean, post_std = self._dist(self.post_net(torch.cat([h, embed], -1)))
        z = post_mean + post_std * torch.randn_like(post_std)
        return h, z, (prior_mean, prior_std), (post_mean, post_std)

    def observe(self, embeds, prev_actions, h=None, z=None):
        """시퀀스 전체를 시간 순서대로 펼친다. embeds (B, L, E), prev_actions (B, L, A)."""
        B, L = embeds.shape[:2]
        if h is None:
            h, z = self.initial(B, embeds.device)
        out = {k: [] for k in ("h", "z", "prior_mean", "prior_std", "post_mean", "post_std")}
        for t in range(L):
            h, z, (pm, ps), (qm, qs) = self.obs_step(h, z, prev_actions[:, t], embeds[:, t])
            for k, v in zip(out, (h, z, pm, ps, qm, qs)):
                out[k].append(v)
        return {k: torch.stack(v, dim=1) for k, v in out.items()}  # 모두 (B, L, ·)
# --8<-- [end:rssm]


# --8<-- [start:world-model]
class WorldModel(nn.Module):
    def __init__(self, cfg: Config, act_dim: int = 1):
        super().__init__()
        self.cfg = cfg
        self.encoder = Encoder(cfg.depth)
        self.rssm = RSSM(act_dim, self.encoder.out_dim, cfg.deter, cfg.stoch, cfg.hidden, cfg.min_std)
        self.feat_dim = cfg.deter + cfg.stoch
        self.decoder = Decoder(self.feat_dim, cfg.depth)
        self.reward = mlp(self.feat_dim, cfg.hidden, 1, layers=2)

    @staticmethod
    def feat(h, z):
        return torch.cat([h, z], -1)

    def loss(self, batch: dict):
        """순차 ELBO 의 음수 = 재구성 + 보상 + KL. 12장이 쓰도록 사후 상태도 돌려준다."""
        cfg = self.cfg
        obs = batch["obs"]  # (B, L, 64, 64)
        embed = self.encoder(obs)  # (B, L, 1024)
        states = self.rssm.observe(embed, batch["prev_action"])
        feat = self.feat(states["h"], states["z"])  # (B, L, 230)

        # ① 재구성: -log p(o_t | h_t, z_t), 분산 1 가우시안 → ½·Σ(o - ô)² (+ 상수)
        recon = self.decoder(feat)
        recon_loss = 0.5 * ((recon - obs) ** 2).sum(dim=(-2, -1)).mean()

        # ② 보상: -log p(r_t | h_t, z_t) → ½·(r - r̂)². 에피소드 첫 시각은 보상이 없으니 뺀다.
        target_r = batch["reward"] * cfg.reward_scale
        mask = 1.0 - batch["first"]
        pred_r = self.reward(feat).squeeze(-1)
        reward_loss = (0.5 * (pred_r - target_r) ** 2 * mask).sum() / mask.sum()

        # ③ KL(q(z_t | h_t, o_t) ‖ p(z_t | h_t)), 자유 내트: 평균 KL 이 free_nats 보다 작으면 기울기 0
        kl = gaussian_kl(states["post_mean"], states["post_std"], states["prior_mean"], states["prior_std"])
        kl = kl.sum(-1).mean()  # z 의 차원끼리는 더하고, 배치 · 시간으로는 평균
        kl_loss = torch.clamp(kl, min=cfg.free_nats)

        loss = recon_loss + reward_loss + cfg.kl_scale * kl_loss
        metrics = dict(recon=recon_loss.item(), reward=reward_loss.item(), kl=kl.item())
        return loss, metrics, states
# --8<-- [end:world-model]


# --8<-- [start:cem]
@torch.no_grad()
def cem_plan(wm: WorldModel, h, z, cfg: Config, act_dim: int = 1):
    """잠재 공간에서 CEM 으로 앞으로 H 스텝의 행동열을 고르고, 첫 행동만 돌려준다.

    h, z: 지금의 믿음 상태 (1, ·). 행동은 [-1, 1] 로 정규화한 값.
    """
    H, J, K = cfg.plan_horizon, cfg.plan_candidates, cfg.plan_elites
    mean = torch.zeros(H, act_dim, device=h.device)
    std = torch.ones(H, act_dim, device=h.device)
    for _ in range(cfg.plan_iters):
        # ① 후보 J 개를 N(mean, std²) 에서 뽑는다: (J, H, A)
        actions = (mean + std * torch.randn(J, H, act_dim, device=h.device)).clamp(-1, 1)
        # ② 모델 안에서 J 개를 한꺼번에 굴려 보상 합을 잰다
        hj, zj = h.expand(J, -1), z.expand(J, -1)
        total = torch.zeros(J, device=h.device)
        for t in range(H):
            hj, zj, _, _ = wm.rssm.img_step(hj, zj, actions[:, t])
            total += wm.reward(wm.feat(hj, zj)).squeeze(-1)
        # ③ 보상 합이 가장 큰 K 개(정예)를 골라 평균 · 표준편차를 다시 맞춘다
        elite = actions[total.topk(K).indices]  # (K, H, A)
        mean, std = elite.mean(0), elite.std(0)
    return mean[0:1]  # (1, A): 계획의 첫 행동
# --8<-- [end:cem]


# --8<-- [start:agent]
class LatentAgent:
    """그림을 하나씩 받으며 믿음 상태 (h, z) 를 갱신하고, choose() 로 행동을 고른다."""

    def __init__(self, wm: WorldModel, choose, act_dim: int = 1):
        self.wm, self.choose, self.act_dim = wm, choose, act_dim
        self.device = next(wm.parameters()).device

    def reset(self):
        self.h, self.z = self.wm.rssm.initial(1, self.device)
        self.prev_action = torch.zeros(1, self.act_dim, device=self.device)

    @torch.no_grad()
    def act(self, obs: np.ndarray, explore_noise: float = 0.0) -> np.ndarray:
        o = preprocess(torch.as_tensor(obs, device=self.device))[None]  # (1, 64, 64)
        embed = self.wm.encoder(o)
        self.h, self.z, _, _ = self.wm.rssm.obs_step(self.h, self.z, self.prev_action, embed)
        a = self.choose(self.h, self.z)  # (1, A), [-1, 1]
        if explore_noise > 0:
            a = (a + explore_noise * torch.randn_like(a)).clamp(-1, 1)
        self.prev_action = a
        return a[0].cpu().numpy()


def run_episode(env: PixelPendulum, agent: LatentAgent | None, explore_noise=0.0, rng=None, record=False):
    """에피소드 하나. agent 가 None 이면 무작위 행동. 행동은 [-1, 1] 로 저장하고 환경에는 ×2 로 준다."""
    obs = env.reset()
    if agent is not None:
        agent.reset()
    obs_list, act_list, rew_list, states = [obs], [], [], [env.state()]
    done = False
    while not done:
        if agent is None:
            a = rng.uniform(-1, 1, size=(1,)).astype(np.float32)
        else:
            a = agent.act(obs, explore_noise).astype(np.float32)
        obs, r, done = env.step(a * env.max_torque)
        obs_list.append(obs)
        act_list.append(a)
        rew_list.append(r)
        if record:
            states.append(env.state())
    ep = dict(obs=np.stack(obs_list), action=np.stack(act_list), reward=np.asarray(rew_list, np.float32))
    if record:
        ep["state"] = np.stack(states)
    return ep
# --8<-- [end:agent]


def train_world_model(wm, opt, buffer, cfg, rng, steps):
    logs = []
    for _ in range(steps):
        batch = buffer.sample(cfg.batch_size, cfg.seq_len, rng)
        loss, metrics, _ = wm.loss(batch)
        opt.zero_grad(set_to_none=True)
        loss.backward()
        nn.utils.clip_grad_norm_(wm.parameters(), cfg.grad_clip)
        opt.step()
        logs.append(metrics)
    return {k: float(np.mean([m[k] for m in logs])) for k in logs[0]}


# ── 그림 ─────────────────────────────────────────────────────────


@torch.no_grad()
def open_loop_figure(wm, ep, path, context=5, horizon=30, every=3, title=""):
    """앞 context 장은 그림을 보며(사후), 그다음 horizon 스텝은 행동만 주고 상상(사전)한다."""
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    device = next(wm.parameters()).device
    obs = preprocess(torch.as_tensor(ep["obs"][: context + horizon], device=device))[None]  # (1, T, 64, 64)
    prev_act = np.concatenate([np.zeros((1, 1), np.float32), ep["action"]], 0)[: context + horizon]
    prev_act = torch.as_tensor(prev_act, device=device)[None]
    states = wm.rssm.observe(wm.encoder(obs[:, :context]), prev_act[:, :context])
    h, z = states["h"][:, -1], states["z"][:, -1]
    recon_ctx = wm.decoder(wm.feat(states["h"], states["z"]))[0]
    imagined = []
    for t in range(context, context + horizon):
        h, z, _, _ = wm.rssm.img_step(h, z, prev_act[:, t], sample=False)
        imagined.append(wm.decoder(wm.feat(h, z))[0])
    model = torch.cat([recon_ctx, torch.stack(imagined)], 0).cpu().numpy() + 0.5
    truth = obs[0].cpu().numpy() + 0.5
    idx = list(range(0, context + horizon, every))
    fig, axes = plt.subplots(2, len(idx), figsize=(len(idx) * 0.9, 2.3))
    for j, t in enumerate(idx):
        for i, img in enumerate((truth, model)):
            ax = axes[i, j]
            ax.imshow(np.clip(img[t], 0, 1), cmap="gray", vmin=0, vmax=1)
            ax.set_xticks([])
            ax.set_yticks([])
            for s in ax.spines.values():
                s.set_edgecolor("#2f6fdb" if t < context else "#b7620c")
                s.set_linewidth(2)
        axes[0, j].set_title(f"t={t}", fontsize=8)
    axes[0, 0].set_ylabel("real", fontsize=9)
    axes[1, 0].set_ylabel("model", fontsize=9)
    if title:
        fig.suptitle(title, fontsize=10)
    fig.tight_layout()
    fig.savefig(path, dpi=110, facecolor="white")
    plt.close(fig)


def episode_figure(ep, path, title="", every=8):
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    T = len(ep["obs"])
    idx = list(range(0, T, every))[:13]
    fig = plt.figure(figsize=(10, 3.4))
    gs = fig.add_gridspec(2, len(idx), height_ratios=[1, 1.3])
    for j, t in enumerate(idx):
        ax = fig.add_subplot(gs[0, j])
        ax.imshow(ep["obs"][t], cmap="gray", vmin=0, vmax=255)
        ax.set_title(f"t={t}", fontsize=8)
        ax.axis("off")
    ax = fig.add_subplot(gs[1, :])
    th = np.arctan2(ep["state"][:, 1], ep["state"][:, 0])
    ax.plot(np.abs(th), color="#2f6fdb", label="|angle| (0 = upright)")
    ax2 = ax.twinx()
    ax2.step(np.arange(len(ep["action"])), ep["action"][:, 0] * 2, color="#b7620c", alpha=0.6, where="post", label="torque")
    ax.set_xlabel("decision step (action repeat 2)")
    ax.set_ylabel("|angle| [rad]")
    ax2.set_ylabel("torque")
    ax.set_ylim(0, np.pi + 0.1)
    ax2.set_ylim(-2.2, 2.2)
    lines = ax.get_legend_handles_labels()[0] + ax2.get_legend_handles_labels()[0]
    labels = ax.get_legend_handles_labels()[1] + ax2.get_legend_handles_labels()[1]
    ax.legend(lines, labels, loc="upper right", fontsize=8)
    ax.set_title(title, fontsize=10)
    fig.tight_layout()
    fig.savefig(path, dpi=110, facecolor="white")
    plt.close(fig)


def curves_figure(log, path, random_return, title="PlaNet"):
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.4))
    ax = axes[0]
    ax.plot(log["train_steps_env"], log["train_return"], ".", color="#9aa8b4", ms=4, label="collect (with noise)")
    ax.plot(log["eval_steps_env"], log["eval_return"], "o-", color="#2f6fdb", label="eval (no noise)")
    ax.axhline(random_return, color="#b03a6a", ls="--", label="random policy")
    ax.set_xlabel("environment steps")
    ax.set_ylabel("episode return (200 steps)")
    ax.set_title(f"{title}: return", fontsize=10)
    ax.legend(fontsize=8)
    ax = axes[1]
    it = np.arange(len(log["recon"]))
    ax.plot(it, log["recon"], label="recon")
    ax.plot(it, np.array(log["reward"]) * 100, label="reward x100")
    ax.plot(it, log["kl"], label="KL (nats)")
    ax.axhline(3.0, color="gray", ls=":", lw=1)
    ax.set_yscale("log")
    ax.set_xlabel("iteration (100 train steps each)")
    ax.set_title("world model losses", fontsize=10)
    ax.legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(path, dpi=110, facecolor="white")
    plt.close(fig)


def random_baseline(cfg, seed, episodes=10):
    env = PixelPendulum(seed=seed + 999, action_repeat=cfg.action_repeat)
    rng = np.random.default_rng(seed + 999)
    return float(np.mean([run_episode(env, None, rng=rng)["reward"].sum() for _ in range(episodes)]))


# --8<-- [start:main]
def main():
    p = argparse.ArgumentParser()
    p.add_argument("--quick", action="store_true", help="아주 작은 설정으로 1분 안팎에 끝까지 돌려 본다")
    p.add_argument("--iterations", type=int, default=None)
    p.add_argument("--batch-size", type=int, default=None, help="CPU 에서 느리면 16 처럼 줄인다")
    p.add_argument("--fig-dir", default="figures")
    p.add_argument("--out", default="ch11_out", help="모델 · 기록을 저장할 폴더")
    p.add_argument("--seed", type=int, default=0)
    args = p.parse_args()

    cfg = Config()
    if args.quick:
        cfg = Config(seed_episodes=2, iterations=2, train_steps=5, batch_size=8, seq_len=20,
                     plan_candidates=100, plan_iters=3, plan_elites=10, eval_every=2, eval_episodes=1)
    if args.iterations is not None:
        cfg.iterations = args.iterations
    if args.batch_size is not None:
        cfg.batch_size = args.batch_size
    torch.manual_seed(args.seed)
    rng = np.random.default_rng(args.seed)
    device = get_device()
    torch.backends.cudnn.benchmark = True  # 합성곱 크기가 늘 같으므로 가장 빠른 방법을 골라 둔다
    os.makedirs(args.fig_dir, exist_ok=True)
    os.makedirs(args.out, exist_ok=True)
    print(f"device={device}", asdict(cfg))

    env = PixelPendulum(seed=args.seed, action_repeat=cfg.action_repeat)
    buffer = ReplayBuffer(device)
    for _ in range(cfg.seed_episodes):  # ① 무작위 시드 에피소드
        buffer.add(run_episode(env, None, rng=rng))
    random_return = random_baseline(cfg, args.seed, episodes=3 if args.quick else 10)
    print(f"random policy return: {random_return:.1f}")

    wm = WorldModel(cfg).to(device)
    opt = torch.optim.Adam(wm.parameters(), lr=cfg.lr, eps=cfg.eps)
    agent = LatentAgent(wm, lambda h, z: cem_plan(wm, h, z, cfg))

    log = {k: [] for k in ("recon", "reward", "kl", "train_return", "train_steps_env",
                           "eval_return", "eval_steps_env", "plan_ms")}
    start = time.time()
    for it in range(1, cfg.iterations + 1):
        m = train_world_model(wm, opt, buffer, cfg, rng, cfg.train_steps)  # ② 모델 학습 C 번
        t0 = time.time()
        ep = run_episode(env, agent, explore_noise=cfg.explore_noise)  # ③ 계획 + 잡음으로 수집
        plan_ms = (time.time() - t0) / len(ep["action"]) * 1000
        buffer.add(ep)
        for k in m:
            log[k].append(m[k])
        log["train_return"].append(float(ep["reward"].sum()))
        log["train_steps_env"].append(buffer.num_steps * cfg.action_repeat)
        log["plan_ms"].append(plan_ms)
        msg = (f"it {it:3d} | env steps {buffer.num_steps * cfg.action_repeat:6d} | recon {m['recon']:7.2f} "
               f"reward {m['reward']:.4f} kl {m['kl']:5.2f} | return {ep['reward'].sum():8.1f} "
               f"| plan {plan_ms:5.1f} ms/action | {time.time() - start:6.0f}s")
        if it % cfg.eval_every == 0 or it == cfg.iterations:
            rets = [run_episode(env, agent)["reward"].sum() for _ in range(cfg.eval_episodes)]
            log["eval_return"].append(float(np.mean(rets)))
            log["eval_steps_env"].append(buffer.num_steps * cfg.action_repeat)
            msg += f" | eval {np.mean(rets):8.1f}"
        print(msg, flush=True)

    torch.save(wm.state_dict(), os.path.join(args.out, "world_model.pt"))
    with open(os.path.join(args.out, "log.json"), "w") as f:
        json.dump(dict(log=log, random_return=random_return, config=asdict(cfg)), f)

    # ④ 최종 평가: 처음 보는 시작 상태 10 개 (잡음 없이)
    test_env = PixelPendulum(seed=args.seed + 123, action_repeat=cfg.action_repeat)
    final = [run_episode(test_env, agent)["reward"].sum() for _ in range(3 if args.quick else 10)]
    print(f"final eval over {len(final)} episodes: mean {np.mean(final):.1f}, std {np.std(final):.1f}, "
          f"min {np.min(final):.1f}, max {np.max(final):.1f}")

    # ⑤ 그림: 학습 곡선, 상상 vs 진짜, 계획한 에피소드
    #    그림용 에피소드는 같은 시드의 평가 환경을 새로 만들어 그 첫 에피소드를 쓴다 (④ 의 첫 번째와 같은 시작 상태).
    curves_figure(log, os.path.join(args.fig_dir, "ch11-curves.png"), random_return)
    fig_env = PixelPendulum(seed=args.seed + 123, action_repeat=cfg.action_repeat)
    ep = run_episode(fig_env, agent, record=True)
    open_loop_figure(wm, ep, os.path.join(args.fig_dir, "ch11-open-loop.png"))
    episode_figure(ep, os.path.join(args.fig_dir, "ch11-planet-episode.png"),
                   title=f"PlaNet (CEM in latent space), return {ep['reward'].sum():.0f}")
    print(f"done in {time.time() - start:.0f}s, final test return {ep['reward'].sum():.1f}")
# --8<-- [end:main]


if __name__ == "__main__":
    main()
