神经网络是什么

从"函数拟合器"的角度理解，比从"模拟大脑"理解更准确。

三个视角

为什么"深"比"宽"更有效

• 理论上单隐层网络已能逼近任意连续函数（万能逼近定理），但可能需要指数级宽的神经元。
• 深层网络通过逐层复用特征（边缘 → 纹理 → 部件 → 物体）实现指数级的表达效率。
• 代价：梯度消失/爆炸、训练不稳定 —— 这正是残差连接、归一化、精细初始化要解决的问题。

和其他模型的关系

神经元与感知机

M-P 模型、单层感知机，以及它为什么搞不定 XOR。

人工神经元（M-P 模型）

• w（权重）：每个输入的重要程度，模型真正要学的参数。
• b（偏置）：让决策边界可以平移，否则超平面必须过原点。
• σ（激活）：引入非线性，否则多层网络等价于一层。

单层感知机

激活函数取符号函数 sign(z)，输出 ±1。学习规则非常简单：

解决方法：加一层

两层感知机（含一个隐层）即可表示任意形状的凸区域划分，从而解决 XOR。这也说明了非线性激活 + 多层堆叠是必要的：

# XOR 的手工解（ReLU 激活）
h1 = relu( x1 + x2 - 0.5 )     # 两个都为 1
h2 = relu( x1 + x2 - 1.5 )     # 抑制重复计数
y  = h1 - h2                   # 输出 0/1

激活函数大全

选错了不会报错，只会训不动 —— 这是最隐蔽的坑之一。

直观对比

怎么选

• 隐藏层默认 ReLU（CNN、MLP）；追求精度可试 GELU / SiLU。
• Transformer / BERT 类：用 GELU。
• RNN 门控：必须用 Sigmoid（需要 0~1 的"开关"）和 Tanh（需要 −1~1 的"信息"）。
• 输出层：二分类 Sigmoid，多分类 Softmax，回归任务不激活。

网络结构与参数量

看懂模型大小、显存占用从会算参数开始。

层级术语

• 输入层：原始特征，不算参数。
• 隐藏层：做特征提取的部分，深度 = 隐藏层数。
• 输出层：映射到任务目标（类别数 / 回归维度）。
• 全连接层（FC / Dense / Linear）：每个输出与所有输入相连。

全连接层参数量

例：784 → 128 → 10 的 MLP，参数量 = (784×128+128) + (128×10+10) = 101,770。

卷积层参数量

例：3×3 卷积，输入 64 通道、输出 128 通道 → (3×3×64+1)×128 = 73,856。 对比同等全连接（假设输入 64×32×32）会是数千万级。

张量形状记忆法

前向传播

输入从第一层流到最后一层，得到预测值并计算损失。

流程

1. 取一个 batch 数据 x；
2. 逐层计算 a(l) = σ(W(l)a(l-1) + b(l))，并缓存中间激活；
3. 输出层得到 ŷ；
4. 用损失函数算 L(ŷ, y)。

def forward(x, params):
    cache = []
    a = x
    for W, b, act in params:
        z = a @ W + b        # 线性变换
        a = act(z)           # 非线性激活
        cache.append((z, a)) # 反向传播要用！
    return a, cache

推理模式

• model.eval() + torch.no_grad()：关闭 Dropout、冻结 BatchNorm 统计量、不建计算图。
• 忘了切 eval 是"验证集指标莫名其妙很差"的经典原因。

损失函数

损失函数定义了"什么叫好"，选错它，训练就是在认真地优化一个错误目标。

为什么分类用交叉熵而不是 MSE

• MSE 配合 Sigmoid 输出时，梯度含 σ'(z) 因子，在预测严重错误（饱和区）时梯度反而趋近 0，学不动。
• 交叉熵 + Softmax 的梯度简洁漂亮：∂L/∂z = ŷ − y，误差越大梯度越大，修正越快。

损失不下降时怎么想

1. 先在一个极小数据集（如 20 个样本）上过拟合：如果连这个都做不到，说明是代码 bug 或结构问题，不是调参问题。
2. 能过拟合小数据但泛化差 → 过拟合，加正则化 / 增数据。
3. 小数据都过拟合不了 → 学习率太大 / 初始化有问题 / 数据标签错 / 梯度断掉。

反向传播

链式法则 + 动态规划。整个深度学习的引擎。

核心思想

要算损失对每一个参数的梯度，直接对每个参数单独求导是 O(N²) 的灾难。 反向传播利用链式法则，从输出层往输入层倒着走一遍，每层复用上一层的梯度，复杂度降到 O(N)。

四步记忆法

1. 算输出层误差：δL = ŷ − y（配合 Softmax+CE）。
2. 第 l 层权重梯度：∂L/∂W = δ(l) a(l-1)T。
3. 第 l 层偏置梯度：∂L/∂b = δ(l)（在一个 batch 上求和）。
4. 把误差往前传：δ(l-1) = W(l)Tδ(l) ⊙ σ′(z(l-1))。

def backward(x, y, params, cache):
    grads = [None] * len(params)
    m = x.shape[0]
    delta = (cache[-1][1] - y) / m          # 输出层误差
    for l in reversed(range(len(params))):
        a_prev = x if l == 0 else cache[l-1][1]
        grads[l] = (a_prev.T @ delta, delta.sum(0))
        if l > 0:
            delta = (delta @ params[l][0].T) * relu_grad(cache[l-1][0])
    return grads

梯度消失与爆炸

δ 往前传时要不断乘 WT 和 σ′：

• 若 |W| < 1 且 σ′ ≤ 1（Sigmoid 最大才 0.25），连乘后梯度指数级衰减 → 浅层几乎学不到东西。
• 若 |W| > 1，梯度指数级放大 → 数值溢出、训练发散。

解决手段：

优化器

梯度告诉我们往哪走，优化器决定怎么走、走多快。

Adam 的更新式

学习率调度

• Warmup：前几百/几千步从小学习率线性升到峰值 —— 训练 Transformer 几乎必需，否则初期直接崩。
• Cosine Decay：余弦衰减到 0，目前最常用的衰减曲线。
• Step Decay：每 N 个 epoch 乘 0.1，简单可靠，适合 CV。
• ReduceLROnPlateau：验证集指标不涨了就降学习率。

权重初始化

全零初始化为什么不行？因为对称性问题。

核心原则：保持方差

让信号在前向传播时激活值方差稳定、反向传播时梯度方差稳定，避免指数级放大或衰减。

# PyTorch 中正确初始化一个 ReLU 网络
for m in model.modules():
    if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
        nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
        if m.bias is not None:
            nn.init.zeros_(m.bias)

正则化与归一化

让模型从"背答案"变成"学规律"的一整套工具。

过拟合与欠拟合

常用正则化手段

归一化层对比

卷积神经网络 CNN

为图像而生的归纳偏置：局部性 + 权值共享 + 平移等变性。

卷积在做什么

用一个小窗口（卷积核）在输入上滑动，每步做一次点乘求和，得到一个特征图（feature map）。 不同的核检测不同的模式：边缘、角点、纹理……

三个核心超参

• 核大小 K：3×3 是黄金选择。两个 3×3 堆叠的感受野等于一个 5×5，但参数更少、非线性更多。
• 步幅 stride：滑动步长。stride=2 直接把分辨率减半，常用于替代池化下采样。
• 填充 padding：same 保持尺寸，valid 不填充。K=3 时 pad=1 保持尺寸。

输出尺寸公式

感受野

输出层一个像素能"看到"的输入区域大小。堆叠层数越深，感受野越大，语义层级越高：

浅层：边缘/颜色中层：纹理/部件深层：物体/语义

典型组件

一个极简 CNN

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(),
            nn.MaxPool2d(2),                                # 32x32 -> 16x16
            nn.Conv2d(32, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(),
            nn.MaxPool2d(2),                                # 16x16 -> 8x8
        )
        self.head = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(),
                                  nn.Linear(64, num_classes))
    def forward(self, x):
        return self.head(self.features(x))

循环网络 RNN / LSTM / GRU

处理序列：把"上一步的记忆"传给下一步。

基本 RNN

沿时间展开后就是一个很深的、每层参数相同的网络 —— 所以梯度消失问题格外严重， 基本 RNN 实际只能记住十几步以内的信息。

LSTM：用"门"保护记忆

核心是引入一条细胞状态 C（信息高速公路），用三个门控制读写：

GRU：精简版 LSTM

把遗忘门和输入门合并成一个更新门 z，去掉独立的细胞状态，参数减少约 1/3， 多数任务上与 LSTM 效果相当、训练更快。

改进方向

• 双向 Bi-RNN：同时从头到尾、从尾到头读一遍，拼接两个方向的隐状态（理解任务常用）。
• 多层堆叠：把下层隐状态作为上层输入。
• Encoder-Decoder + Attention：解决定长向量的信息瓶颈，直接演化出 Transformer。

注意力机制与 Transformer

"让模型自己决定该看哪里" —— 当代 AI 的地基。

Scaled Dot-Product Attention

• Q（Query）：我在找什么；K（Key）：我能提供什么；V（Value）：我实际的内容。
• 本质是"按相似度做加权平均查表"，复杂度 O(n²·d)。

多头注意力

把 d 维切成 h 个头并行做注意力，每个头可以关注不同的关系模式（句法、指代、位置……），最后拼接再线性变换。

Transformer Block 结构

x → LayerNorm → MultiHeadAttention → 残差加 → x
  → LayerNorm → FFN(升维4倍→GELU→降维) → 残差加 → out

• 残差连接是深层 Transformer 能训起来的关键（Pre-LN 比 Post-LN 更稳，现代模型普遍用 Pre-LN + RMSNorm）。
• 位置编码：注意力本身对顺序无感。绝对正弦编码 / 可学习编码 / RoPE 旋转位置编码（LLaMA 系）。
• 因果掩码：解码器里屏蔽未来位置，保证自回归。

三条演化路线

复杂度与优化

标准注意力的时间和显存都是 O(n²)，这是长上下文的根本瓶颈。常见优化：

经典架构速查

一张表记住视觉到语言的主干脉络。

迁移学习：几乎总是正确选择

1. 用 ImageNet / 大规模语料预训练的权重初始化；
2. 替换最后的分类头为新任务的输出维度；
3. 先冻结骨干只训分类头（几个 epoch）；
4. 再解冻全部用很小学习率（如 1e-5）微调；
5. 数据极少时，也可只做线性探测（Linear Probe）。

训练流程与调参清单

一份可以直接照着做的 checklist。

标准训练循环

for epoch in range(epochs):
    model.train()
    for x, y in train_loader:
        x, y = x.to(device), y.to(device)
        optimizer.zero_grad()          # 1. 清梯度
        logits = model(x)              # 2. 前向
        loss = criterion(logits, y)    # 3. 算损失
        loss.backward()                # 4. 反向
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # 5. 可选裁剪
        optimizer.step()               # 6. 更新
    scheduler.step()                   # 7. 学习率调度
    model.eval()                       # 8. 验证（务必切 eval）
    with torch.no_grad():
        ...

调参优先级（从高到低）

1. 学习率 —— 影响最大，先做 LR Range Test 找一个数量级。
2. 数据与增强 —— 加高质量数据往往胜过任何调参。
3. 模型容量 —— 欠拟合就加深加宽，过拟合就加正则。
4. Batch size —— 在显存允许范围内尽量大，配合相应学习率。
5. 优化器与调度 —— AdamW + cosine + warmup 是稳妥默认。
6. 正则强度 —— weight decay、dropout 最后微调。

超参速查表

NumPy 手写一个小网络

约 60 行，跑通 MNIST 级别任务。理解原理最好的方式就是写一遍。

import numpy as np

def relu(z):      return np.maximum(0, z)
def relu_g(z):    return (z > 0).astype(np.float32)
def softmax(z):
    e = np.exp(z - z.max(1, keepdims=True))   # 防溢出
    return e / e.sum(1, keepdims=True)

class MLP:
    def __init__(self, dims, seed=0):
        rng = np.random.default_rng(seed)
        self.W, self.b = [], []
        for din, dout in zip(dims[:-1], dims[1:]):
            # He 初始化：保持方差
            self.W.append(rng.normal(0, np.sqrt(2./din), (din, dout)))
            self.b.append(np.zeros(dout))

    def forward(self, x):
        self.a = [x]
        for W, b in zip(self.W[:-1], self.b[:-1]):
            self.a.append(relu(self.a[-1] @ W + b))
        self.logits = self.a[-1] @ self.W[-1] + self.b[-1]
        return softmax(self.logits)

    def backward(self, y):
        n = y.shape[0]
        p = softmax(self.logits)
        p[np.arange(n), y] -= 1
        delta = p / n                              # CE + softmax 的优雅梯度
        for l in reversed(range(len(self.W))):
            self.dW = getattr(self, "dW", [])
            gW = self.a[l].T @ delta
            gb = delta.sum(0)
            if l > 0:
                delta = (delta @ self.W[l].T) * relu_g(self.a[l])
            self.dW.insert(0, (gW, gb))
        return self.dW

    def step(self, lr):
        for (W, b), (gW, gb) in zip(zip(self.W, self.b), self.dW):
            W -= lr * gW
            b -= lr * gb
        self.dW = []

# ---- 训练 ----
net = MLP([784, 256, 128, 10])
for epoch in range(10):
    for xb, yb in batches(X, y, size=64):
        net.forward(xb)
        net.backward(yb)
        net.step(lr=0.1)
    acc = (net.forward(X_test).argmax(1) == y_test).mean()
    print(f"epoch {epoch}: test acc = {acc:.4f}")

常见坑与调试技巧

这些错误 90% 的人都会踩一遍。

调试工具箱

• 打印张量统计：每层的 mean / std / min / max，是发现梯度消失最快的方式。
• 梯度范数监控：torch.nn.utils.clip_grad_norm_ 返回值就是裁剪前的范数。
• TensorBoard / WandB：把损失、准确率、学习率、梯度直方图全部记下来。
• 可视化中间特征：CNN 看特征图，Transformer 看注意力权重。
• 单元测试式验证：用形状已知的小张量过一遍网络，确认维度变化符合预期。

名词速查表

看到缩写不认识时来这里。