"""8장 실습: 진자 그림(64×64)을 32차원 잠재 벡터로 압축하는 VAE.

하는 일
  1. PixelPendulum 에서 무작위 행동으로 에피소드를 모은다 (그림 64×64 흑백).
  2. 합성곱 VAE 를 학습한다 (Ha & Schmidhuber 2018 의 구조를 흑백 1채널로).
  3. 비교를 위해 같은 구조의 '그냥 오토인코더' 도 학습한다.
  4. 재구성 · 차원별 KL · 잠재 공간 · 순회 · 사전 분포 표본 그림을 저장한다.
  5. 9 · 10장이 이어서 쓰도록 VAE 체크포인트(ch08_vae.pt)와 에피소드(ch08_episodes.npz)를 저장한다.

실행
  python ch08_vae.py            # 본문 결과 (노트북 GPU 약 2 – 4분 / CPU 4스레드 약 50분)
  python ch08_vae.py --quick    # 연기 시험 (CPU 로 1분 안쪽)
"""

from __future__ import annotations

import argparse
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 wm_envs import PixelPendulum


def get_device() -> str:
    if torch.cuda.is_available():
        return "cuda"
    if torch.backends.mps.is_available():
        return "mps"
    return "cpu"


# --8<-- [start:collect]
def collect_pixel_episodes(n_episodes: int, seed: int = 0, policy=None, max_steps: int = 200):
    """PixelPendulum 에서 에피소드를 모은다. policy 가 None 이면 무작위 토크.

    돌려주는 dict 의 배열 (N = 에피소드 수, T = 스텝 수)
      obs    : (N, T+1, 64, 64) uint8   ← 학습에 쓰는 것은 이것뿐
      action : (N, T, 1) float32
      reward : (N, T) float32
      state  : (N, T+1, 3) float32      ← 정답 [cos θ, sin θ, θ̇]. 그림 확인용으로만 쓴다
    """
    env = PixelPendulum(seed=seed, max_steps=max_steps)
    rng = np.random.default_rng(seed)
    obs_all, act_all, rew_all, state_all = [], [], [], []
    for _ in range(n_episodes):
        obs = env.reset()
        obs_list, state_list, act_list, rew_list = [obs], [env.state()], [], []
        done = False
        while not done:
            if policy is None:
                action = rng.uniform(-2.0, 2.0, size=(1,)).astype(np.float32)
            else:
                action = np.asarray(policy(obs), dtype=np.float32).reshape(1)
            obs, reward, done = env.step(action)
            obs_list.append(obs)
            state_list.append(env.state())
            act_list.append(action)
            rew_list.append(reward)
        obs_all.append(np.stack(obs_list))
        state_all.append(np.stack(state_list))
        act_all.append(np.stack(act_list))
        rew_all.append(np.asarray(rew_list, dtype=np.float32))
    return dict(
        obs=np.stack(obs_all),
        action=np.stack(act_all).astype(np.float32),
        reward=np.stack(rew_all),
        state=np.stack(state_all).astype(np.float32),
    )
# --8<-- [end:collect]


# --8<-- [start:model]
class ConvVAE(nn.Module):
    """합성곱 VAE. 입력 (B, 1, 64, 64) 값 범위 [0, 1] → 잠재 z (B, z_dim)."""

    def __init__(self, z_dim: int = 32):
        super().__init__()
        self.z_dim = z_dim
        # 인코더: 4×4 합성곱, 보폭 2 를 네 번. 64 → 31 → 14 → 6 → 2
        self.enc = nn.Sequential(
            nn.Conv2d(1, 32, 4, stride=2), nn.ReLU(),  # (B, 32, 31, 31)
            nn.Conv2d(32, 64, 4, stride=2), nn.ReLU(),  # (B, 64, 14, 14)
            nn.Conv2d(64, 128, 4, stride=2), nn.ReLU(),  # (B, 128, 6, 6)
            nn.Conv2d(128, 256, 4, stride=2), nn.ReLU(),  # (B, 256, 2, 2)
            nn.Flatten(),  # (B, 1024)
        )
        self.fc_mu = nn.Linear(1024, z_dim)  # 평균 μ
        self.fc_logvar = nn.Linear(1024, z_dim)  # 로그 분산 log σ²
        # 디코더: z → 1024 → (1024, 1, 1) 에서 전치 합성곱으로 1 → 5 → 13 → 30 → 64
        self.fc_dec = nn.Linear(z_dim, 1024)
        self.dec = nn.Sequential(
            nn.ConvTranspose2d(1024, 128, 5, stride=2), nn.ReLU(),  # (B, 128, 5, 5)
            nn.ConvTranspose2d(128, 64, 5, stride=2), nn.ReLU(),  # (B, 64, 13, 13)
            nn.ConvTranspose2d(64, 32, 6, stride=2), nn.ReLU(),  # (B, 32, 30, 30)
            nn.ConvTranspose2d(32, 1, 6, stride=2),  # (B, 1, 64, 64) 로짓
        )

    def encode(self, x):
        """q_φ(z|x) 의 평균과 로그 분산."""
        h = self.enc(x)
        return self.fc_mu(h), self.fc_logvar(h)

    def reparameterize(self, mu, logvar):
        """재매개변수화: z = μ + σ ⊙ ε,  ε ~ N(0, I)."""
        std = torch.exp(0.5 * logvar)  # σ = exp(½ log σ²)
        eps = torch.randn_like(std)
        return mu + std * eps

    def decode_logits(self, z):
        """p_θ(x|z) 의 베르누이 로짓. 픽셀 밝기 = sigmoid(로짓)."""
        h = self.fc_dec(z).view(-1, 1024, 1, 1)
        return self.dec(h)

    def decode(self, z):
        return torch.sigmoid(self.decode_logits(z))

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        return self.decode_logits(z), mu, logvar
# --8<-- [end:model]


# --8<-- [start:loss]
def vae_loss(logits, x, mu, logvar, beta: float = 1.0):
    """음의 ELBO (그림 한 장당 평균). 작을수록 좋다.

    재구성 항: -log p_θ(x|z) = 픽셀마다 이진 교차 엔트로피(BCE)의 합
    KL 항    : KL(N(μ, σ²) ‖ N(0, 1)) = ½ Σ_j (μ_j² + σ_j² − 1 − log σ_j²)
    """
    batch = x.shape[0]
    recon = F.binary_cross_entropy_with_logits(logits, x, reduction="sum") / batch
    kl = 0.5 * torch.sum(mu.pow(2) + logvar.exp() - 1.0 - logvar) / batch
    return recon + beta * kl, recon, kl
# --8<-- [end:loss]


class ConvAE(nn.Module):
    """비교용 '그냥' 오토인코더: VAE 와 같은 구조에서 확률(σ, KL)만 뺐다."""

    def __init__(self, z_dim: int = 32):
        super().__init__()
        vae = ConvVAE(z_dim)
        self.enc, self.fc_mu, self.fc_dec, self.dec = vae.enc, vae.fc_mu, vae.fc_dec, vae.dec

    def encode(self, x):
        return self.fc_mu(self.enc(x))

    def decode(self, z):
        return torch.sigmoid(self.dec(self.fc_dec(z).view(-1, 1024, 1, 1)))

    def forward(self, x):
        z = self.encode(x)
        return self.dec(self.fc_dec(z).view(-1, 1024, 1, 1))


def to_float(frames_uint8, device):
    """uint8 (B, 64, 64) → float (B, 1, 64, 64), 값 범위 [0, 1]."""
    return torch.as_tensor(frames_uint8, device=device).float().div_(255.0).unsqueeze(1)


# --8<-- [start:train]
def train_vae(frames, z_dim=32, epochs=10, batch_size=128, lr=1e-3, beta=1.0, device="cpu", log=print):
    """frames: (N, 64, 64) uint8. 학습한 VAE 와 에폭별 (재구성, KL) 기록을 돌려준다."""
    model = ConvVAE(z_dim).to(device)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    n = len(frames)
    history = []
    for epoch in range(1, epochs + 1):
        perm = np.random.permutation(n)
        sums = np.zeros(3)
        for i in range(0, n, batch_size):
            x = to_float(frames[perm[i : i + batch_size]], device)  # (B, 1, 64, 64)
            logits, mu, logvar = model(x)
            loss, recon, kl = vae_loss(logits, x, mu, logvar, beta)
            opt.zero_grad()
            loss.backward()
            opt.step()
            sums += np.array([loss.item(), recon.item(), kl.item()]) * len(x)
        loss_e, recon_e, kl_e = sums / n
        history.append((recon_e, kl_e))
        log(f"epoch {epoch:2d} | -ELBO {loss_e:7.2f} = 재구성 {recon_e:7.2f} + KL {kl_e:5.2f}")
    return model, history
# --8<-- [end:train]


def train_ae(frames, z_dim=32, epochs=10, batch_size=128, lr=1e-3, device="cpu"):
    model = ConvAE(z_dim).to(device)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    n = len(frames)
    for _ in range(epochs):
        perm = np.random.permutation(n)
        for i in range(0, n, batch_size):
            x = to_float(frames[perm[i : i + batch_size]], device)
            loss = F.binary_cross_entropy_with_logits(model(x), x, reduction="sum") / len(x)
            opt.zero_grad()
            loss.backward()
            opt.step()
    return model


def save_vae(model: ConvVAE, path: str):
    torch.save({"z_dim": model.z_dim, "state_dict": model.state_dict()}, path)


def load_vae(path: str, device="cpu") -> ConvVAE:
    """9 · 10장에서 쓰는 함수: 저장한 VAE 를 불러온다."""
    ckpt = torch.load(path, map_location=device)
    model = ConvVAE(ckpt["z_dim"]).to(device)
    model.load_state_dict(ckpt["state_dict"])
    model.eval()
    return model


@torch.no_grad()
def encode_frames(model: ConvVAE, frames, device, batch_size=512):
    """uint8 그림 (N, 64, 64) → μ, log σ² 각각 (N, z_dim) numpy."""
    mus, logvars = [], []
    for i in range(0, len(frames), batch_size):
        mu, logvar = model.encode(to_float(frames[i : i + batch_size], device))
        mus.append(mu.cpu().numpy())
        logvars.append(logvar.cpu().numpy())
    return np.concatenate(mus), np.concatenate(logvars)


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


def plot_images(rows, row_titles, path, cell=0.9):
    n_rows, n_cols = len(rows), len(rows[0])
    fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * cell + 1.2, n_rows * cell + 0.3))
    axes = np.atleast_2d(axes)
    for r in range(n_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([])
        axes[r, 0].set_ylabel(row_titles[r], rotation=0, ha="right", va="center", fontsize=9)
    fig.subplots_adjust(left=0.13, right=0.99, top=0.98, bottom=0.02, wspace=0.05, hspace=0.08)
    fig.savefig(path, dpi=110, facecolor="white")
    plt.close(fig)


def main():
    parser = argparse.ArgumentParser(description="8장: 진자 그림 VAE")
    parser.add_argument("--quick", action="store_true", help="아주 작게 돌려 오류만 확인")
    parser.add_argument("--episodes", type=int, default=200)
    parser.add_argument("--epochs", type=int, default=10)
    parser.add_argument("--z-dim", type=int, default=32)
    parser.add_argument("--beta", type=float, default=1.0)
    parser.add_argument("--seed", type=int, default=0)
    parser.add_argument("--fig-dir", default="figures")
    parser.add_argument("--out", default=".", help="체크포인트 · 데이터를 저장할 폴더")
    args = parser.parse_args()
    if args.quick:
        args.episodes, args.epochs = 6, 1

    os.makedirs(args.fig_dir, exist_ok=True)
    os.makedirs(args.out, exist_ok=True)
    torch.manual_seed(args.seed)
    np.random.seed(args.seed)
    device = get_device()
    print(f"장치: {device}")

    # 1. 데이터 모으기
    t0 = time.time()
    data = collect_pixel_episodes(args.episodes, seed=args.seed)
    frames = data["obs"].reshape(-1, 64, 64)  # 에피소드를 풀어 그림 묶음으로
    states = data["state"].reshape(-1, 3)
    print(f"에피소드 {args.episodes}개, 그림 {len(frames)}장 모음 ({time.time() - t0:.1f}초)")
    np.savez_compressed(os.path.join(args.out, "ch08_episodes.npz"), **data)

    # 2. VAE 학습
    t0 = time.time()
    vae, history = train_vae(frames, args.z_dim, args.epochs, beta=args.beta, device=device)
    print(f"VAE 학습 {time.time() - t0:.1f}초")
    save_vae(vae, os.path.join(args.out, "ch08_vae.pt"))
    vae.eval()

    # 3. 비교용 오토인코더
    ae = train_ae(frames, args.z_dim, args.epochs, device=device).eval()

    # 4. 분석
    rng = np.random.default_rng(1)
    with torch.no_grad():
        # 4-1 재구성
        idx = rng.choice(len(frames), 10, replace=False)
        x = to_float(frames[idx], device)
        mu, logvar = vae.encode(x)
        recon_vae = vae.decode(mu).cpu().numpy()[:, 0]
        recon_ae = ae.decode(ae.encode(x)).cpu().numpy()[:, 0]
        plot_images(
            [frames[idx] / 255.0, recon_vae, recon_ae],
            ["input", "VAE", "AE"],
            os.path.join(args.fig_dir, "ch08-recon.png"),
        )

        # 4-2 차원별 KL: 평균 KL 이 거의 0 인 차원은 '쓰이지 않는' 차원
        mu_all, logvar_all = encode_frames(vae, frames, device)
        kl_dim = 0.5 * np.mean(mu_all**2 + np.exp(logvar_all) - 1.0 - logvar_all, axis=0)
        active = np.argsort(-kl_dim)
        n_active = int(np.sum(kl_dim > 0.05))
        print("차원별 평균 KL (큰 순서 5개):", ", ".join(f"z[{j}]={kl_dim[j]:.2f}" for j in active[:5]))
        print(f"KL > 0.05 인 '살아 있는' 차원: {n_active}개 / {args.z_dim}개")

        fig, ax = plt.subplots(figsize=(8, 2.6))
        ax.bar(np.arange(args.z_dim), kl_dim, color="#2f6fdb")
        ax.set_xlabel("latent dimension j")
        ax.set_ylabel("mean KL (nats)")
        ax.set_title("KL per latent dimension")
        fig.tight_layout()
        fig.savefig(os.path.join(args.fig_dir, "ch08-kl-per-dim.png"), dpi=110, facecolor="white")
        plt.close(fig)

        # 재구성 항의 바닥값: 목표 픽셀이 0 · 1 이 아닌 회색이면 BCE 는 0 이 될 수 없다.
        # 가장 잘 맞혀도(예측 = 목표) 남는 값 = 픽셀 엔트로피의 합 (3장)
        p = np.clip(frames[: min(len(frames), 5000)] / 255.0, 1e-6, 1 - 1e-6)
        floor = np.mean(np.sum(-(p * np.log(p) + (1 - p) * np.log(1 - p)), axis=(1, 2)))
        print(f"재구성 항(BCE)의 이론적 바닥값: 그림당 {floor:.1f} 내트")

        # 4-3 잠재 벡터를 주성분 분석(PCA)으로 2차원에 비춰 보고, 정답 각도로 칠하기
        theta = np.arctan2(states[:, 1], states[:, 0])
        sel = rng.choice(len(frames), min(4000, len(frames)), replace=False)
        z_ae = []
        for i in range(0, len(sel), 512):
            z_ae.append(ae.encode(to_float(frames[sel[i : i + 512]], device)).cpu().numpy())
        z_ae = np.concatenate(z_ae)

        def pca2(z):
            zc = z - z.mean(axis=0)
            _, _, vt = np.linalg.svd(zc, full_matrices=False)
            return zc @ vt[:2].T

        fig, axes = plt.subplots(1, 2, figsize=(10, 4), constrained_layout=True)
        for ax, z, name in [(axes[0], mu_all[sel], "VAE mu"), (axes[1], z_ae, "plain AE z")]:
            p2 = pca2(z)
            sc = ax.scatter(p2[:, 0], p2[:, 1], c=theta[sel], cmap="hsv", s=4, vmin=-np.pi, vmax=np.pi)
            ax.set_xlabel("PC 1")
            ax.set_ylabel("PC 2")
            ax.set_title(f"{name}  (|z| ~ {np.abs(z).max():.0f})")
            ax.set_aspect("equal", "datalim")
        fig.colorbar(sc, ax=axes, label="true angle theta (rad)")
        fig.savefig(os.path.join(args.fig_dir, "ch08-latent.png"), dpi=110, facecolor="white")
        plt.close(fig)

        # 4-4 잠재 공간 순회: KL 이 큰 세 차원을 하나씩 -3 ~ 3 으로 움직이고 나머지는 0
        values = np.linspace(-3, 3, 9)
        rows = []
        for d in active[:3]:
            z = torch.zeros(len(values), args.z_dim, device=device)
            z[:, d] = torch.as_tensor(values, dtype=torch.float32, device=device)
            rows.append(vae.decode(z).cpu().numpy()[:, 0])
        plot_images(rows, [f"z[{d}]" for d in active[:3]], os.path.join(args.fig_dir, "ch08-traversal.png"))

        # 4-5 사전 분포 N(0, I) 에서 뽑은 z 를 디코딩: VAE vs AE
        z = torch.randn(10, args.z_dim, device=device)
        z_ae_scaled = z * torch.as_tensor(z_ae.std(axis=0), device=device) + torch.as_tensor(z_ae.mean(axis=0), device=device)
        plot_images(
            [vae.decode(z).cpu().numpy()[:, 0], ae.decode(z).cpu().numpy()[:, 0], ae.decode(z_ae_scaled).cpu().numpy()[:, 0]],
            ["VAE", "AE", "AE*"],
            os.path.join(args.fig_dir, "ch08-samples.png"),
        )

    # 4-6 학습 곡선
    hist = np.array(history)
    fig, ax1 = plt.subplots(figsize=(7, 3))
    ax1.plot(np.arange(1, len(hist) + 1), hist[:, 0], "o-", color="#2f6fdb", label="reconstruction (BCE)")
    ax1.set_xlabel("epoch")
    ax1.set_ylabel("reconstruction (nats / image)")
    ax2 = ax1.twinx()
    ax2.plot(np.arange(1, len(hist) + 1), hist[:, 1], "s--", color="#b7620c", label="KL")
    ax2.set_ylabel("KL (nats / image)")
    fig.legend(loc="upper right", bbox_to_anchor=(0.88, 0.9))
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch08-loss.png"), dpi=110, facecolor="white")
    plt.close(fig)
    print("그림 저장:", args.fig_dir)


if __name__ == "__main__":
    main()
