"""9장 실습: 혼합 밀도 네트워크(MDN)와 MDN-RNN.

하는 일
  1. 장난감 문제: 답이 여러 개인 문제에서 '평균 하나(MSE)' 와 'MDN' 을 비교한다.
  2. 8장의 VAE 로 진자 에피소드를 잠재 벡터 z 의 시퀀스로 바꾼다.
  3. MDN-RNN(LSTM + 혼합 가우시안 머리 + 보상 머리)이 (z_t, a_t) 로 z_{t+1}, r_t 를 예측하도록 학습한다.
  4. 모델이 자기 예측을 다시 입력으로 받아 꾸는 '꿈' 을 VAE 디코더로 그림으로 그려 진짜와 비교한다.
  5. 10장이 쓰도록 ch09_mdnrnn.pt, ch09_latents.npz 를 저장한다.

먼저 8장을 실행해 ch08_vae.pt, ch08_episodes.npz 를 만들어 두어야 한다.

실행
  python ch09_mdn_rnn.py            # 본문 결과 (노트북 GPU 약 2 – 3분 / CPU 4스레드 약 20분)
  python ch09_mdn_rnn.py --quick    # 연기 시험
"""

from __future__ import annotations

import argparse
import math
import os
import time

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from ch08_vae import encode_frames, get_device, load_vae

LOG_2PI = math.log(2.0 * math.pi)


# --8<-- [start:mdn-loss]
def mdn_log_prob(y, log_pi, mu, log_sigma):
    """혼합 가우시안의 로그 가능도 log p(y) 를 log-sum-exp 로 안정하게 계산한다.

    y         : (..., D)      정답
    log_pi    : (..., D, K)   혼합 가중치의 로그 (log_softmax 결과)
    mu        : (..., D, K)   성분별 평균
    log_sigma : (..., D, K)   성분별 로그 표준편차
    반환       : (..., D)      차원마다의 log p(y_d)
    """
    y = y.unsqueeze(-1)  # (..., D, 1) → K 개 성분과 나란히 비교
    # 성분 k 의 로그 정규 밀도: -log σ - ½ log 2π - ½ ((y-μ)/σ)²
    log_normal = -log_sigma - 0.5 * LOG_2PI - 0.5 * ((y - mu) / log_sigma.exp()) ** 2
    # log Σ_k π_k N_k = logsumexp_k (log π_k + log N_k)
    return torch.logsumexp(log_pi + log_normal, dim=-1)
# --8<-- [end:mdn-loss]


# --8<-- [start:mdn-sample]
def mdn_sample(log_pi, mu, log_sigma, tau: float = 1.0):
    """온도 τ 로 혼합 가우시안에서 표본을 뽑는다 (Ha & Schmidhuber 의 방식).

    1) 성분 고르기: 확률 ∝ exp(log π_k / τ)   (τ 가 크면 고르게, 작으면 가장 큰 성분만)
    2) 그 성분에서 뽑기: μ_k + σ_k · √τ · ε
    τ = 0 이면 가장 큰 성분의 평균을 그대로 돌려준다 (잡음 없는 꿈).
    """
    if tau <= 1e-6:
        k = log_pi.argmax(dim=-1, keepdim=True)
        return mu.gather(-1, k).squeeze(-1)
    k = torch.distributions.Categorical(logits=log_pi / tau).sample().unsqueeze(-1)  # (..., D, 1)
    mu_k = mu.gather(-1, k).squeeze(-1)
    sigma_k = log_sigma.gather(-1, k).squeeze(-1).exp()
    return mu_k + sigma_k * math.sqrt(tau) * torch.randn_like(mu_k)
# --8<-- [end:mdn-sample]


# ── 1. 장난감 문제: 답이 둘 이상일 때 ─────────────────────────


# --8<-- [start:toy]
class ToyMDN(nn.Module):
    """입력 x (1차원) → 출력 y 의 혼합 가우시안 (K 개 성분)."""

    def __init__(self, n_mix: int = 5, hidden: int = 64):
        super().__init__()
        self.body = nn.Sequential(nn.Linear(1, hidden), nn.Tanh(), nn.Linear(hidden, hidden), nn.Tanh())
        self.head = nn.Linear(hidden, 3 * n_mix)  # 성분마다 (가중치 로짓, 평균, 로그 표준편차)

    def forward(self, x):
        logit_pi, mu, log_sigma = self.head(self.body(x)).chunk(3, dim=-1)  # 각각 (B, K)
        log_pi = F.log_softmax(logit_pi, dim=-1)  # 합이 1 이 되도록
        return log_pi.unsqueeze(1), mu.unsqueeze(1), log_sigma.clamp(-7, 3).unsqueeze(1)  # (B, 1, K)
# --8<-- [end:toy]


def toy_experiment(fig_dir, device, steps=4000):
    """y = x + 0.3 sin(2πx) 를 뒤집어 'y 를 보고 x 맞히기'. 한 y 에 x 가 여럿이다."""
    rng = np.random.default_rng(0)
    n = 2000
    x_true = rng.uniform(0, 1, n)
    y_obs = x_true + 0.3 * np.sin(2 * np.pi * x_true) + rng.uniform(-0.1, 0.1, n)
    inp = torch.tensor(y_obs, dtype=torch.float32, device=device).unsqueeze(1)  # 입력 = y
    tgt = torch.tensor(x_true, dtype=torch.float32, device=device).unsqueeze(1)  # 정답 = x

    mlp = nn.Sequential(nn.Linear(1, 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 1)).to(device)
    mdn = ToyMDN().to(device)
    opt_a = torch.optim.Adam(mlp.parameters(), lr=3e-3)
    opt_b = torch.optim.Adam(mdn.parameters(), lr=3e-3)
    for step in range(steps):
        loss_a = F.mse_loss(mlp(inp), tgt)  # 평균 하나를 맞히는 회귀
        opt_a.zero_grad()
        loss_a.backward()
        opt_a.step()
        loss_b = -mdn_log_prob(tgt, *mdn(inp)).mean()  # 혼합 가우시안의 음의 로그 가능도
        opt_b.zero_grad()
        loss_b.backward()
        opt_b.step()
    print(f"[장난감] MSE 회귀 손실 {loss_a.item():.4f} | MDN 음의 로그 가능도 {loss_b.item():.3f}")

    with torch.no_grad():
        grid = torch.linspace(-0.1, 1.1, 300, device=device).unsqueeze(1)
        pred = mlp(grid).cpu().numpy()[:, 0]
        log_pi, mu, log_sigma = mdn(grid)
        samples = torch.stack([mdn_sample(log_pi, mu, log_sigma, 1.0)[:, 0] for _ in range(6)]).cpu().numpy()

    fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.8), sharey=True)
    for ax in axes:
        ax.scatter(y_obs, x_true, s=3, color="#9aa4b1", label="data")
        ax.set_xlabel("input y")
    axes[0].plot(grid.cpu().numpy()[:, 0], pred, color="#d1495b", lw=2.5, label="MSE regression")
    axes[0].set_title("single prediction (MSE): averages the branches")
    axes[0].set_ylabel("target x")
    g = grid.cpu().numpy()[:, 0]
    for s in samples:
        axes[1].scatter(g, s, s=3, color="#2f6fdb")
    axes[1].scatter([], [], s=8, color="#2f6fdb", label="MDN samples")
    axes[1].set_title("mixture density network: keeps every branch")
    for ax in axes:
        ax.legend(loc="upper left", fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch09-toy-mdn.png"), dpi=110, facecolor="white")
    plt.close(fig)


# ── 2. MDN-RNN ───────────────────────────────────────────


# --8<-- [start:model]
class MDNRNN(nn.Module):
    """M 모델: LSTM 이 (z_t, a_t) 를 읽고 z_{t+1} 의 혼합 가우시안과 보상 r_t 를 내놓는다.

    z 의 각 차원 d 마다 따로 K 개 성분의 혼합을 쓴다 (Ha & Schmidhuber 와 같다).
    """

    def __init__(self, z_dim: int = 32, act_dim: int = 1, hidden: int = 256, n_mix: int = 5):
        super().__init__()
        self.z_dim, self.act_dim, self.hidden, self.n_mix = z_dim, act_dim, hidden, n_mix
        self.lstm = nn.LSTM(z_dim + act_dim, hidden, batch_first=True)
        self.mdn_head = nn.Linear(hidden, 3 * z_dim * n_mix)  # 차원 · 성분마다 (로짓, μ, log σ)
        self.reward_head = nn.Linear(hidden, 1)

    def heads(self, out):
        """LSTM 출력 (B, T, H) → 혼합 매개변수 각각 (B, T, D, K), 보상 (B, T)."""
        B, T, _ = out.shape
        params = self.mdn_head(out).view(B, T, 3, self.z_dim, self.n_mix)
        logit_pi, mu, log_sigma = params.unbind(dim=2)
        log_pi = F.log_softmax(logit_pi, dim=-1)  # 성분 K 개에 대해 합 1
        log_sigma = log_sigma.clamp(-7.0, 2.0)  # 너무 작거나 큰 σ 막기 (수치 안정)
        reward = self.reward_head(out).squeeze(-1)
        return log_pi, mu, log_sigma, reward

    def forward(self, z, a, state=None):
        """z: (B, T, D), a: (B, T, A) → 혼합 매개변수, 보상, 새 LSTM 상태 (h, c)."""
        out, state = self.lstm(torch.cat([z, a], dim=-1), state)  # out: (B, T, H)
        return (*self.heads(out), state)

    def initial_state(self, batch: int, device):
        zeros = torch.zeros(1, batch, self.hidden, device=device)
        return (zeros, zeros.clone())
# --8<-- [end:model]


# --8<-- [start:train]
def train_mdnrnn(mu, logvar, actions, rewards, hidden=256, n_mix=5, steps=6000, seq_len=64, batch=64,
                 lr=1e-3, reward_weight=1.0, device="cpu", log=print):
    """mu, logvar: (N, T+1, D) VAE 인코딩, actions: (N, T, 1), rewards: (N, T)."""
    N, T1, D = mu.shape
    T = T1 - 1
    model = MDNRNN(D, actions.shape[-1], hidden, n_mix).to(device)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    mu_t = torch.as_tensor(mu, device=device)
    std_t = torch.as_tensor(np.exp(0.5 * logvar), device=device)
    act_t = torch.as_tensor(actions, device=device)
    rew_t = torch.as_tensor(rewards, device=device)
    n_train = int(N * 0.9)  # 마지막 10% 에피소드는 검증용
    history = []
    for step in range(1, steps + 1):
        ep = torch.randint(0, n_train, (batch,), device=device)
        t0 = torch.randint(0, T - seq_len + 1, (batch,), device=device)
        idx = t0[:, None] + torch.arange(seq_len + 1, device=device)  # (B, L+1)
        # 매번 q(z|o) 에서 새로 뽑는다: z = μ + σ ε  (모델이 z 의 흔들림에 강해진다)
        z = mu_t[ep[:, None], idx] + std_t[ep[:, None], idx] * torch.randn(batch, seq_len + 1, D, device=device)
        a = act_t[ep[:, None], idx[:, :-1]]  # (B, L, 1)
        r = rew_t[ep[:, None], idx[:, :-1]]  # (B, L)
        # 교사 강요: 입력은 언제나 '진짜' z_t. 출력으로 z_{t+1} 과 r_t 를 맞힌다
        log_pi, m, log_s, r_hat, _ = model(z[:, :-1], a)
        nll = -mdn_log_prob(z[:, 1:], log_pi, m, log_s).sum(-1).mean()  # 차원 합 → 시간 · 배치 평균
        r_loss = F.mse_loss(r_hat, r)
        loss = nll + reward_weight * r_loss
        opt.zero_grad()
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # 기울기 폭발 막기
        opt.step()
        if step % 500 == 0 or step == 1:
            val = evaluate(model, mu_t[n_train:], act_t[n_train:], rew_t[n_train:])
            history.append((step, nll.item(), r_loss.item(), *val))
            log(f"step {step:5d} | 학습 NLL {nll.item():8.2f}  보상 MSE {r_loss.item():.3f} | "
                f"검증 NLL {val[0]:8.2f}  보상 MSE {val[1]:.3f}")
    return model, history
# --8<-- [end:train]


@torch.no_grad()
def evaluate(model, mu, act, rew):
    """검증 에피소드 전체(평균 μ 를 입력)로 NLL 과 보상 MSE."""
    log_pi, m, log_s, r_hat, _ = model(mu[:, :-1], act)
    nll = -mdn_log_prob(mu[:, 1:], log_pi, m, log_s).sum(-1).mean().item()
    return nll, F.mse_loss(r_hat, rew).item()


# --8<-- [start:dream]
@torch.no_grad()
def dream(model, z_real, actions, warmup: int, tau: float):
    """처음 warmup 스텝은 진짜 z 를 넣어 기억(h)을 만들고, 그 뒤로는 자기 예측을 다시 넣는다.

    z_real : (1, T+1, D) 진짜 잠재 시퀀스 (처음 warmup+1 개만 쓴다)
    actions: (1, T, 1) 행동 — 꿈속에서도 진짜와 같은 행동을 넣어 비교한다
    반환    : (T+1, D) 꿈속 z 시퀀스
    """
    state = model.initial_state(1, z_real.device)
    z = z_real[:, 0:1]  # (1, 1, D)
    out = [z[0, 0]]
    for t in range(actions.shape[1]):
        log_pi, mu, log_sigma, _, state = model(z, actions[:, t : t + 1], state)
        if t + 1 <= warmup:
            z = z_real[:, t + 1 : t + 2]  # 아직은 진짜를 보여 준다
        else:
            z = mdn_sample(log_pi, mu, log_sigma, tau)  # 이제부터는 꿈: 자기가 뽑은 z 를 다시 입력
        out.append(z[0, 0])
    return torch.stack(out)
# --8<-- [end:dream]


def image_angle(imgs):
    """진자 그림에서 각도를 읽는다 (확인용). 밝기로 가중한 무게중심은 막대 위에 있으므로
    그 방향이 곧 막대의 방향이다. 끝점 = (sin θ, -cos θ) 이므로 θ = atan2(x, -y)."""
    coords = (np.arange(imgs.shape[-1]) + 0.5) / imgs.shape[-1] - 0.5
    w = imgs.sum(axis=(-1, -2)) + 1e-8
    cx = (imgs * coords[None, :]).sum(axis=(-1, -2)) / w
    cy = (imgs * coords[:, None]).sum(axis=(-1, -2)) / w
    return np.arctan2(cx, -cy)


def angle_error(a, b):
    """두 각도의 차이를 [0, π] 로 (한 바퀴 돌아도 같은 각도)."""
    return np.abs((a - b + np.pi) % (2 * np.pi) - np.pi)


def save_mdnrnn(model: MDNRNN, path: str):
    cfg = dict(z_dim=model.z_dim, act_dim=model.act_dim, hidden=model.hidden, n_mix=model.n_mix)
    torch.save({"config": cfg, "state_dict": model.state_dict()}, path)


def load_mdnrnn(path: str, device="cpu") -> MDNRNN:
    ckpt = torch.load(path, map_location=device)
    model = MDNRNN(**ckpt["config"]).to(device)
    model.load_state_dict(ckpt["state_dict"])
    model.eval()
    return model


def main():
    parser = argparse.ArgumentParser(description="9장: MDN-RNN")
    parser.add_argument("--quick", action="store_true")
    parser.add_argument("--steps", type=int, default=6000)
    parser.add_argument("--hidden", type=int, default=256)
    parser.add_argument("--n-mix", type=int, default=5)
    parser.add_argument("--seed", type=int, default=0)
    parser.add_argument("--data", default=".", help="8장 결과(ch08_vae.pt, ch08_episodes.npz)가 있는 폴더")
    parser.add_argument("--fig-dir", default="figures")
    parser.add_argument("--out", default=".")
    args = parser.parse_args()
    if args.quick:
        args.steps = 50
    os.makedirs(args.fig_dir, exist_ok=True)
    torch.manual_seed(args.seed)
    np.random.seed(args.seed)
    device = get_device()
    print(f"장치: {device}")

    # 1. 장난감 문제
    toy_experiment(args.fig_dir, device, steps=200 if args.quick else 4000)

    # 2. 에피소드를 z 시퀀스로
    vae = load_vae(os.path.join(args.data, "ch08_vae.pt"), device)
    data = np.load(os.path.join(args.data, "ch08_episodes.npz"))
    obs, actions, rewards = data["obs"], data["action"], data["reward"]
    N, T1 = obs.shape[:2]
    mu, logvar = encode_frames(vae, obs.reshape(-1, 64, 64), device)
    mu, logvar = mu.reshape(N, T1, -1), logvar.reshape(N, T1, -1)
    np.savez_compressed(os.path.join(args.out, "ch09_latents.npz"), mu=mu, logvar=logvar, action=actions, reward=rewards)
    print(f"z 시퀀스: {mu.shape} (에피소드, 시간, 차원)")

    # 3. 학습
    t0 = time.time()
    model, history = train_mdnrnn(mu, logvar, actions, rewards, args.hidden, args.n_mix, args.steps, device=device)
    print(f"MDN-RNN 학습 {time.time() - t0:.1f}초")
    save_mdnrnn(model, os.path.join(args.out, "ch09_mdnrnn.pt"))

    # 4. 꿈 vs 진짜 (검증 에피소드)
    ep = N - 1
    z_real = torch.as_tensor(mu[ep : ep + 1], device=device)
    a_real = torch.as_tensor(actions[ep : ep + 1], device=device)
    warmup, show = 10, np.arange(8, 48, 4)
    rows, names = [obs[ep, show] / 255.0], ["real"]
    for tau, sample_seed in [(0.0, 1), (1.0, 1), (1.0, 2)]:
        torch.manual_seed(sample_seed)
        z_dream = dream(model, z_real, a_real, warmup, tau)
        with torch.no_grad():
            rows.append(vae.decode(z_dream[show]).cpu().numpy()[:, 0])
        names.append(f"dream tau={tau:g}" + (f" #{sample_seed}" if tau > 0 else ""))
    n_cols = len(show)
    fig, axes = plt.subplots(len(rows), n_cols, figsize=(n_cols * 0.95 + 1.3, len(rows) * 1.0 + 0.4))
    for r in range(len(rows)):
        for c in range(n_cols):
            ax = axes[r, c]
            ax.imshow(rows[r][c], cmap="gray", vmin=0, vmax=1)
            ax.set_xticks([])
            ax.set_yticks([])
            if r == 0:
                ax.set_title(f"t={show[c]}" + (" *" if show[c] <= warmup else ""), fontsize=8)
        axes[r, 0].set_ylabel(names[r], rotation=0, ha="right", va="center", fontsize=9)
    fig.subplots_adjust(left=0.14, right=0.99, top=0.9, bottom=0.02, wspace=0.05, hspace=0.08)
    fig.savefig(os.path.join(args.fig_dir, "ch09-dream.png"), dpi=110, facecolor="white")
    plt.close(fig)

    # 4-2 꿈이 얼마나 오래 맞는지 숫자로: 검증 에피소드 전부에서 각도 오차를 잰다
    true_theta = np.arctan2(data["state"][..., 1], data["state"][..., 0])  # (N, T+1)
    horizon = 60
    span = slice(warmup, warmup + horizon + 1)
    errors = {"VAE reconstruction (no dream)": [], "dream tau=0": [], "dream tau=1": []}
    for ep in range(int(N * 0.9), N):
        z_ep = torch.as_tensor(mu[ep : ep + 1, : warmup + horizon + 1], device=device)
        a_ep = torch.as_tensor(actions[ep : ep + 1, : warmup + horizon], device=device)
        target = true_theta[ep, span]
        with torch.no_grad():
            recon = vae.decode(z_ep[0, span]).cpu().numpy()[:, 0]
        errors["VAE reconstruction (no dream)"].append(angle_error(image_angle(recon), target))
        for tau, n_samples in [(0.0, 1), (1.0, 4)]:
            for _ in range(n_samples):
                z_dream = dream(model, z_ep, a_ep, warmup, tau)
                with torch.no_grad():
                    imgs = vae.decode(z_dream[span]).cpu().numpy()[:, 0]
                errors[f"dream tau={tau:g}"].append(angle_error(image_angle(imgs), target))
    fig, ax = plt.subplots(figsize=(7.5, 3.4))
    steps_after = np.arange(horizon + 1)
    for (name, errs), color in zip(errors.items(), ["#999999", "#2f6fdb", "#b7620c"]):
        mean_err = np.degrees(np.mean(errs, axis=0))
        ax.plot(steps_after, mean_err, color=color, lw=2, label=name)
        if name != "VAE reconstruction (no dream)":
            print(f"{name}: 꿈 시작 후 10 · 25 · 50 스텝의 평균 각도 오차 = "
                  + " · ".join(f"{mean_err[k]:.0f}°" for k in (10, 25, 50)))
    ax.axhline(90, color="#d1495b", ls="--", lw=1, label="random guess (90 deg)")
    ax.set_xlabel("steps after the dream starts (0.05 s each)")
    ax.set_ylabel("mean |angle error| (deg)")
    ax.legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch09-dream-error.png"), dpi=110, facecolor="white")
    plt.close(fig)

    # 5. 학습 곡선
    h = np.array(history)
    fig, ax = plt.subplots(figsize=(7, 3))
    ax.plot(h[:, 0], h[:, 1], "o-", label="train NLL")
    ax.plot(h[:, 0], h[:, 3], "s--", label="validation NLL")
    ax.set_xlabel("update step")
    ax.set_ylabel("NLL of z_{t+1} (nats)")
    ax.legend()
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch09-loss.png"), dpi=110, facecolor="white")
    plt.close(fig)
    print("그림 저장:", args.fig_dir)


if __name__ == "__main__":
    main()
