2014 - Goodfellow 生成對抗網路（GAN，造假者的博弈）#

# 純 Python 實作：玩具 1D 高斯分佈的簡化 GAN 訓練（離散化 32 bins）
import math, random

random.seed(42)

K, LO, HI = 32, -4.0, 4.0
w = (HI - LO) / K                     # bin 寬度

def bin_of(x):                        # 樣本落在哪個 bin
    return max(0, min(K-1, int((x-LO)/w)))

def sample_gauss():                   # 真資料：N(0,1)
    u1, u2 = random.random(), random.random()
    return math.sqrt(-2*math.log(u1))*math.cos(2*math.pi*u2)

def Phi(t):                           # 常態 CDF
    return 0.5*(1+math.erf(t/math.sqrt(2)))

p_data = [Phi((j+1)*w+LO) - Phi(j*w+LO) for j in range(K)]   # 每個 bin 的真實機率
s = sum(p_data)
p_data = [p/s for p in p_data]

logits = [0.0]*K                      # 生成器：softmax 機率向量的 logits
d_logits = [0.0]*K                    # 判別器：每個 bin 一個 sigmoid 分數

def softmax(l):
    m = max(l)
    e = [math.exp(v-m) for v in l]
    s = sum(e)
    return [v/s for v in e]

def dsig(j):
    a = max(-30.0, min(30.0, d_logits[j]))
    return 1/(1+math.exp(-a))

def sample_from(p):                   # 從 p_g 抽一個 bin
    r, c = random.random(), 0.0
    for i, v in enumerate(p):
        c += v
        if r < c:
            return i
    return K-1

def acc(n=2000):
    c = 0
    for _ in range(n):
        p = softmax(logits)
        if dsig(bin_of(sample_gauss())) > 0.5: c += 1     # 真：應判 1
        if dsig(sample_from(p)) < 0.5: c += 1             # 假：應判 0
    return 100.0*c/(2*n)

print("玩具 GAN：離散化 1D 高斯（32 bins）的博弈糾纏")
lrd, lrg = 1.0, 2.0
for ep in range(1, 601):
    p = softmax(logits)
    for j in range(K):                # D 學習：逐 bin BCE 的期望梯度
        d_logits[j] += lrd * ((1-dsig(j))*p_data[j] - dsig(j)*p[j])
    p = softmax(logits)
    Elog = sum(p[j]*math.log(dsig(j)+1e-9) for j in range(K))
    for i in range(K):                # G 學習：dL/dlogit_i = p_i*(E[log d] - log d_i)
        logits[i] -= lrg * p[i] * (Elog - math.log(dsig(i)+1e-9))
    if ep in (1, 50, 150, 300, 600):
        print(f"  epoch {ep:>3}: 判別器準確度 = {acc():5.1f}%")

p = softmax(logits)
js = 0.5*sum(p[j]*math.log(p[j]/p_data[j]+1e-9) for j in range(K))    + 0.5*sum(p_data[j]*math.log(p_data[j]/p[j]+1e-9) for j in range(K))
print(f"\n收斂後：判別器準確度 = {acc(3000):5.1f}%（接近 50% = 分不出真假）")
print(f"Jensen–Shannon 散度 ≈ {js:.4f}（0 = 分佈完全相同）")
for j in range(6):
    print(f"  bin {j} [{LO+j*w:+.1f},{LO+(j+1)*w:+.1f}): p_g={p[j]:.4f}  p_data={p_data[j]:.4f}")

玩具 GAN：離散化 1D 高斯（32 bins）的博弈糾纏
  epoch   1: 判別器準確度 =  75.4%
  epoch  50: 判別器準確度 =  64.0%
  epoch 150: 判別器準確度 =  52.1%
  epoch 300: 判別器準確度 =  50.8%
  epoch 600: 判別器準確度 =  51.2%

收斂後：判別器準確度 =  51.0%（接近 50% = 分不出真假）
Jensen–Shannon 散度 ≈ 0.0092（0 = 分佈完全相同）
  bin 0 [-4.0,-3.8): p_g=0.0010  p_data=0.0001
  bin 1 [-3.8,-3.5): p_g=0.0010  p_data=0.0001
  bin 2 [-3.5,-3.2): p_g=0.0011  p_data=0.0003
  bin 3 [-3.2,-3.0): p_g=0.0011  p_data=0.0008
  bin 4 [-3.0,-2.8): p_g=0.0013  p_data=0.0016
  bin 5 [-2.8,-2.5): p_g=0.0018  p_data=0.0032