"""2장 실습: 확률과 최대우도를 숫자로 확인하기.

이 파일은 2장의 공식들이 '정말 그런지' 컴퓨터로 확인한다.
  1. 베이즈 정리      : 병 검사 예제를 공식과 시뮬레이션으로 계산해 비교
  2. 큰 수의 법칙     : 주사위 평균이 3.5 로 다가가고, 표본 평균의 표준편차가 σ/√N 으로 줄어드는지
  3. 밀도는 1 을 넘는다: 좁은 가우시안의 히스토그램과 밀도 함수
  4. 최대우도 추정     : 가우시안의 μ̂ = 표본 평균, σ̂² = 표본 분산 이 정말 로그 가능도를 최대로 만드는지
  5. 손실 함수의 정체  : MSE = 가우시안 NLL, BCE = 베르누이 NLL, CE = 범주형 NLL

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

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
import torch.nn.functional as F


# --8<-- [start:bayes]
def bayes_example(rng: np.random.Generator, n_people: int) -> None:
    """병 검사 예제: 양성이 나왔을 때 정말 병이 있을 확률은?"""
    p_d = 0.01  # P(병)          : 100 명 중 1 명
    p_pos_d = 0.99  # P(양성 | 병)   : 병이 있으면 99% 양성
    p_pos_nd = 0.05  # P(양성 | 건강) : 건강해도 5% 는 양성(오진)

    # 공식: P(병 | 양성) = P(양성 | 병) P(병) / P(양성)
    p_pos = p_pos_d * p_d + p_pos_nd * (1 - p_d)  # 주변화: 병인 경우 + 건강한 경우
    posterior = p_pos_d * p_d / p_pos
    print(f"[베이즈] 공식     P(양성) = {p_pos:.4f},  P(병 | 양성) = {posterior:.4f}")

    # 시뮬레이션: 가상의 사람을 많이 만들어 실제로 세어 본다.
    sick = rng.random(n_people) < p_d  # 각 사람이 병이 있는지
    u = rng.random(n_people)
    positive = np.where(sick, u < p_pos_d, u < p_pos_nd)  # 병 여부에 따라 양성 확률이 다르다
    print(f"[베이즈] 시뮬레이션 양성 {positive.sum()} 명 중 병 {np.sum(sick & positive)} 명"
          f" → P(병 | 양성) ≈ {np.sum(sick & positive) / positive.sum():.4f}")
# --8<-- [end:bayes]


# --8<-- [start:lln]
def law_of_large_numbers(rng: np.random.Generator, n_rolls: int, fig_dir: str) -> None:
    """주사위를 던질수록 평균이 기댓값 3.5 에 다가간다."""
    faces = np.arange(1, 7)
    mean = faces.mean()  # E[X] = 3.5
    var = ((faces - mean) ** 2).mean()  # Var[X] = 35/12 ≈ 2.9167
    print(f"[큰 수의 법칙] 주사위 E[X] = {mean}, Var[X] = {var:.4f}, σ = {math.sqrt(var):.4f}")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.8))
    ax = axes[0]
    for k in range(5):  # 다섯 사람이 각자 주사위를 n_rolls 번 던진다
        rolls = rng.integers(1, 7, size=n_rolls)
        running = np.cumsum(rolls) / np.arange(1, n_rolls + 1)  # 지금까지의 평균
        ax.plot(np.arange(1, n_rolls + 1), running, lw=1.2, label=f"run {k + 1}")
    ax.axhline(mean, color="k", ls="--", lw=1, label="E[X] = 3.5")
    ax.set_xscale("log")
    ax.set_xlabel("number of rolls N")
    ax.set_ylabel("sample mean")
    ax.set_title("Sample mean of die rolls")
    ax.legend(fontsize=8, ncol=2)

    # 표본 평균의 표준편차: 이론값 σ/√N 과 실험값 비교
    ns = np.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000])
    measured = []
    for n in ns:
        means = rng.integers(1, 7, size=(4000, n)).mean(axis=1)  # 표본 평균을 4000 번 만든다
        measured.append(means.std())
    measured = np.array(measured)
    ax = axes[1]
    ax.loglog(ns, measured, "o", label="measured std of sample mean")
    ax.loglog(ns, math.sqrt(var) / np.sqrt(ns), "-", label=r"theory $\sigma/\sqrt{N}$")
    ax.set_xlabel("N (rolls per average)")
    ax.set_ylabel("std of sample mean")
    ax.set_title("Error shrinks like 1/sqrt(N)")
    ax.legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch02-lln.png"), dpi=120)
    plt.close(fig)
    for n, m in zip(ns, measured):
        if n in (10, 100, 1000):
            print(f"[큰 수의 법칙] N={n:5d}: 실험 표준편차 {m:.4f}, 이론 σ/√N {math.sqrt(var) / math.sqrt(n):.4f}")
# --8<-- [end:lln]


# --8<-- [start:density]
def gaussian_pdf(x, mu, sigma):
    """1차원 가우시안 밀도  N(x; μ, σ²) = 1/(σ√(2π)) · exp(-(x-μ)² / (2σ²))."""
    return np.exp(-((x - mu) ** 2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))


def density_can_exceed_one(rng: np.random.Generator, n: int, fig_dir: str) -> None:
    mu, sigma = 0.0, 0.2
    x = rng.normal(mu, sigma, size=n)  # μ + σ·ε 로 뽑는 것과 같다
    grid = np.linspace(-1, 1, 400)
    pdf = gaussian_pdf(grid, mu, sigma)
    area = np.sum(pdf) * (grid[1] - grid[0])  # 넓이 = Σ 높이 × 폭 (리만 합)
    # 격자에 정확한 0 은 없어서 pdf.max() 는 p(±0.0025) 이지만, p(0) = 1.9947 과 거의 같다.
    print(f"[밀도] 최댓값 p(0) ≈ {pdf.max():.4f} (1 보다 크다!),  밑넓이 ≈ {area:.4f}")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.6))
    ax = axes[0]
    ax.bar(np.arange(1, 7), np.full(6, 1 / 6), color="#7aa7f0", edgecolor="k")
    ax.set_ylim(0, 0.3)
    ax.set_xlabel("die face x")
    ax.set_ylabel("P(X = x)")
    ax.set_title("Discrete: probability mass (sums to 1)")
    ax = axes[1]
    ax.hist(x, bins=60, density=True, color="#cfd9ea", edgecolor="#7a8aa3", label=f"histogram of {n} samples")
    ax.plot(grid, pdf, "r-", lw=2, label=r"density $\mathcal{N}(0, 0.2^2)$")
    ax.set_xlabel("x")
    ax.set_ylabel("p(x)")
    ax.set_title("Continuous: density (area is 1, height can be > 1)")
    ax.legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch02-density.png"), dpi=120)
    plt.close(fig)
# --8<-- [end:density]


# --8<-- [start:mle]
def gaussian_log_likelihood(x: np.ndarray, mu: float, sigma: float) -> float:
    """log L(μ, σ) = Σ_i log N(x_i; μ, σ²) = -N/2·log(2π) - N·log σ - Σ(x_i-μ)²/(2σ²)."""
    n = len(x)
    return -0.5 * n * math.log(2 * math.pi) - n * math.log(sigma) - np.sum((x - mu) ** 2) / (2 * sigma**2)


def gaussian_mle(rng: np.random.Generator, n: int, fig_dir: str) -> None:
    true_mu, true_sigma = 3.0, 2.0
    x = rng.normal(true_mu, true_sigma, size=n)

    # 풀이 상자에서 미분으로 구한 답
    mu_hat = x.mean()  # μ̂ = (1/N) Σ x_i
    var_hat = np.mean((x - mu_hat) ** 2)  # σ̂² = (1/N) Σ (x_i - μ̂)²
    sigma_hat = math.sqrt(var_hat)
    print(f"[MLE] 진짜 μ={true_mu}, σ={true_sigma}  /  공식 μ̂={mu_hat:.4f}, σ̂={sigma_hat:.4f}")

    # 확인 1: 격자에서 로그 가능도가 가장 큰 곳을 찾아본다.
    mus = np.linspace(2.0, 4.0, 401)
    sigmas = np.linspace(1.5, 2.5, 401)
    ll_mu = np.array([gaussian_log_likelihood(x, m, sigma_hat) for m in mus])
    ll_sigma = np.array([gaussian_log_likelihood(x, mu_hat, s) for s in sigmas])
    print(f"[MLE] 격자 탐색   μ*={mus[ll_mu.argmax()]:.4f}, σ*={sigmas[ll_sigma.argmax()]:.4f}")

    # 확인 2: 경사 하강(4장에서 배울 방법, 여기서는 Adam)으로 NLL 을 내려 본다 (= 로그 가능도를 올린다).
    xt = torch.tensor(x)
    mu_p = torch.tensor(0.0, requires_grad=True)
    log_sigma_p = torch.tensor(0.0, requires_grad=True)  # σ > 0 을 지키려고 log σ 를 학습한다
    opt = torch.optim.Adam([mu_p, log_sigma_p], lr=0.05)
    for _ in range(2000):
        sigma_p = log_sigma_p.exp()
        nll = (0.5 * math.log(2 * math.pi) + log_sigma_p + (xt - mu_p) ** 2 / (2 * sigma_p**2)).mean()
        opt.zero_grad()
        nll.backward()
        opt.step()
    print(f"[MLE] 경사 하강   μ*={mu_p.item():.4f}, σ*={log_sigma_p.exp().item():.4f}")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.6))
    axes[0].plot(mus, ll_mu)
    axes[0].axvline(mu_hat, color="r", ls="--", label=f"sample mean = {mu_hat:.3f}")
    axes[0].set_xlabel(r"$\mu$")
    axes[0].set_ylabel("log-likelihood")
    axes[0].set_title(r"log L as a function of $\mu$ ($\sigma$ fixed)")
    axes[0].legend(fontsize=8)
    axes[1].plot(sigmas, ll_sigma)
    axes[1].axvline(sigma_hat, color="r", ls="--", label=f"sample std = {sigma_hat:.3f}")
    axes[1].set_xlabel(r"$\sigma$")
    axes[1].set_title(r"log L as a function of $\sigma$ ($\mu$ fixed)")
    axes[1].legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(fig_dir, "ch02-mle.png"), dpi=120)
    plt.close(fig)
# --8<-- [end:mle]


# --8<-- [start:losses]
def losses_are_nll(rng: np.random.Generator) -> None:
    # (1) 회귀: σ = 1 로 고정한 가우시안 NLL 과 MSE 의 관계
    y = torch.tensor(rng.normal(size=8))  # 정답
    y_hat = y + torch.tensor(rng.normal(scale=0.5, size=8))  # 모델의 예측 (조금 틀림)
    sigma = 1.0
    nll = (0.5 * math.log(2 * math.pi) + math.log(sigma) + (y - y_hat) ** 2 / (2 * sigma**2)).mean()
    mse = F.mse_loss(y_hat, y)
    print(f"[손실] 가우시안 NLL = {nll.item():.6f}")
    print(f"[손실] MSE/2 + ½log(2π) = {(mse / 2 + 0.5 * math.log(2 * math.pi)).item():.6f}  (같다)")

    # (2) 이진 분류: 베르누이 NLL 과 BCE
    t = torch.tensor([1.0, 0.0, 1.0, 1.0])  # 정답 (0 또는 1)
    p = torch.tensor([0.9, 0.2, 0.6, 0.99])  # 모델이 말한 '1 일 확률'
    bern_nll = -(t * torch.log(p) + (1 - t) * torch.log(1 - p)).mean()
    print(f"[손실] 베르누이 NLL = {bern_nll.item():.6f},  F.binary_cross_entropy = "
          f"{F.binary_cross_entropy(p, t).item():.6f}")

    # (3) 다중 분류: softmax + 범주형 NLL 과 F.cross_entropy
    logits = torch.tensor([[2.0, 1.0, 0.1], [0.5, 2.5, 0.3]])  # 신경망의 날 출력 (2 개 샘플, 3 개 범주)
    target = torch.tensor([0, 2])  # 정답 범주 번호
    probs = torch.exp(logits) / torch.exp(logits).sum(dim=1, keepdim=True)  # softmax
    cat_nll = -torch.log(probs[torch.arange(2), target]).mean()
    print(f"[손실] softmax 확률 = {[[round(v, 4) for v in row] for row in probs.tolist()]}")
    print(f"[손실] 범주형 NLL = {cat_nll.item():.6f},  F.cross_entropy = {F.cross_entropy(logits, target).item():.6f}")
# --8<-- [end:losses]


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)
    torch.manual_seed(args.seed)

    scale = 10 if args.quick else 1
    bayes_example(rng, n_people=1_000_000 // scale)
    law_of_large_numbers(rng, n_rolls=10_000 // scale, fig_dir=args.fig_dir)
    density_can_exceed_one(rng, n=20_000 // scale, fig_dir=args.fig_dir)
    gaussian_mle(rng, n=1_000, fig_dir=args.fig_dir)
    losses_are_nll(rng)


if __name__ == "__main__":
    main()
