필사 모드: AI 数学完全指南 — 从线性代数到信息论

import numpy as np

# 单个神经元 = 向量内积
weights = np.array([0.5, -0.3, 0.8])  # 权重
inputs = np.array([1.0, 2.0, 3.0])     # 输入
bias = 0.1

output = np.dot(weights, inputs) + bias
# 0.5*1.0 + (-0.3)*2.0 + 0.8*3.0 + 0.1 = 2.5

# 整个层 = 矩阵乘法
W = np.random.randn(4, 3)  # 3 → 4 个神经元
x = np.random.randn(3)      # 输入向量
h = W @ x                    # 矩阵-向量乘 = 层输出

# 用向量表示单词(Word Embedding)
king = np.array([0.8, 0.2, 0.9, -0.5])
queen = np.array([0.7, 0.8, 0.85, -0.4])
man = np.array([0.9, 0.1, 0.5, -0.6])
woman = np.array([0.8, 0.7, 0.45, -0.5])

# king - man + woman ≈ queen(著名的关系!)
result = king - man + woman
print(f"king - man + woman = {result}")
print(f"queen              = {queen}")
# 几乎相同!

# 余弦相似度 — 两个向量有多相似
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

print(cosine_similarity(result, queen))  # ~0.95(非常相似!)

# Transformer 的 Self-Attention 也是矩阵乘法!
# Q, K, V = 输入乘以权重矩阵所得
batch_size, seq_len, d_model = 2, 10, 64

X = np.random.randn(batch_size, seq_len, d_model)
W_Q = np.random.randn(d_model, d_model)
W_K = np.random.randn(d_model, d_model)
W_V = np.random.randn(d_model, d_model)

Q = X @ W_Q  # Query: (2, 10, 64)
K = X @ W_K  # Key:   (2, 10, 64)
V = X @ W_V  # Value: (2, 10, 64)

# Attention Score = Q × K^T / √d
scores = Q @ K.transpose(0, 2, 1) / np.sqrt(d_model)
# scores shape: (2, 10, 10) — 每个 token 对其他 token 的 attention

# PCA: 找出数据的主要方向
from sklearn.decomposition import PCA

# 100 维数据 → 降到 2 维
data = np.random.randn(1000, 100)
pca = PCA(n_components=2)
reduced = pca.fit_transform(data)

# 内部实际发生的事:
# 1. 计算协方差矩阵: C = X^T X / n
# 2. 特征值分解: C = V Λ V^T
# 3. 选出最大特征值对应的特征向量
# → 数据方差最大的方向!

# SVD(奇异值分解) — 用于 LLM 压缩!
# LoRA 正是如此: 把一个大矩阵分解成两个小矩阵

W = np.random.randn(768, 768)  # GPT-2 的 attention weight

# SVD: W = U × Σ × V^T
U, S, Vt = np.linalg.svd(W)

# 只保留前 r 个即可近似(LoRA 的原理!)
r = 16  # rank
W_approx = U[:, :r] @ np.diag(S[:r]) @ Vt[:r, :]

# 原始: 768×768 = 589,824 个参数
# LoRA: 768×16 + 16×768 = 24,576 个参数(仅 4%!)
error = np.linalg.norm(W - W_approx) / np.linalg.norm(W)
print(f"Rank-{r} 近似误差: {error:.4f}")

# f(x, y) = x² + 2xy + y²
# ∂f/∂x = 2x + 2y(把 y 当作常数)
# ∂f/∂y = 2x + 2y(把 x 当作常数)

def f(x, y):
    return x**2 + 2*x*y + y**2

def df_dx(x, y):
    return 2*x + 2*y  # x 方向的梯度

def df_dy(x, y):
    return 2*x + 2*y  # y 方向的梯度

# 梯度向量(Gradient)
gradient = np.array([df_dx(3, 2), df_dy(3, 2)])
print(f"∇f(3,2) = {gradient}")  # [10, 10]
# → 沿这个方向的反方向走, 函数值就会减小!

# y = f(g(x)) → dy/dx = df/dg × dg/dx

# 在神经网络中:
# Loss = CrossEntropy(softmax(Wx + b), target)
# dLoss/dW = dLoss/dsoftmax × dsoftmax/d(Wx+b) × d(Wx+b)/dW

# PyTorch 会自动完成这一切!
import torch

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
W = torch.randn(2, 3, requires_grad=True)
b = torch.randn(2, requires_grad=True)

# Forward
h = W @ x + b
loss = h.sum()

# Backward(链式法则自动应用!)
loss.backward()

print(f"dLoss/dW = {W.grad}")  # 自动微分!
print(f"dLoss/db = {b.grad}")
print(f"dLoss/dx = {x.grad}")

# 损失函数: L(w) = (w - 3)²
# 最小值: w = 3

def loss(w):
    return (w - 3) ** 2

def grad(w):
    return 2 * (w - 3)

# 梯度下降法
w = 10.0  # 起点(离得很远)
lr = 0.1  # 学习率

for step in range(20):
    g = grad(w)
    w = w - lr * g  # 沿梯度的反方向移动!
    if step % 5 == 0:
        print(f"Step {step}: w={w:.4f}, loss={loss(w):.4f}")

# Step 0:  w=8.6000, loss=31.3600
# Step 5:  w=3.2150, loss=0.0462
# Step 10: w=3.0070, loss=0.0000
# Step 15: w=3.0002, loss=0.0000
# → w 收敛到 3!

lr 过大时:
  w: 10 → -4 → 18 → -22 → 发散!

lr 过小时:
  w: 10 → 9.86 → 9.72 → ... → 100 万步之后 → 3.001

合适的 lr:
  w: 10 → 8.6 → 7.48 → ... → 20 步之后 → 3.0002

# Adam = Momentum + RMSprop(现代深度学习标准)
class Adam:
    def __init__(self, params, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
        self.lr = lr
        self.beta1 = beta1  # 动量(惯性)
        self.beta2 = beta2  # 梯度平方的移动平均
        self.eps = eps
        self.m = {id(p): 0 for p in params}  # 一阶矩
        self.v = {id(p): 0 for p in params}  # 二阶矩
        self.t = 0

    def step(self, params, grads):
        self.t += 1
        for p, g in zip(params, grads):
            pid = id(p)
            # 动量: 记住之前梯度的方向
            self.m[pid] = self.beta1 * self.m[pid] + (1 - self.beta1) * g
            # 自适应学习率: 根据梯度大小调整
            self.v[pid] = self.beta2 * self.v[pid] + (1 - self.beta2) * g**2
            # 偏差修正
            m_hat = self.m[pid] / (1 - self.beta1**self.t)
            v_hat = self.v[pid] / (1 - self.beta2**self.t)
            # 更新
            p -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps)

# GPT 的输出 = 下一个 token 的概率分布
logits = np.array([2.0, 1.0, 0.1, -1.0, 3.0])  # 模型输出(原始值)
vocab = ["the", "cat", "sat", "on", "mat"]

# Softmax: logits → 概率
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 数值稳定性
    return exp_x / exp_x.sum()

probs = softmax(logits)
for word, p in zip(vocab, probs):
    print(f"  {word}: {p:.4f}")
# the: 0.2312, cat: 0.0851, sat: 0.0346, on: 0.0115, mat: 0.6276
# → "mat" 的概率最高!

# P(A|B) = P(B|A) × P(A) / P(B)
# "在看到数据的情况下, 模型正确的概率"

# 例: 垃圾邮件过滤器
# P(垃圾邮件|"免费") = P("免费"|垃圾邮件) × P(垃圾邮件) / P("免费")
p_free_given_spam = 0.8    # 垃圾邮件中出现"免费"的概率
p_spam = 0.3               # 全部邮件中垃圾邮件所占比例
p_free = 0.35              # 全部邮件中出现"免费"的概率

p_spam_given_free = (p_free_given_spam * p_spam) / p_free
print(f"P(垃圾邮件|'免费') = {p_spam_given_free:.2f}")  # 0.69(69%!)

# 高斯(正态)分布 — Diffusion Model 的核心!
def gaussian(x, mu=0, sigma=1):
    return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)

# DDPM(图像生成):
# Forward: 干净图像 → 加入高斯噪声(逐渐破坏)
# Reverse: 噪声 → 去除噪声(神经网络学习这一过程) → 干净图像!

# 加噪过程
def add_noise(image, t, noise_schedule):
    """x_t = √(α_bar_t) × x_0 + √(1 - α_bar_t) × ε"""
    alpha_bar = noise_schedule[t]
    noise = np.random.randn(*image.shape)  # 高斯噪声
    noisy = np.sqrt(alpha_bar) * image + np.sqrt(1 - alpha_bar) * noise
    return noisy, noise

# 衡量模型的预测与正确答案之间的差异
def cross_entropy(predictions, targets):
    """H(p, q) = -Σ p(x) log q(x)"""
    return -np.sum(targets * np.log(predictions + 1e-9))

# 正确答案: "cat"(独热编码)
target = np.array([0, 1, 0, 0, 0])  # [the, cat, sat, on, mat]

# 好的预测
good_pred = np.array([0.05, 0.85, 0.03, 0.02, 0.05])
print(f"Good: {cross_entropy(good_pred, target):.4f}")  # 0.1625(低)

# 差的预测
bad_pred = np.array([0.3, 0.1, 0.2, 0.2, 0.2])
print(f"Bad:  {cross_entropy(bad_pred, target):.4f}")  # 2.3026(高)

def entropy(probs):
    """H(X) = -Σ p(x) log₂ p(x)"""
    return -np.sum(probs * np.log2(probs + 1e-9))

# 均匀硬币: H = 1 bit(最大不确定性)
fair_coin = np.array([0.5, 0.5])
print(f"均匀硬币: {entropy(fair_coin):.2f} bits")  # 1.00

# 有偏硬币: H 小于 1 bit(可预测)
biased_coin = np.array([0.9, 0.1])
print(f"有偏硬币: {entropy(biased_coin):.2f} bits")  # 0.47

# GPT 输出的熵越低 → 说明模型越确信
# 提高 Temperature → 熵增加 → 输出更多样化

def kl_divergence(p, q):
    """D_KL(P || Q) = Σ p(x) log(p(x) / q(x))"""
    return np.sum(p * np.log(p / (q + 1e-9) + 1e-9))

# 在 VAE(Variational Autoencoder)中:
# 最小化 KL(q(z|x) || p(z))
# = 让编码器的输出分布趋近于标准正态分布!

# 在 RLHF 中:
# 把 KL(π_new || π_ref) 作为惩罚项加入
# = 让新模型不要偏离原模型太远!

[第 1 周] 线性代数基础
  → 向量、矩阵乘法、转置、逆矩阵
  → 用 numpy 亲手实现

[第 2 周] 微积分 + 优化
  → 偏导数、链式法则、梯度下降法
  → 理解 PyTorch autograd

[第 3 周] 概率 + 统计
  → 条件概率、贝叶斯、分布
  → 实现 softmax、cross-entropy

[第 4 周] 信息论 + 实战
  → 熵、KL-divergence
  → 在 nanoGPT/DDPM 代码中找出这些数学