"""3장 실습: 엔트로피 · 교차 엔트로피 · KL 발산을 숫자로 확인하기.

  1. 동전의 엔트로피        : 앞면 확률 p 에 따라 H(p) 가 어떻게 바뀌는지
  2. 이산 분포의 H · CE · KL : KL = 교차 엔트로피 - 엔트로피, KL 은 비대칭
  3. 젠센 부등식            : log E[X] ≥ E[log X] 를 직접 확인
  4. 가우시안 KL            : 풀이 상자의 닫힌 꼴 = 몬테카를로 추정 = torch.distributions
  5. forward / reverse KL   : 봉우리 두 개짜리 분포에 가우시안 하나를 맞추면?
  6. 상호정보량             : I(X;Y) = KL(p(x,y) ‖ p(x)p(y))

실행:
    python ch03_information.py            # 그림은 figures/ 에 저장
    python ch03_information.py --quick    # 표본 수를 줄인 빠른 확인
CPU 로 몇 초면 끝난다.
"""

from __future__ import annotations

import argparse
import math
import os

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import torch
from torch.distributions import Normal, kl_divergence


# --8<-- [start:discrete]
def entropy(p: np.ndarray) -> float:
    """H(p) = -Σ p_i log p_i   (p_i = 0 인 항은 0 으로 친다: 0·log 0 = 0)"""
    p = p[p > 0]
    return float(-np.sum(p * np.log(p)))


def cross_entropy(p: np.ndarray, q: np.ndarray) -> float:
    """H(p, q) = -Σ p_i log q_i   (정답 분포 p 로 평균 낸, 모델 q 의 놀람)"""
    mask = p > 0
    return float(-np.sum(p[mask] * np.log(q[mask])))


def kl(p: np.ndarray, q: np.ndarray) -> float:
    """KL(p ‖ q) = Σ p_i log(p_i / q_i)"""
    mask = p > 0
    return float(np.sum(p[mask] * np.log(p[mask] / q[mask])))


def discrete_examples() -> None:
    for p_head in (0.5, 0.9, 0.99):
        coin = np.array([p_head, 1 - p_head])
        print(f"[엔트로피] 앞면 확률 {p_head:4}: H = {entropy(coin):.4f} 내트 = {entropy(coin) / math.log(2):.4f} bit")
    p = np.array([0.5, 0.3, 0.2])  # 진짜 분포
    q = np.array([0.4, 0.4, 0.2])  # 모델이 생각하는 분포
    print(f"[이산] H(p) = {entropy(p):.4f},  H(p,q) = {cross_entropy(p, q):.4f}")
    print(f"[이산] KL(p‖q) = {kl(p, q):.4f},  H(p,q) - H(p) = {cross_entropy(p, q) - entropy(p):.4f}")
    print(f"[이산] KL(q‖p) = {kl(q, p):.4f}   ← 순서를 바꾸면 값이 다르다 (비대칭)")
    print(f"[이산] 균등 분포 3칸의 엔트로피 = {entropy(np.ones(3) / 3):.4f} = log 3 = {math.log(3):.4f}")
# --8<-- [end:discrete]


def coin_entropy_figure(fig_dir: str) -> None:
    ps = np.linspace(1e-4, 1 - 1e-4, 500)
    h = -(ps * np.log(ps) + (1 - ps) * np.log(1 - ps))
    fig, ax = plt.subplots(figsize=(6.5, 3.6))
    ax.plot(ps, h, lw=2)
    ax.axhline(math.log(2), color="gray", ls="--", lw=1)
    ax.text(0.02, math.log(2) + 0.015, "max = log 2 = 0.693 (fair coin)", fontsize=9)
    for p0 in (0.9, 0.99):
        h0 = -(p0 * math.log(p0) + (1 - p0) * math.log(1 - p0))
        ax.plot([p0], [h0], "o", color="C3")
        ax.annotate(f"p={p0}: H={h0:.3f}", (p0, h0), textcoords="offset points", xytext=(-95, 4), fontsize=9)
    ax.set_xlabel("probability of heads p")
    ax.set_ylabel("entropy H (nats)")
    ax.set_title("Entropy of a coin flip")
    ax.set_ylim(0, 0.8)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch03-coin-entropy.png"), dpi=120)
    plt.close(fig)


# --8<-- [start:jensen]
def jensen_check(rng: np.random.Generator, n: int) -> None:
    """log 는 오목(위로 볼록) 함수라서 log E[X] ≥ E[log X] 이다."""
    x = rng.uniform(0.5, 2.0, size=n)  # 양수인 확률변수
    print(f"[젠센] log E[X] = {math.log(x.mean()):.4f}  ≥  E[log X] = {np.log(x).mean():.4f}")
    x2 = rng.normal(0.0, 1.0, size=n)
    print(f"[젠센] (E[X])² = {x2.mean() ** 2:.4f}  ≤  E[X²] = {(x2**2).mean():.4f}   (x² 는 볼록)")
# --8<-- [end:jensen]


def jensen_figure(fig_dir: str) -> None:
    f = lambda x: -np.log(x)  # 볼록 함수
    xs = np.linspace(0.25, 3.2, 300)
    a, b, w = 0.5, 2.5, 0.4  # 두 점과 섞는 비율 (a 쪽 가중치 0.4)
    m = w * a + (1 - w) * b
    fig, ax = plt.subplots(figsize=(6.5, 3.8))
    ax.plot(xs, f(xs), lw=2, label=r"convex $f(x) = -\log x$")
    ax.plot([a, b], [f(a), f(b)], "k--", lw=1.2, label="chord")
    ax.plot([a, b], [f(a), f(b)], "ko")
    ax.plot([m], [f(m)], "o", color="C2", ms=8, label=r"$f(\mathbb{E}[x])$")
    ax.plot([m], [w * f(a) + (1 - w) * f(b)], "o", color="C3", ms=8, label=r"$\mathbb{E}[f(x)]$")
    ax.vlines(m, f(m), w * f(a) + (1 - w) * f(b), colors="C3", lw=1)
    ax.annotate("a", (a, f(a)), textcoords="offset points", xytext=(6, 4))
    ax.annotate("b", (b, f(b)), textcoords="offset points", xytext=(4, 6))
    ax.set_xlabel("x")
    ax.set_title(r"Jensen: $f(\mathbb{E}[x]) \leq \mathbb{E}[f(x)]$ for convex $f$")
    ax.legend(fontsize=9)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch03-jensen.png"), dpi=120)
    plt.close(fig)


# --8<-- [start:gauss_kl]
def kl_gauss(mu1: float, s1: float, mu2: float, s2: float) -> float:
    """KL( N(μ1, s1²) ‖ N(μ2, s2²) ) 닫힌 꼴 = log(s2/s1) + (s1² + (μ1-μ2)²) / (2 s2²) - 1/2"""
    return math.log(s2 / s1) + (s1**2 + (mu1 - mu2) ** 2) / (2 * s2**2) - 0.5


def kl_to_standard_normal(mu: float, s: float) -> float:
    """VAE 에서 쓰는 특수형: KL( N(μ, s²) ‖ N(0, 1) ) = ½ (μ² + s² - 1 - log s²)"""
    return 0.5 * (mu**2 + s**2 - 1 - math.log(s**2))


def gaussian_kl_check(rng: np.random.Generator, n: int, fig_dir: str) -> None:
    mu1, s1, mu2, s2 = 1.0, 0.5, 0.0, 1.0
    closed = kl_gauss(mu1, s1, mu2, s2)

    # 몬테카를로: x ~ q 를 많이 뽑아 log q(x) - log p(x) 를 평균 낸다.
    def log_normal(x, mu, s):
        return -0.5 * math.log(2 * math.pi) - math.log(s) - (x - mu) ** 2 / (2 * s**2)

    x = rng.normal(mu1, s1, size=n)
    terms = log_normal(x, mu1, s1) - log_normal(x, mu2, s2)
    mc = terms.mean()
    lib = kl_divergence(Normal(mu1, s1), Normal(mu2, s2)).item()
    print(f"[가우시안 KL] 닫힌 꼴 {closed:.4f}  /  몬테카를로({n}개) {mc:.4f}  /  torch {lib:.4f}")
    print(f"[가우시안 KL] 특수형 ½(μ²+σ²-1-log σ²) = {kl_to_standard_normal(mu1, s1):.4f}")
    print(f"[가우시안 KL] 순서를 바꾼 KL(p‖q) = {kl_gauss(mu2, s2, mu1, s1):.4f}")

    # 대각 다변량: 차원별 KL 의 합
    mu_vec = torch.tensor([1.0, -0.5, 0.0])
    s_vec = torch.tensor([0.5, 1.0, 2.0])
    per_dim = 0.5 * (mu_vec**2 + s_vec**2 - 1 - torch.log(s_vec**2))
    lib_vec = kl_divergence(Normal(mu_vec, s_vec), Normal(torch.zeros(3), torch.ones(3)))
    print(f"[대각 다변량] 차원별 {[round(v, 4) for v in per_dim.tolist()]} → 합 {per_dim.sum().item():.4f}"
          f" (torch {lib_vec.sum().item():.4f})")

    # 표본 수에 따라 몬테카를로 추정이 닫힌 꼴로 다가가는 모습
    counts = np.unique(np.logspace(0, math.log10(n), 60).astype(int))
    running = np.cumsum(terms) / np.arange(1, n + 1)
    fig, ax = plt.subplots(figsize=(6.5, 3.4))
    ax.plot(counts, running[counts - 1], lw=1.5, label="Monte Carlo estimate")
    ax.axhline(closed, color="r", ls="--", label=f"closed form = {closed:.4f}")
    ax.set_xscale("log")
    ax.set_xlabel("number of samples")
    ax.set_ylabel("KL estimate")
    ax.set_title(r"KL( N(1, 0.5$^2$) || N(0, 1) )")
    ax.legend(fontsize=9)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch03-kl-mc.png"), dpi=120)
    plt.close(fig)
# --8<-- [end:gauss_kl]


# --8<-- [start:fwd_rev]
def forward_reverse_kl(fig_dir: str) -> None:
    """봉우리가 두 개인 p 에 가우시안 q 하나를 맞춘다. KL 의 방향에 따라 결과가 다르다."""
    xs = np.linspace(-8, 8, 4001)
    dx = xs[1] - xs[0]

    def normal_pdf(x, mu, s):
        return np.exp(-((x - mu) ** 2) / (2 * s**2)) / (s * math.sqrt(2 * math.pi))

    p = 0.5 * normal_pdf(xs, -2, 0.6) + 0.5 * normal_pdf(xs, 2, 0.6)
    eps = 1e-300  # log 0 을 피하는 아주 작은 수

    def kl_num(a, b):  # 격자 위에서 적분: Σ a(x) log(a(x)/b(x)) Δx
        return float(np.sum(a * (np.log(a + eps) - np.log(b + eps))) * dx)

    best_fwd, best_rev = (None, math.inf), (None, math.inf)
    for mu in np.linspace(-3, 3, 121):
        for s in np.linspace(0.2, 3.0, 141):
            q = normal_pdf(xs, mu, s)
            f, r = kl_num(p, q), kl_num(q, p)
            if f < best_fwd[1]:
                best_fwd = ((mu, s), f)
            if r < best_rev[1]:
                best_rev = ((mu, s), r)
    (mf, sf), kf = best_fwd
    (mr, sr), kr = best_rev
    print(f"[forward KL(p‖q) 최소] μ = {mf:+.2f}, σ = {sf:.2f}  (KL = {kf:.3f})")
    print(f"[reverse KL(q‖p) 최소] μ = {mr:+.2f}, σ = {sr:.2f}  (KL = {kr:.3f})")
    print(f"[참고] p 의 평균 = 0, 분산 = 0.6² + 2² = {0.36 + 4:.2f} → 표준편차 {math.sqrt(4.36):.2f}")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.6), sharey=True)
    for ax, (mu, s), title in (
        (axes[0], (mf, sf), "forward KL(p||q): mode covering"),
        (axes[1], (mr, sr), "reverse KL(q||p): mode seeking"),
    ):
        ax.fill_between(xs, p, color="#cfd9ea", label="target p (two modes)")
        ax.plot(xs, normal_pdf(xs, mu, s), "r-", lw=2, label=f"best q: mu={mu:+.2f}, sigma={s:.2f}")
        ax.set_xlim(-6, 6)
        ax.set_title(title)
        ax.set_xlabel("x")
        ax.legend(fontsize=8, loc="upper left")
    axes[0].set_ylabel("density")
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch03-forward-reverse-kl.png"), dpi=120)
    plt.close(fig)
# --8<-- [end:fwd_rev]


# --8<-- [start:mutual]
def mutual_information() -> None:
    # 날씨 X(맑음/비) 와 우산 Y(안 씀/씀) 의 결합 분포
    joint = np.array([[0.45, 0.05],  # 맑음: 안 씀, 씀
                      [0.10, 0.40]])  # 비  : 안 씀, 씀
    px = joint.sum(axis=1, keepdims=True)  # 주변 분포 p(x) (행의 합)
    py = joint.sum(axis=0, keepdims=True)  # 주변 분포 p(y) (열의 합)
    mi = np.sum(joint * np.log(joint / (px * py)))
    print(f"[상호정보량] p(x) = {px.ravel().tolist()}, p(y) = {py.ravel().tolist()}")
    print(f"[상호정보량] I(X;Y) = {mi:.4f} 내트   (독립이면 0)")
    indep = px * py  # 독립이라면 결합 분포는 곱이 된다
    print(f"[상호정보량] 독립인 결합 분포로 계산하면 I = {np.sum(indep * np.log(indep / (px * py))):.4f}")
# --8<-- [end:mutual]


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--quick", action="store_true", help="표본 수를 줄여 빠르게 확인")
    parser.add_argument("--fig-dir", default="figures", help="그림을 저장할 폴더")
    parser.add_argument("--seed", type=int, default=0)
    args = parser.parse_args()
    os.makedirs(args.fig_dir, exist_ok=True)
    rng = np.random.default_rng(args.seed)

    n = 10_000 if args.quick else 1_000_000
    discrete_examples()
    coin_entropy_figure(args.fig_dir)
    jensen_check(rng, n)
    jensen_figure(args.fig_dir)
    gaussian_kl_check(rng, n, args.fig_dir)
    forward_reverse_kl(args.fig_dir)
    mutual_information()


if __name__ == "__main__":
    main()
