AI浪潮下的小小避风港

CS231n——Lecture6 卷积神经网络架构

2026-06-02T16:00:00.000Z

CS231n——Lecture5 基于CNN的图像分类

2026-06-02T08:58:43.000Z

# 第一部分回顾：深度学习基础（Lecture2—Lecture4）

在进入卷积网络之前，先回顾前几讲建立的深度学习基础框架。

# 图像分类与线性分类器

第一步是定义问题：输入一张图像（展开为张量），输出一个分数向量，表示各标签与图像的匹配程度。通过权重矩阵 $W$ 进行预测：

$f(x, W) = Wx$

问题由此转化为：如何选择一个好的 $W$ ？ 这便引入了损失函数。

# 损失函数

损失函数告诉我们：给定权重矩阵 $W$ 与数据集，这个 $W$ 在解决当前问题上表现如何。常用损失函数包括：

多分类 SVM 损失（Hinge Loss）： $L_i = \sum_{j \neq y_i} \max(0, s_j - s_{y_i} + \Delta)$
Softmax 损失（交叉熵损失）： $L_i = -\log\left(\frac{e^{s_{y_i}}}{\sum_j e^{s_j}}\right)$

现在我们有了问题定义（线性分类器）和评判标准（损失函数），但还需要找到一个好的解决方案——这引出了优化。

# 优化

将优化环境想象成高维空间中的一个曲面：x 轴（或整个平面）上的每个点对应一组权重 $W$ ，y 轴是损失函数值。损失越高说明模型越差，所以优化的目标是让损失往下滑，在曲面的最低点附近找到一组权重。

常用优化算法沿以下路线演进：

方法	核心改进
SGD	用 mini-batch 梯度近似全量梯度，解决计算效率
SGD + Momentum	引入速度/惯性，冲过鞍点和局部极小值
RMSProp	逐参数自适应学习率，解决病态条件
Adam	动量 + 自适应学习率 + 偏差修正，全能选手
AdamW	Adam + 解耦权重衰减，当前主流默认选择

# 线性分类器的局限

线性分类器本质上需要为每个类别总结出一个模板。当同一类别在特征空间中呈现多模态分布（如分布在两个相对象限中），单个模板无法同时覆盖——这正是线性分类器无法处理奇偶分布、同心圆等问题的根本原因。

# 神经网络的引入

将两个权重矩阵叠加，并在中间插入非线性激活函数：

$f(x, W_1, W_2) = W_2 \max(0, W_1 x)$

这一简单的改动赋予了模型非线性分类能力。关键在于：如果去掉中间的 $\max(0, \cdot)$ ， $W_2 W_1$ 退化为单个矩阵 $W_3$ ，又变回线性分类器。堆叠任意多层线性变换，等价于一层线性变换——表达能力没有一丝提升。非线性激活函数的最核心作用永远是：引入非线性。

# 计算图与反向传播

为了优化模型参数，需要计算损失函数对每个权重的梯度。计算图正是为此而设计：它是一个有向无环图（DAG），节点是运算步骤，边是数据流。

前向传播：数据从左往右流，经过各中间节点，最终算出损失
反向传播：一旦算出损失，从右往左沿图回溯，使用链式法则自动计算每个节点的梯度

核心公式极为简洁：

$\text{下游梯度} = \text{上游梯度} \times \text{局部梯度}$

重要的形状法则：上游梯度总是与输出形状相同，下游梯度总是与输入形状相同。维度分析即可推导出任何张量运算的反向传播，无需死记公式。

# 完整流程总结

对于任意待解决的问题：

将输入编码为张量
写出计算图，计算输出张量
收集数据集，定义损失函数
使用梯度下降优化损失，通过反向传播自动计算梯度

这套流程基本支撑了所有深度学习应用。

# 图像特征表示 Image Features

# 为什么需要特征？

实际上，神经网络的输入不一定非得是原始像素。我们可以定义一些其他类型的函数来提取特征——将原始图像的像素值转化为更有意义的表示，再送入线性分类器。

两个经典的例子：

颜色直方图 Color Histogram：将所有像素按颜色值归类到具体的桶（bucket）中，只统计颜色分布，完全忽略空间位置信息。比如一张蓝天的图片，蓝色像素占比会远高于其他颜色。

定向梯度直方图 Histogram of Oriented Gradients (HOG)：丢弃颜色信息，只关注图像中的结构信息——计算每个局部区域中边缘的方向分布。它关注的是"这个区域有怎样的边缘走向"，而不是"这个区域是什么颜色"。

# 特征提取 + 分类器的组合范式

在深度学习兴起之前，计算机视觉的主流范式是：

手动设计特征提取器（颜色直方图、HOG、SIFT 等）
将多种特征堆叠拼接成一个特征向量
将特征向量送入线性分类器（如 SVM）

好的特征表示需要大量领域知识和工程经验。问题在于：作为人类，很难手写完美的特征提取器——数据本身和端到端的学习往往能做得更好。

# 端到端神经网络

神经网络的思路完全不同：

输入：原始像素值
输出：预测分数
整个系统通过梯度下降从训练数据中自动学习所有参数

不需要手动设计特征——网络自己学习需要提取哪些特征。问题变成了：如何设计神经网络架构？ 即决定运算符的序列和中间张量的大小。

# 从全连接层到卷积层

# 全连接层的局限

回顾全连接层（Fully Connected Layer）：将 CIFAR-10 图像（ $32 \times 32 \times 3 = 3072$ 维）展开成一维向量，与权重矩阵 $W \in \mathbb{R}^{10 \times 3072}$ 做矩阵乘法，得到 10 个类别的预测分数。

全连接层的底层原理是向量点积：两个向量方向接近时点积结果高，正交时结果为零（或很小）。每一行权重可视为该类别的"模板"。

致命的缺陷：将图像压扁成一维向量，完全损失了空间结构。一个像素与它上下左右的像素之间的空间关系在压扁后荡然无存——左邻像素和右邻像素在 3072 维向量中相隔 32 个位置，与一个完全无关的远处像素相邻。

# 如何尊重二维信息？

这就是卷积神经网络 CNN 的诞生原因。

CNN 的核心洞察：图像具有平移不变性。一只猫在图像偏左还是偏右的位置，它仍然是猫。全连接层会把"左上角的猫"和"右下角的猫"视为完全不同的输入模式，需要分别学习——这极其浪费。卷积层通过参数共享直接内置了这一归纳偏置：同一个滤波器在整个图像上滑动检测，无论特征出现在哪个位置。

# 卷积层 Convolutional Layer

# 基本思想：局部连接 + 参数共享

卷积层改变了全连接层的连接方式：

全连接层：每个输出神经元连接所有输入像素，权重数量 $C_{in} \times H \times W \times C_{out}$
卷积层：每个滤波器只看输入的一小部分（局部感受野），同一个滤波器在整个图像上滑动并共享权重，权重数量仅 $C_{out} \times C_{in} \times K_h \times K_w$

# 卷积运算的直观过程

将一个 $5 \times 5 \times 3$ 的小滤波器（filter / kernel）滑动到输入图像上的某个位置，计算该滤波器与该位置图像片段的逐元素乘积之和（即点积），得到一个标量。这个标量衡量了该位置与滤波器的"匹配程度"——值越大，说明该区域越符合滤波器检测的模式。

然后重复这个过程：将小滤波器滑动到输入图像上的每一个可能位置，计算并收集所有匹配分数，排列成一个二维网格 $28 \times 28 \times 1$ （称为激活图 Activation Map 或 特征图 Feature Map）。

单个滤波器只能检测一种模式（如边缘、纹理、颜色对比等）。要检测多种模式，需要多个滤波器：

第二个 $5 \times 5 \times 3$ 滤波器做同样的事，生成另一张 $28 \times 28 \times 1$ 的特征图
以此类推，添加任意数量的滤波器
将所有特征图沿深度方向堆叠，得到一个三维张量 $28 \times 28 \times C_{out}$

每个卷积层还会添加一个偏置项（每个滤波器一个标量偏置），为非线性变换提供灵活性。

# 卷积层的定义

卷积层的关键运算符：

输入：一张图像 + 一组滤波器（随机初始化）

超参数：滤波器数量 $C_{out}$ （输出通道数）、滤波器尺寸 $K_h \times K_w$

与全连接层相同，卷积层输出后必须接非线性激活函数（如 ReLU），否则多个卷积层的叠加仍等价于一层线性变换。

# 批量处理：四维张量

实际操作中我们处理的是一批图像（mini-batch）：

张量	维度	含义
输入	$N \times C_{in} \times H \times W$	一批图像（N 张）
滤波器	$C_{out} \times C_{in} \times K_h \times K_w$	一组滤波器
输出	$N \times C_{out} \times H' \times W'$	一批输出特征图

# 空间维度计算

卷积后特征图的空间尺寸由三个因素决定：

不填充，步幅为 1：

$H' = H - K + 1$

例如： $32 \times 32$ 的输入， $5 \times 5$ 的卷积核 → $28 \times 28$ 的输出。

带零填充 Zero Padding：

在图像边界外添加 $P$ 圈零值像素，使输出尺寸可控：

$H' = H - K + 1 + 2P$

如果需要输出尺寸与输入相同（ $H' = H$ ），设置 $P = (K-1)/2$ 。这也是 $K$ 通常取奇数（3, 5, 7）的原因——保证填充为整数。

带步幅 Stride：

默认滤波器每次滑动 1 步。将步幅设为 $S$ 可以加速卷积、减少计算量：

$H' = \frac{H - K + 2P}{S} + 1$

通用公式（三个参数同时出现，通常不引入膨胀）：

$H' = \left\lfloor \frac{H - K + 2P}{S} \right\rfloor + 1$

其中 $\lfloor \cdot \rfloor$ 表示下取整——当 $(H - K + 2P)$ 不能被 $S$ 整除时，多余的边缘像素直接丢弃。

# 感受野 Receptive Field

为什么更深的层能"看到"更大的结构？

卷积层每一层的输出神经元只查看输入的本地区域。但经过堆叠后，感受野会被逐层放大：

第一层：一个神经元能看到 $K \times K$ 的原始输入区域
第二层：一个神经元能看到 $K \times K$ 的第一层输出区域 → 对应 $(2K-1) \times (2K-1)$ 的原始输入区域
第三层：对应 $(3K-2) \times (3K-2)$ 的原始输入区域

这种逐层扩大的效应使得：浅层学习边缘和纹理等局部特征，深层学习语义和整体结构等全局特征。

# $1 \times 1$ 卷积

当 $K = 1$ 时，卷积核退化为一个"逐点"操作——它不混合空间信息，仅在通道维度上做线性组合。 $1 \times 1$ 卷积本质上是一个作用于每个像素位置的全连接层，常用于：

降维/升维：减少或增加通道数，相比于大核卷积极大幅度减少参数量
增加非线性：在 $1 \times 1$ 卷积后接 ReLU，在不改变空间尺寸的前提下增强模型表达能力
是 ResNet 瓶颈结构（Bottleneck Block）和 Inception 架构的核心构件

# 卷积的其他变体

除了标准的二维卷积，同一原理可以推广到不同维度：

类型	输入维度	卷积核维度	典型应用
1D 卷积	$N \times C \times L$	$C \times K$	序列数据（文本、音频、时间序列）
2D 卷积	$N \times C \times H \times W$	$C \times K_h \times K_w$	图像处理
3D 卷积	$N \times C \times D \times H \times W$	$C \times K_d \times K_h \times K_w$	视频分析、医学影像（CT/MRI）

膨胀卷积 Dilated Convolution：在滤波器元素之间插入空洞（dilation rate $d$ ），在不增加参数的前提下指数级扩大感受野。例如一个 $3 \times 3$ 卷积核，膨胀率 $d = 2$ 时感受野等效于 $5 \times 5$ 。常用于语义分割和需要大感受野的密集预测任务。

分组卷积 Grouped Convolution：将输入通道分为 $G$ 组，每组独立进行卷积，最后拼接输出。它将参数量和计算量同时降为 $1/G$ 。分组卷积的思想最早在 AlexNet 中被用于多 GPU 训练，后来成为 MobileNet（深度可分离卷积）、ResNeXt 等高效/高性能架构的核心设计。

深度可分离卷积 Depthwise Separable Convolution：分组卷积的极端形式—— $G = C_{in} = C_{out}$ ，即每个通道分配一个独立的 $K \times K \times 1$ 滤波器。计算量约为标准卷积的 $1/K^2 + 1/C_{out}$ 倍，是 MobileNet/Xception 等移动端网络的基石。

# 卷积层参数计算

以输入 $32 \times 32 \times 3$ ，卷积层 $6$ 个 $5 \times 5$ 滤波器，步幅 1，无填充为例：

每个滤波器参数： $5 \times 5 \times 3 + 1 = 76$ （权重 + 偏置）
总参数量： $76 \times 6 = 456$
输出维度： $28 \times 28 \times 6$
总连接数（乘加运算）： $28 \times 28 \times 6 \times (5 \times 5 \times 3) = 1,764,000$

# 池化层 Pooling Layer

# 为什么需要池化？

步幅卷积是下采样的一种方式，但它需要学习参数且计算量较大。池化层提供了另一种更轻量的下采样方法——无参数、计算简单、天然带上采样能力。

# 最大池化 Max Pooling

最常见的池化方式：将特征图划分为多个不重叠区域（如 $2 \times 2$ ），每个区域取最大值作为输出。

最大池化的两个核心作用：

降维：空间尺寸变为原来的一半（ $2 \times 2$ 池化），减少计算量和内存
引入平移不变性：小范围平移不会改变最大值的结果，网络对位置的微小变化更鲁棒

池化是一个早已存在的信号处理方法，只是被重新发现并整合进了深度学习管道中。

# 池化的设计约定

不使用填充：池化层的核心目的是降维，加零填充与其目的相悖
最常见设置： $2 \times 2$ 区域、步幅 2（相当于无重叠的 $2 \times 2$ 窗口）
池化区域尺寸与步幅相等：默认就是不重叠的；如果步幅小于池化区域，就有重叠

# 平均池化 Average Pooling

取每个区域的平均值而非最大值。历史上曾广泛使用，但目前在分类网络中已大部分被最大池化取代。

一个重要区别：如果用平均池化取代最大池化，需要紧接着引入非线性激活函数，因为取均值是线性运算。而最大池化取的是 $\max$ ，本身已经带非线性，不需要额外的激活。

# 池化层的形状公式

将池化视为一种"特殊的卷积"：

$H' = \frac{H - K}{S} + 1$

其中池化窗口尺寸 $K$ 通常等于步幅 $S$ （ $K=S=2$ 是最常见配置），因此：

$H' = \frac{H}{2}$

# 其他池化方法

方法	说明
最大池化 Max Pooling	取区域最大值，自带非线性，最常用
平均池化 Average Pooling	取区域平均值，需要额外非线性激活
全局平均池化 Global Average Pooling	取整张特征图的最大值，常用于 CNN 末端替代全连接层
全局平均池化 Global Average Pooling	取整张特征图的平均值，将 $H \times W \times C$ 压缩为 $1 \times 1 \times C$ ，直接接分类器，极大减少参数量

# 输入尺寸不统一怎么办？

调整至同一大小：将所有输入图像 resize 到固定尺寸
填充：较小的图像用零或其他值填充至统一大小
自适应池化：在 CNN 末端使用全局平均池化（Global Average Pooling），无论输入特征图多大，输出固定为 $1 \times 1 \times C$ ，自然消除了尺寸不统一的问题

# CNN 架构设计

# 典型架构模式

池化层与卷积层交替插入到网络中：

$\text{INPUT} \to [\text{CONV} \to \text{ReLU}]_N \to \text{POOL} \to [\text{CONV} \to \text{ReLU}]_M \to \text{POOL} \to \text{FC} \to \text{FC}$

一个更具体的视觉模式：

$32 \times 32 \times 3 \xrightarrow{\text{CONV+ReLU}} 28 \times 28 \times 6 \xrightarrow{\text{POOL}} 14 \times 14 \times 6 \xrightarrow{\text{CONV+ReLU}} 10 \times 10 \times 10 \xrightarrow{\text{POOL}} 5 \times 5 \times 10 \xrightarrow{\text{Flatten}} \text{FC}$

核心规律：

空间尺寸逐步缩小： $32 \to 28 \to 14 \to 10 \to 5$ （通过卷积缩小 + 池化加速缩小）
通道数逐步增加： $3 \to 6 \to 10$ （从低级纹理到高级语义，需要更多模式来描述）
尾部使用全连接层进行分类

# 参数量分布规律

以经典架构为例，各层的参数量和计算量分布呈明显的"倒置"结构：

早期层：参数量极少（滤波器尺寸小），但计算量最大（空间尺寸大，卷积在大量空间位置上滑动）
后期全连接层：参数量巨大（ $5 \times 5 \times 10 = 250$ 个输入神经元 × 分类数 = 大量参数），但计算量较小

这个规律驱动了此后多年 CNN 架构的设计：将全连接层替换为全局平均池化以削减参数，用更深的卷积层换取表达能力。

# 设计中的关键归纳偏置

卷积网络的两个核心假设（归纳偏置），使其天然适合处理图像：

局部性 Locality：像素之间的关系随空间距离增大而衰减——近处相关的概率远大于远处
平移不变性 Translation Invariance：一个特征无论在图像的哪个位置出现，都应当被同一滤波器检测到——参数共享保证了这一点

这两个假设不是从数据中学来的，而是被硬编码进网络结构中的设计选择。它们大幅减少了自由度——一个全连接层需要学习 $C_{in}HW \times C_{out}HW$ 个连接模式，而卷积层只需学习 $C_{in}K_hK_w \times C_{out}$ 个，同时天然过滤掉大量无意义的假关联。

# 代码实现

# 基本卷积运算的 NumPy 实现

import numpy as np

def conv2d_forward(X, W, b, stride=1, pad=0):
    """
    X: 输入 (N, C_in, H, W)
    W: 滤波器 (C_out, C_in, K_h, K_w)
    b: 偏置 (C_out,)
    """
    N, C_in, H, W_in = X.shape
    C_out, _, K_h, K_w = W.shape

    H_out = (H + 2 * pad - K_h) // stride + 1
    W_out = (W_in + 2 * pad - K_w) // stride + 1

    # 填充
    X_padded = np.pad(X, ((0,0), (0,0), (pad,pad), (pad,pad)))

    out = np.zeros((N, C_out, H_out, W_out))

    for n in range(N):
        for c in range(C_out):
            for h in range(H_out):
                for w in range(W_out):
                    h_start = h * stride
                    w_start = w * stride
                    patch = X_padded[n, :, h_start:h_start+K_h, w_start:w_start+K_w]
                    out[n, c, h, w] = np.sum(patch * W[c]) + b[c]

    return out


def max_pool2d_forward(X, pool_size=2, stride=2):
    """
    最大池化前向传播
    X: 输入 (N, C, H, W)
    """
    N, C, H, W_in = X.shape
    H_out = (H - pool_size) // stride + 1
    W_out = (W_in - pool_size) // stride + 1

    out = np.zeros((N, C, H_out, W_out))

    for n in range(N):
        for c in range(C):
            for h in range(H_out):
                for w in range(W_out):
                    h_start = h * stride
                    w_start = w * stride
                    out[n, c, h, w] = np.max(
                        X[n, c, h_start:h_start+pool_size, w_start:w_start+pool_size]
                    )

    return out

# CNN 架构示例（类似 LeNet-5 风格）

class SimpleCNN:
    def __init__(self):
        # 第一卷积层：3 → 6 通道, 5x5 卷积核
        self.conv1_W = np.random.randn(6, 3, 5, 5) * 0.01
        self.conv1_b = np.zeros(6)

        # 第二卷积层：6 → 16 通道, 5x5 卷积核
        self.conv2_W = np.random.randn(16, 6, 5, 5) * 0.01
        self.conv2_b = np.zeros(16)

        # 全连接层：16*5*5 = 400 → 120 → 10
        self.fc1_W = np.random.randn(400, 120) * 0.01
        self.fc1_b = np.zeros(120)
        self.fc2_W = np.random.randn(120, 10) * 0.01
        self.fc2_b = np.zeros(10)

    def forward(self, X):
        # 输入 X: (N, 3, 32, 32)
        # Conv1: (N,3,32,32) → (N,6,28,28)
        out = conv2d_forward(X, self.conv1_W, self.conv1_b)
        out = np.maximum(0, out)  # ReLU

        # Pool1: (N,6,28,28) → (N,6,14,14)
        out = max_pool2d_forward(out, pool_size=2, stride=2)

        # Conv2: (N,6,14,14) → (N,16,10,10)
        out = conv2d_forward(out, self.conv2_W, self.conv2_b)
        out = np.maximum(0, out)  # ReLU

        # Pool2: (N,16,10,10) → (N,16,5,5)
        out = max_pool2d_forward(out, pool_size=2, stride=2)

        # Flatten: (N,16,5,5) → (N,400)
        N = out.shape[0]
        out = out.reshape(N, -1)

        # FC1: (N,400) → (N,120)
        out = out.dot(self.fc1_W) + self.fc1_b
        out = np.maximum(0, out)  # ReLU

        # FC2: (N,120) → (N,10)
        scores = out.dot(self.fc2_W) + self.fc2_b
        return scores

# Convolution Summary

概念	说明
卷积层	局部连接 + 参数共享，保留空间结构
滤波器	$K_h \times K_w \times C_{in}$ 的小张量，每个滤波器学习一种模式
输出维度	$\lfloor (W - K + 2P) / S \rfloor + 1$
参数量	$C_{out} \times (C_{in} \times K_h \times K_w + 1)$ ，与输入空间尺寸无关
步幅	控制滑动步长，影响输出尺寸和计算量
零填充	控制边界效果， $P = (K-1)/2$ 可保持尺寸不变
感受野	堆叠卷积层后逐层扩大，深层学习全局结构
$1 \times 1$ 卷积	通道维度上的线性组合，用于升降维和增加非线性
膨胀卷积	不增加参数的前提下扩大感受野
分组卷积	分通道独立卷积，减少参数量和计算量

# Pooling Summary

概念	说明
池化层	轻量级下采样，无参数，降低空间尺寸和计算量
最大池化	最常用，自带非线性，引入平移不变性
平均池化	需要额外非线性激活，已被最大池化大量取代
典型设置	$2 \times 2$ 窗口，步幅 2，无填充
全局平均池化	将 $H \times W \times C$ 压缩为 $1 \times 1 \times C$ ，替代全连接层
位置	与卷积层交替插入：CONV-ReLU-POOL 循环模式

# 声明

本blog由Yumengmeng基于2025春季李飞飞斯坦福CS231n计算机视觉课程的视频内容结合Claude Code抓取网上开源笔记进行美化与排版,仅供个人复习使用。

CS231n——Lecture4 神经网络与反向传播

2026-06-02T05:06:16.000Z

# 从线性分类器到神经网络

# 回顾：线性函数

线性分类器的核心公式：

$f(x, W) = Wx$

其中 $x \in \mathbb{R}^D$ ， $W \in \mathbb{R}^{C \times D}$ 。D 是输入维度，C 是类别数量（输出标签数量）。

在 Lecture 2 中我们看到，线性分类器每类只能学习一个模板，面对多模态分布、同心圆等问题完全无能为力——你无法用一条直线分开两个交替占据四个象限的类别。

# 双层神经网络

神经网络在线性分类器的基础上，在输入和输出之间插入了一个隐藏层：

$f(x, W_1, W_2) = W_2 \max(0, W_1 x)$

其中：

$x \in \mathbb{R}^D$ — 输入向量
$W_1 \in \mathbb{R}^{H \times D}$ — 第一层权重，将输入映射到 H 维隐藏空间
$W_2 \in \mathbb{R}^{C \times H}$ — 第二层权重，将隐藏表示映射到 C 个类别得分
H — 隐藏神经元数量，是一个超参数

权重矩阵的维度必须保持一致性：D → H → C，矩阵乘法才能正确执行。

# 为什么要引入非线性？

这是整个神经网络设计中最关键的问题。

如果去掉中间的 $\max(0, \cdot)$ ，两层网络退化为：

$f = W_2 (W_1 x) = (W_2 W_1) x = W_3 x$

存在一个 $W_3 = W_2 W_1$ 使得 $f = W_3 x$ ，又变回了线性分类器。堆叠任意多层线性变换，等价于一层线性变换——无论加多少层，表达能力没有任何提升。

$\text{线性 → 线性 → 线性 = 线性}$

非线性激活函数的作用是从一个空间变换到另一个空间，使原本线性不可分的数据在新空间中变得线性可分。隐藏层中的每个神经元可以理解为最终输出标签的某一部分"特征模板"——比如一个神经元学会检测"猫耳朵"，另一个检测"猫眼睛"，最终组合起来做出分类决策。

# 激活函数 Activation Functions

除了 $\max(0, x)$ （ReLU），常见的激活函数还包括：

# Sigmoid

$\sigma(x) = \frac{1}{1+e^{-x}}$

将值压缩到 (0,1)；容易导致梯度消失——两端饱和区梯度趋近于零。梯度公式简洁： $\sigma'(x) = (1-\sigma(x)) \cdot \sigma(x)$ 。

# Tanh

$\tanh(x) = \frac{e^x-e^{-x}}{e^x+e^{-x}}$

将值压缩到 (-1,1)，零中心化优于 Sigmoid，但同样存在梯度消失问题。

# ReLU

$\text{ReLU}(x) = \max(0, x)$

计算高效，大多数场景的默认首选（CNN、Transformer 均适用）；缺点是有"死亡神经元"问题——权重一旦归零后永不激活。Krizhevsky 等人 2012 年的实验表明，ReLU 的收敛速度远超 Tanh：

# Leaky ReLU

$\text{LeakyReLU}(x) = \max(0.01x, x)$

负区间保留微小梯度，缓解死亡神经元问题。

# ELU

$f(x) = \begin{cases} x & x \ge 0 \\ \alpha(e^x-1) & x < 0 \end{cases}$

负区间平滑，输出均值接近零，训练更稳定但计算量稍大。

# GELU 与 SILU (Swish)

$\text{GELU}(x) = x \cdot \Phi(x), \quad \text{SILU}(x) = x \cdot \sigma(x)$

GELU 是 Transformer 架构的标配激活函数（BERT、GPT 均使用）；SILU/Swish 是 GELU 的近似，在某些视觉任务中性能更优。

# 选择建议

ReLU — 默认起点，大部分 CNN 场景首选
GELU / SILU — 现代 Transformer 架构的主流选择
Sigmoid / Tanh — 基本不用于隐藏层（梯度消失严重），仅偶见于输出层或门控机制
激活函数最核心的作用永远是：引入非线性

# 一个完整的双层神经网络

大约 20 行代码即可构建。分为四步：

# 第一步：定义模型

import numpy as np

# 超参数
N = 100        # 样本数
D = 3072       # 输入维度（如 CIFAR-10: 32×32×3）
H = 100        # 隐藏神经元数量
C = 10         # 输出类别数

# 随机生成数据（仅示例）
X = np.random.randn(N, D)
y = np.random.randint(0, C, N)

# 初始化权重：小随机数 × 缩放因子
W1 = np.random.randn(D, H) * 0.01
b1 = np.zeros(H)
W2 = np.random.randn(H, C) * 0.01
b2 = np.zeros(C)

# 第二步：前向传播 Forward Pass

# 隐藏层：线性变换 + ReLU 激活
h = X @ W1 + b1          # [N, H]
h_relu = np.maximum(0, h) # ReLU

# 输出层：线性变换得到得分
scores = h_relu @ W2 + b2 # [N, C]

# Softmax 交叉熵损失
exp_scores = np.exp(scores - np.max(scores, axis=1, keepdims=True))
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

# 数据损失：负对数似然
loss = -np.mean(np.log(probs[np.arange(N), y]))

# 正则化损失：L2
reg = 0.001 * (np.sum(W1**2) + np.sum(W2**2))
total_loss = loss + reg

# 第三步：反向传播 Backward Pass

# Softmax 梯度
dscores = probs.copy()
dscores[np.arange(N), y] -= 1
dscores /= N

# W2 和 b2 的梯度
dW2 = h_relu.T @ dscores + 2 * 0.001 * W2  # 包含正则化梯度
db2 = np.sum(dscores, axis=0)

# 反向传播通过 ReLU：只路由到激活的神经元
dh = dscores @ W2.T
dh[h <= 0] = 0   # ReLU 反向：h≤0 的位置梯度为零

# W1 和 b1 的梯度
dW1 = X.T @ dh + 2 * 0.001 * W1
db1 = np.sum(dh, axis=0)

# 第四步：梯度下降更新

learning_rate = 1e-3
W1 -= learning_rate * dW1
b1 -= learning_rate * db1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2

# 模型容量与正则化

更多的神经元 = 更强的学习能力 = 更复杂的决策边界。但容量过大必然导致过拟合——模型记住了训练数据的噪声而非真实规律。

实践中更推荐的做法是：

优先调整正则化超参数，而非缩减模型规模。

一个容量足够大 + 正确正则化的网络，通常优于一个容量刚好合适的网络。正则化强度 $\lambda$ 是关键调节旋钮：

$\lambda$ 过大 → 权重被过度压制 → 欠拟合
$\lambda$ 过小 → 模型自由度过高 → 过拟合
通过验证集调参找到最佳值

损失函数的完整组成（以双层网络为例）：

$\text{得分: } s = W_2 \max(0, W_1 x)$

$\text{数据损失（Hinge）: } L_i = \sum_{j \neq y_i} \max(0, s_j - s_{y_i} + 1)$

$\text{正则化（L2）: } R(W) = \sum_k \sum_l W_{k,l}^2$

$\text{总损失: } L = \frac{1}{N} \sum_i L_i + \lambda R(W_1) + \lambda R(W_2)$

# 计算图与反向传播

# 什么是计算图？

计算图是一个有向无环图（DAG），节点是运算步骤（加法、乘法、max、sigmoid 等），边是数据流（标量、向量、矩阵）。通过计算图，我们可以系统化地应用链式法则，自动计算任意复杂函数的梯度——这就是 PyTorch、JAX 等框架自动微分的核心原理。

反向传播的核心机制非常简单：每个节点收到上游传来的梯度，乘以自身的局部梯度（输出对输入的导数），然后把结果传递给下游。整个过程完全局部化，每个节点独立运作。

$\text{下游梯度} = \text{上游梯度} \times \text{局部梯度}$

计算图上的反向传播，本质就是链式法则的递归应用。根据输入 $x$ 的维度，分成三种情况： $x$ 是标量时导数是标量， $x$ 是向量且 $y$ 是标量时导数是向量（梯度）， $x$ 和 $y$ 都是向量时导数变成雅可比矩阵。

# x 是标量，y 是标量 → 导数也是标量

$x$ 和 $y$ 以及所有中间变量都是标量，导数就是普通的 $\frac{dy}{dx}$ 。最基础的情形。

经典例子 $f(x, y, z) = (x + y) \cdot z$ ，设 $x=-2, y=5, z=-4$ ：

前向： $q = x + y = 3$ ， $f = q \cdot z = -12$

反向（从 $\frac{\partial f}{\partial f}=1$ 开始）：

步骤	计算	结果
$\frac{\partial f}{\partial z}$	$q \times 1 = 3$	3
$\frac{\partial f}{\partial q}$	$z \times 1 = -4$	-4
$\frac{\partial f}{\partial x}$	$\frac{\partial f}{\partial q} \cdot \frac{\partial q}{\partial x} = -4 \times 1$	-4
$\frac{\partial f}{\partial y}$	同理	-4

在这个最简单的例子中，三种基本门已经展现出了各自的"性格"：

Add 门：分发器。上游梯度原封不动传给两个输入（局部梯度恒为 1）
Multiply 门：交换器。 $\frac{\partial (ab)}{\partial a} = b$ ，梯度乘以"另一个输入的值"。这意味着如果乘法门的一个输入很小、另一个很大，梯度分配会严重失衡——小输入得到极大梯度，大输入得到极小梯度。这也是数据预处理影响训练稳定性的根本原因
Max 门：路由器。梯度只流向前向传播中值更大的那个输入，另一个得 0

当同一个变量被多次使用时（即计算图中出现分支），来自各条路径的梯度需要累加（+= 而不是 =），这是多变量链式法则的直接推论。

Sigmoid 函数 $\sigma(x) = \frac{1}{1+e^{-x}}$ 可以拆解为多个基本门（add → multiply → exp → add → reciprocal），但其局部梯度有简洁的闭式形式：

$\frac{d\sigma(x)}{dx} = (1 - \sigma(x)) \cdot \sigma(x)$

将整个 sigmoid 打包成一个"复合门"能大幅简化计算图：

# 前向
dot = w[0]*x[0] + w[1]*x[1] + w[2]
f = 1.0 / (1 + math.exp(-dot))   # sigmoid 复合门

# 反向：一行公式得到梯度
ddot = (1 - f) * f               # σ'(x) = (1-σ)σ
dx = [w[0] * ddot, w[1] * ddot]
dw = [x[0] * ddot, x[1] * ddot, 1.0 * ddot]

# x 是向量，y 是标量 → 导数是向量

这是实际神经网络中最常见的情形—— $x$ 是一个向量（比如隐藏层激活值 $h \in \mathbb{R}^H$ ），损失 $L$ 是标量。此时 $\frac{\partial L}{\partial x}$ 变成一个与 $x$ 同形的向量，每个分量 $\frac{\partial L}{\partial x_i}$ 表示改变 $x_i$ 对最终损失的影响。

核心原则： $\frac{\partial L}{\partial v}$ 的形状永远与 $v$ 完全相同。这是向量化反向传播的第一性原理，后面所有推导都以此为出发点。

对于 $y = f(x)$ ， $x \in \mathbb{R}^n, y \in \mathbb{R}^m$ ， $L$ 为标量：

$\frac{\partial L}{\partial x} = \left(\frac{\partial y}{\partial x}\right)^T \cdot \frac{\partial L}{\partial y}$

这里 $\frac{\partial y}{\partial x}$ 是 Jacobian 矩阵（ $m \times n$ ）， $\frac{\partial L}{\partial y}$ 是梯度向量（ $m$ 维）。但实际上我们几乎从不显式构造 Jacobian——一个 $1000 \times 1000$ 的 Jacobian 就有 100 万个元素，而实际网络的维度远大于此。

以 ReLU 为例： $y = \max(0, x)$ ， $x, y \in \mathbb{R}^n$ 。它的 Jacobian 是一个 $n \times n$ 的对角矩阵——对角线上要么是 0（ $x_i \leq 0$ ）要么是 1（ $x_i > 0$ ），所有非对角元素全是 0。所以反向传播直接简化为逐元素条件判断：

dh = dscores @ W2.T      # 上游梯度 [N, H]
dh[h <= 0] = 0           # 只传给激活了的神经元，无需构造矩阵

# x 是向量，y 是向量 → 导数是雅可比矩阵（重点）

当 $x$ 和 $y$ 都是向量时， $\frac{\partial y}{\partial x}$ 变成一个矩阵——雅可比矩阵（Jacobian），形状为 $m \times n$ （ $m$ 是 $y$ 的维度， $n$ 是 $x$ 的维度）。但实际中我们几乎从不显式构造它，而是利用稀疏性绕过。

以全连接层 $Y = X \cdot W$ 为例—— $X$ 是 $[N, D]$ 的矩阵， $W$ 是 $[D, M]$ ， $Y$ 是 $[N, M]$ ：

$X$ ： $[N, D]$ ， $W$ ： $[D, M]$ ， $Y$ ： $[N, M]$
已知上游梯度 $\frac{\partial L}{\partial Y}$ ，形状也是 $[N, M]$ （与 $Y$ 一致）

不需要死记公式。维度分析法四步就能推出来：

推导 $\frac{\partial L}{\partial W}$ ：目标形状 $[D, M]$ （与 $W$ 一致）。手上有的矩阵： $X [N, D]$ 和 $\frac{\partial L}{\partial Y} [N, M]$ 。唯一能拼出 $[D, M]$ 的组合： $X^T [D \times N] \cdot \frac{\partial L}{\partial Y} [N \times M] = [D \times M]$ 。

$\frac{\partial L}{\partial W} = X^T \cdot \frac{\partial L}{\partial Y}$

推导 $\frac{\partial L}{\partial X}$ ：目标形状 $[N, D]$ 。 $\frac{\partial L}{\partial Y} [N \times M] \cdot W^T [M \times D] = [N \times D]$ 。

$\frac{\partial L}{\partial X} = \frac{\partial L}{\partial Y} \cdot W^T$

用代码写出来就两行：

dW = X.T @ dY    # [D, N] @ [N, M] = [D, M]  ✓
dX = dY @ W.T    # [N, M] @ [M, D] = [N, D]  ✓

观察这两个公式：它们正是乘法门"交换变量"特性在矩阵层面的体现——梯度传到 $W$ 时乘以 $X^T$ ，传到 $X$ 时乘以 $W^T$ 。整个过程没有构造任何完整 Jacobian（那个尺寸会是 $(NM) \times (ND)$ ，根本放不下内存）——这正是深度学习能在千万级参数上高效训练的根本原因。

值得一提的是，这个维度分析技巧适用面非常广：全连接层、卷积层、注意力层、Einsum……任何张量运算的反向传播，只要记住"梯度形状 = 变量形状"，逆向拼维度就能推导出正确答案。

# 实践要点

分阶段计算：把复杂函数拆成简单中间变量，每个独立求导，链式组合
缓存前向值：反向需要前向的中间结果，别重复算
分支处用 +=：同一变量被多次使用时，梯度必须累加
梯度形状 = 变量形状：所有向量化反向传播的推导起点
先数值梯度检查，再切解析梯度：调试时用有限差分验证实现正确性

class MultiplyGate:
    def forward(self, x, y):
        self.x, self.y = x, y  # 缓存
        return x * y

    def backward(self, dout):
        return self.y * dout, self.x * dout  # 交换 + 乘上游梯度

每个运算模块写好 forward() 和 backward()，就能像搭积木一样组合出任意复杂网络——这正是 PyTorch 等框架的设计哲学。

# 声明

本blog由Yumengmeng基于2025春季李飞飞斯坦福CS231n计算机视觉课程的视频内容结合Claude Code抓取网上开源笔记进行美化与排版,仅供个人复习使用。

CS231n——Lecture3 正则化与优化

2026-05-31T07:27:56.000Z

# 正则化 Regularization

# 为什么需要正则化？

在 Lecture 2 中我们定义了完整的损失函数：

$L(W) = \frac{1}{N} \sum_i L_i(f(x_i, W), y_i) + \lambda R(W)$

其中第一项是数据损失 Data Loss，衡量模型在训练集上的预测误差；第二项是正则化项 Regularization Term。

如果只最小化数据损失，模型会倾向于过拟合 Overfitting——过度记忆训练数据中的每一个细节、噪声和无用特征，导致在训练集上表现极好（loss 接近零），但在从未见过的测试数据上表现糟糕。正则化的核心目的就是防止模型在训练数据上"表现得太好"，从而提升泛化能力。

这背后是奥卡姆剃刀原则 Occam's Razor：在所有能解释同一现象的假设中，最简单的那个往往是最好的。正则化通过惩罚复杂模型，引导优化过程偏好简单、可泛化的解。

# 正则化的三个核心作用

表达偏好：在多个都能拟合训练数据的 W 中，正则化表达了我们对"什么样的权重更好"的先验偏好（例如权重应该分散、不应该过大）
提升泛化：降低模型复杂度，减少过拟合，让模型在未知测试数据上表现更好
稳定优化：L2 正则化为损失函数添加二次曲率，使优化曲面更加"碗状"，梯度下降更容易找到好的解

超参数 $\lambda$ 控制正则化的强度：

$\lambda$ 过大 → 模型过于简单 → 欠拟合 Underfitting（连训练数据都学不好）
$\lambda$ 过小 → 模型过于复杂 → 过拟合 Overfitting（记住了训练数据的噪声）
$\lambda$ 需要通过验证集手动调整，是训练时必须调优的重要超参数

# L1 正则化（Lasso）

公式：

$R(W) = \sum_k \sum_l |W_{k,l}|$

L1 正则化将所有权重的绝对值和作为惩罚项。L1 的惩罚是线性增长的，这导致一个关键特性：稀疏性 Sparsity——优化过程会主动将大部分权重推向精确的零值，只保留少数真正重要的非零权重。

为什么 L1 产生稀疏解？ 考虑一个简单场景：损失函数是一个二次曲面，正则化是 L1 的菱形约束区域。最优解往往落在菱形的顶点（坐标轴上），此时某些权重精确为零。而 L2 的约束区域是圆形，最优解通常落在圆内部某处，权重都不为零。这就是 L1 天然适合特征选择 Feature Selection的原因。

代码实现：

def l1_regularization(W, lambda_reg):
    """
    L1 正则化损失
    """
    reg_loss = lambda_reg * np.sum(np.abs(W))
    return reg_loss

def l1_gradient(W, lambda_reg):
    """
    L1 正则化的梯度：d(R)/dW = lambda * sign(W)
    注意在 W=0 处不可导，实践中使用次梯度 subgradient
    """
    dW = lambda_reg * np.sign(W)
    return dW

# L2 正则化（Weight Decay / Ridge）

公式：

$R(W) = \sum_k \sum_l W_{k,l}^2$

L2 正则化将所有权重的平方和作为惩罚项。由于平方函数的特性——权重值越大惩罚越重（平方增长），优化过程会倾向于让所有权重都保持较小的值，并且均匀分散到各个维度。

直观例子：假设输入向量 $x = [1, 1, 1, 1]$ ，考虑两组权重：

$w_1 = [1, 0, 0, 0]$ ，与 x 的内积 = 1，L2 惩罚 = 1
$w_2 = [0.25, 0.25, 0.25, 0.25]$ ，与 x 的内积 = 1，L2 惩罚 = 0.25

两组权重在分类效果上完全相同（内积都是 1），但 L2 正则化强烈偏好 $w_2$ ，因为它利用了所有输入维度，权重分布更均匀、每个值更小。这种"不把鸡蛋放在一个篮子里"的策略让模型对输入噪声更鲁棒。

代码实现：

def l2_regularization(W, lambda_reg):
    """
    L2 正则化损失
    W: 权重矩阵
    lambda_reg: 正则化强度超参数
    """
    reg_loss = lambda_reg * np.sum(W * W)
    return reg_loss

def l2_gradient(W, lambda_reg):
    """
    L2 正则化的梯度：d(R)/dW = 2 * lambda * W
    """
    dW = 2 * lambda_reg * W
    return dW

# Elastic Net

公式：

$R(W) = \sum_k \sum_l \left(\beta \cdot W_{k,l}^2 + |W_{k,l}|\right)$

Elastic Net 将 L1 和 L2 线性组合，同时享受两者的优点：L2 的权重收缩与稳定性 + L1 的稀疏性与特征选择。通过调整 $\beta$ 参数来控制两者的相对强度。

在实际深度学习中，单纯的 L1/L2 权重正则化使用频率逐渐降低，更多被以下结构化正则化方法取代：

Dropout：训练时随机"丢弃"（置零）一部分神经元，强制网络学习冗余表示，防止神经元之间形成过度依赖
Batch Normalization：对每一层的激活值进行归一化，稳定数据分布，本身自带轻微正则化效果
数据增强 Data Augmentation：对训练图像进行随机翻转、裁剪、颜色抖动等变换，相当于免费扩大了训练集
Stochastic Depth：训练时随机丢弃整层网络，强迫梯度通过不同的子网络传播

# 优化 Optimization

# 优化问题概述

在确定了损失函数之后，下一个问题是：如何找到使损失最小的权重 W？ 这就是优化问题。

损失函数可以想象成一个高维曲面（比如 CIFAR-10 线性分类器有 $10 \times 3072 = 30720$ 个参数），我们的目标是走到这个曲面的最低点。但盲目地走显然不可行——下面首先来看为什么"随机猜测"行不通。

# 策略零：随机搜索 Random Search（反面教材）

最 naive 的想法：随机生成很多组权重，每组都算一下损失，选损失最小的那个。

best_loss = float('inf')
best_W = None
for _ in range(1000):
    W = np.random.randn(10, 3073) * 0.001  # 随机生成权重
    loss = compute_loss(W, X_train, y_train)
    if loss < best_loss:
        best_loss = loss
        best_W = W

在 CIFAR-10 上，随机搜索的最好结果仅为 15.5% 准确率，而当时最优方法已达到约 95%。随机搜索在高维空间中完全没有方向感——这就像在撒哈拉沙漠里随机扔一个飞镖，指望恰好命中某个特定沙粒。

我们需要利用损失曲面的几何信息来指导搜索方向。 这就引出了梯度下降。

# 梯度下降法 Gradient Descent

# 介绍

梯度下降是整个深度学习优化的基石，所有后续高级优化器（SGD、Momentum、Adam）本质上都是它的变体或改进。

# 思路

想象你站在一片山区，四周被浓雾笼罩，完全看不见山脚在哪里。你唯一能感知的是脚下地面的坡度——往哪个方向走是下坡。梯度下降的策略很简单：每一步都沿着当前最陡的下坡方向走一小段距离，重复这个过程直到地面变平（梯度趋近于零）。

梯度是导数在多维空间中的推广，它是一个向量，每个分量是损失函数对对应参数的偏导数。梯度指向函数值增长最快的方向，所以我们沿着负梯度方向走就是下降最快。

# 原理

一维情况：导数 $\frac{df}{dx} = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$ ，表示函数在该点的瞬时变化率。

多维情况：梯度 $\nabla_W L = \left(\frac{\partial L}{\partial w_1}, \frac{\partial L}{\partial w_2}, ..., \frac{\partial L}{\partial w_n}\right)$ ，是一个 n 维向量。

更新公式：

$W \leftarrow W - \alpha \cdot \nabla_W L$

其中 $\alpha$ 是学习率 Learning Rate，控制每一步走多远，是最关键的超参数之一。

$\theta_{t+1} = \theta_t - \alpha \cdot \nabla_\theta J(\theta_t)$

# 数值梯度 vs 解析梯度

计算梯度有两种方式：

数值梯度 Numerical Gradient（用定义近似）：

$\frac{df}{dx} \approx \frac{f(x+h) - f(x-h)}{2h}$

def eval_numerical_gradient(f, x, h=1e-5):
    """使用中心差分法计算数值梯度"""
    grad = np.zeros_like(x)
    it = np.nditer(x, flags=['multi_index'])
    while not it.finished:
        idx = it.multi_index
        old_val = x[idx]

        x[idx] = old_val + h
        fxh1 = f(x)

        x[idx] = old_val - h
        fxh2 = f(x)

        grad[idx] = (fxh1 - fxh2) / (2 * h)
        x[idx] = old_val
        it.iternext()
    return grad

优点：简单、直观，不需要推导
缺点：极其缓慢（每个参数都要算两次前向传播），精度受 h 选择影响；仅用于梯度检查，不用于训练

解析梯度 Analytic Gradient（微积分推导）：

直接从损失函数公式推导出精确的梯度表达式。例如，SVM 损失对 W 的梯度：

$\nabla_W L_i = \begin{cases} 0 & \text{if } s_{y_i} \geq s_j + 1 \\ x_i & \text{if } s_{y_i} < s_j + 1 \end{cases}$

优点：精确、快速（一次计算得到所有梯度）
缺点：推导过程容易出错

实践中的铁律：训练时使用解析梯度；调试时使用数值梯度做梯度检查 Gradient Check——如果两者差异过大，说明解析梯度的公式或实现中有 bug。

# 基本梯度下降的代码实现

def gradient_descent(X, y, W_init, learning_rate, num_iters):
    """
    全量梯度下降（Batch Gradient Descent）
    每次迭代使用全部训练数据计算梯度
    """
    W = W_init.copy()
    loss_history = []

    for i in range(num_iters):
        # 计算在整个训练集上的梯度
        scores = X.dot(W)
        loss, dW = svm_loss(scores, y)  # 包含数据损失 + 正则化损失的梯度

        # 沿负梯度方向更新
        W -= learning_rate * dW

        loss_history.append(loss)

    return W, loss_history

全量梯度下降的致命问题：当训练集很大时（如 ImageNet 有 120 万张图），每走一步都需要计算全部数据的梯度，计算代价高到无法接受。

# 随机梯度下降 Stochastic Gradient Descent (SGD)

# 介绍

SGD 是深度学习中最基础的实用优化算法。它用一个关键洞察解决了全量梯度下降的效率问题：不需要精确梯度，近似梯度就够了。

# 思路

与其每次用全部 N 个样本计算精确梯度，不如随机抽取一小批（mini-batch，通常 32/64/128/256 个样本），用这批样本的梯度作为整体梯度的无偏估计。这样每一步的计算量从 O(N) 降到了 O(batch_size)，使得大规模数据上的训练成为可能。

术语澄清："SGD" 在实际使用中几乎总是指 Mini-batch SGD（小批量随机梯度下降），而不是每次只用一个样本的极端版本。

# 原理

全量梯度下降的更新公式是：

$W \leftarrow W - \alpha \cdot \frac{1}{N}\sum_{i=1}^N \nabla_W L_i$

SGD 将其替换为对 mini-batch 的近似：

$W \leftarrow W - \alpha \cdot \frac{1}{m}\sum_{k=1}^m \nabla_W L_{i_k}$

其中 $m$ 是 mini-batch 大小， $i_k$ 是随机采样的索引。一个 Epoch 定义为遍历整个训练集一次（即所有 mini-batch 的梯度更新加起来覆盖了全部数据）。

# SGD 面临的三大挑战

尽管 SGD 解决了计算效率问题，但它本身存在三个核心缺陷：

挑战一：病态条件 Ill-Conditioning

损失曲面的曲率在不同方向差异巨大——某些方向陡峭（梯度大），某些方向平坦（梯度小）。SGD 在陡峭方向上来回震荡（zigzag），在平坦方向上却几乎无法前进。这就像一个窄长的峡谷：你沿着峡谷壁来回弹跳，但沿着谷底的推进却极其缓慢。

挑战二：鞍点 Saddle Points

在高维空间中，鞍点的数量远超局部极小值。鞍点处梯度等于零，但有些方向是上坡（最小值）、有些方向是下坡（最大值）——典型的例子是 $f(x, y) = x^2 - y^2$ ，在原点沿 x 方向是极小值，沿 y 方向是极大值。普通 SGD 遇到鞍点时梯度趋近于零，更新几乎停滞，但实际上并非真正的最优点。

挑战三：梯度噪声 Gradient Noise

每个 mini-batch 计算出的梯度都是整体梯度的含噪估计——不同的 mini-batch 给出略有不同的梯度方向和大小。这种随机性使得 SGD 的更新路径始终在"抖动"，收敛过程不够平滑。

不过梯度噪声也有一个意外的好处：它有时能帮助 SGD 从浅的局部极小值中跳出来，而这在全量梯度下降中是不可能的。

# 代码实现

def sgd(X, y, W_init, learning_rate, batch_size, num_epochs):
    """
    小批量随机梯度下降
    """
    N = X.shape[0]
    W = W_init.copy()
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        # 每个 epoch 开始时打乱数据顺序
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            # 取一个 mini-batch
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            # 计算 mini-batch 梯度
            scores = X_batch.dot(W)
            loss, dW = svm_loss(scores, y_batch)

            # 更新
            W -= learning_rate * dW
            loss_history.append(loss)

    return W, loss_history

# 带动量的随机梯度下降 SGD with Momentum

# 介绍

带动量的 SGD 是 SGD 的第一个重要升级。它在原始 SGD 的基础上引入了一个速度变量 velocity，让参数更新带有"惯性"。

# 思路

想象你把 SGD 的优化过程想象成一个小球在损失曲面上滚动。普通 SGD 的小球没有质量——每一步只看当前位置的坡度，走到哪算哪，非常容易在峡谷里来回震荡或被鞍点"卡住"。带动量的 SGD 赋予小球质量和惯性：它记住了之前运动的方向和速度，即使当前梯度很小甚至为零，积累的动量也能推动它继续前进，冲过鞍点和平坦区域。

同时，由于速度是历史梯度的加权平均，它自然地平滑掉了梯度噪声——单个 mini-batch 的随机波动被抹平，整体的前进方向更加一致和稳定。

# 原理

动量方法维护一个速度向量 v，每一步将其更新为历史速度与当前梯度的加权组合：

$v_{t+1} = \rho \cdot v_t + \nabla_W L$

$W \leftarrow W - \alpha \cdot v_{t+1}$

其中：

$\rho$ （动量系数，又称 $\beta$ 或 momentum）通常取 0.9 或 0.99
$v_t$ 是历史梯度的指数加权移动平均 Exponential Moving Average
$\rho = 0.9$ 意味着当前速度约等于过去约 10 步梯度的加权平均

为什么动量能克服鞍点？ 在鞍点处 $\nabla_W L \approx 0$ ，如果是普通 SGD，更新直接停止。但带动量的 SGD 中：

$v_{t+1} \approx \rho \cdot v_t$

速度不会立刻消失，而是以 $\rho$ 的比例衰减，继续推动参数向前走。这就像球滚到了一个小凹陷处——纯靠坡度它出不来，但如果有速度，就能直接冲过去。

# Nesterov 加速梯度（NAG）

Nesterov 动量是标准动量的一个巧妙改进：先沿着速度方向"展望"一步，在那个位置计算梯度，而不是在当前位置算。这相当于在行动之前先"看一步"。

$v_{t+1} = \rho \cdot v_t - \alpha \cdot \nabla_W L(W + \rho \cdot v_t)$

$W \leftarrow W + v_{t+1}$

NAG 对于凸优化问题有更好的理论收敛保证，在非凸的深度学习实践中也往往比标准动量略好一些。

# 代码实现

def sgd_momentum(X, y, W_init, learning_rate, momentum, batch_size, num_epochs):
    """
    带动量的随机梯度下降
    momentum: 动量系数，典型值 0.9
    """
    N = X.shape[0]
    W = W_init.copy()
    v = np.zeros_like(W)  # 初始化速度为零
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            scores = X_batch.dot(W)
            loss, dW = svm_loss(scores, y_batch)

            # 核心：速度更新 + 参数更新
            v = momentum * v + dW          # 累积历史梯度
            W -= learning_rate * v          # 用速度（而非原始梯度）更新

            loss_history.append(loss)

    return W, loss_history

# Nesterov 动量版本
def sgd_nesterov(X, y, W_init, learning_rate, momentum, batch_size, num_epochs):
    """
    Nesterov 加速梯度下降
    """
    N = X.shape[0]
    W = W_init.copy()
    v = np.zeros_like(W)
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            # 在"前瞻"位置计算梯度
            W_ahead = W - momentum * v
            scores = X_batch.dot(W_ahead)
            loss, dW = svm_loss(scores, y_batch)

            v = momentum * v + learning_rate * dW
            W -= v

            loss_history.append(loss)

    return W, loss_history

# RMSProp

# 介绍

RMSProp（Root Mean Square Propagation）由 Geoff Hinton 在 Coursera 课程中提出，是自适应学习率方法的代表作之一。它解决了 SGD 最为人诟病的问题——在所有参数上使用同一个全局学习率。

# 思路

回到 SGD 面临的病态条件问题：某些参数方向的梯度一直很大（陡峭方向），某些方向的梯度一直很小（平坦方向）。对所有参数使用相同的学习率必然意味着——要么陡峭方向上震荡发散，要么平坦方向上寸步难行。

RMSProp 的核心思想：每个参数应该有自己专属的学习率。如果一个参数的梯度一直很大，就给它小步走（防止震荡）；如果一个参数的梯度一直很小，就给它大步走（加速前进）。

具体做法是维护每个参数的梯度平方的指数移动平均，然后用这个平均值来逐元素缩放学习率——梯度大的方向被除以大数（步长变小），梯度小的方向被除以小数（步长变大）。

# 原理

$\text{cache}_{t+1} = \rho \cdot \text{cache}_t + (1 - \rho) \cdot (\nabla_W L)^2$

$W \leftarrow W - \frac{\alpha}{\sqrt{\text{cache}_{t+1}} + \epsilon} \cdot \nabla_W L$

其中：

$\text{cache}$ ：梯度平方的指数移动平均，注意这里的乘法是逐元素乘法
$\rho$ ：衰减率，典型值 0.9 或 0.99，控制历史信息保留多久
$\epsilon$ ：极小常数（如 $10^{-7}$ ），防止除零

为什么用指数移动平均而不是简单累加？ RMSProp 的前身是 AdaGrad，它将所有历史梯度平方直接累加：

$\text{cache}_{\text{AdaGrad}} = \text{cache} + (\nabla_W L)^2$

这导致 cache 单调递增、学习率单调递减，在非凸问题中会过早地把学习率压到零，让训练提前停滞。RMSProp 使用指数移动平均——旧信息逐渐"遗忘"、新信息权重更大——完美解决了这个问题。

# 代码实现

def rmsprop(X, y, W_init, learning_rate, decay_rate, batch_size, num_epochs, eps=1e-7):
    """
    RMSProp 优化器
    decay_rate: 梯度平方的衰减率 (rho)，典型值 0.9 或 0.99
    """
    N = X.shape[0]
    W = W_init.copy()
    cache = np.zeros_like(W)  # 梯度平方的移动平均
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            scores = X_batch.dot(W)
            loss, dW = svm_loss(scores, y_batch)

            # 更新梯度平方的移动平均
            cache = decay_rate * cache + (1 - decay_rate) * dW ** 2

            # 逐元素自适应学习率
            W -= learning_rate * dW / (np.sqrt(cache) + eps)

            loss_history.append(loss)

    return W, loss_history

# Adam（Adaptive Moment Estimation）

# 介绍

Adam 由 Kingma 和 Ba 在 2015 年提出，是目前深度学习中使用最广泛的优化器。它将 Momentum（一阶矩/动量） 和 RMSProp（二阶矩/自适应学习率） 的思想优雅地结合在一起，既有动量带来的平滑加速能力，又有逐参数自适应学习率的鲁棒性。

Adam 几乎是所有项目的默认优化器——如果不知道该用什么，先用 Adam 通常不会错。

# 思路

Adam 同时维护两个指数移动平均：

一阶矩 $m_t$ ：梯度的指数移动平均（如同动量），记录梯度的"方向"和"趋势"
二阶矩 $v_t$ ：梯度平方的指数移动平均（如同 RMSProp），记录梯度的"波动幅度"

然后用 $m_t$ 作为更新方向（替代原始梯度），用 $\sqrt{v_t}$ 作为逐参数的学习率缩放因子。最终更新公式大致是：

$W \leftarrow W - \alpha \cdot \frac{m_t}{\sqrt{v_t} + \epsilon}$

但有个关键问题：在训练的最初几步， $m_t$ 和 $v_t$ 都被初始化为零。由于指数移动平均的性质，前几步的值会严重偏向零，导致参数更新过小。Adam 使用偏差修正 Bias Correction来解决这个问题。

# 原理

第一步：更新一阶矩和二阶矩

$m_t = \beta_1 \cdot m_{t-1} + (1 - \beta_1) \cdot \nabla_W L$

$v_t = \beta_2 \cdot v_{t-1} + (1 - \beta_2) \cdot (\nabla_W L)^2$

第二步：偏差修正

$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}$

$\hat{v}_t = \frac{v_t}{1 - \beta_2^t}$

偏差修正的直观理解：在 t=1 时， $m_1 = (1-\beta_1) \cdot g_1$ （注意 $m_0=0$ ），除以 $1-\beta_1$ 后正好还原为 $g_1$ 。随着 t 增大， $1 - \beta_1^t$ 趋近于 1，偏差修正逐渐失效——这正是我们想要的，因为移动平均本身已经足够准确了。

第三步：参数更新

$W \leftarrow W - \alpha \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$

推荐超参数（论文默认值，大多数场景直接使用即可）：

参数	推荐值	说明
$\alpha$ (lr)	1e-3	学习率，有时用 5e-4
$\beta_1$	0.9	一阶矩衰减率（动量项）
$\beta_2$	0.999	二阶矩衰减率（缩放项）
$\epsilon$	1e-8	数值稳定常数

# AdamW：解耦权重衰减

标准 Adam 的一个隐性问题：当使用 L2 正则化时，正则化项的梯度进入了 $m_t$ 和 $v_t$ 的计算，导致权重衰减效果被自适应学习率干扰——不同参数的权重衰减强度不一致，违背了正则化的初衷。

AdamW（Loshchilov & Hutter, 2019）的解决方案极其简单：将权重衰减从梯度计算中解耦出来，作为独立的更新步骤：

$W \leftarrow W - \alpha \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} - \alpha \cdot \lambda \cdot W$

最后一项 $\alpha \cdot \lambda \cdot W$ 是直接的权重衰减，不经过任何自适应缩放。这个简单的修改在 ImageNet 等大型实验中一致地提升了泛化性能。AdamW 已逐渐成为现代深度学习训练的首选优化器。

# 代码实现

def adam(X, y, W_init, learning_rate, beta1, beta2, batch_size, num_epochs, eps=1e-8):
    """
    Adam 优化器
    beta1: 一阶矩衰减率，默认 0.9
    beta2: 二阶矩衰减率，默认 0.999
    """
    N = X.shape[0]
    W = W_init.copy()
    m = np.zeros_like(W)  # 一阶矩（动量）
    v = np.zeros_like(W)  # 二阶矩（RMSProp cache）
    t = 0                 # 时间步计数
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            t += 1
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            scores = X_batch.dot(W)
            loss, dW = svm_loss(scores, y_batch)

            # 更新一阶矩和二阶矩
            m = beta1 * m + (1 - beta1) * dW
            v = beta2 * v + (1 - beta2) * (dW ** 2)

            # 偏差修正
            m_unbiased = m / (1 - beta1 ** t)
            v_unbiased = v / (1 - beta2 ** t)

            # 参数更新
            W -= learning_rate * m_unbiased / (np.sqrt(v_unbiased) + eps)

            loss_history.append(loss)

    return W, loss_history


def adamw(X, y, W_init, learning_rate, beta1, beta2,
          weight_decay, batch_size, num_epochs, eps=1e-8):
    """
    AdamW 优化器：将权重衰减从自适应学习率中解耦
    weight_decay: 权重衰减系数（即原 L2 正则化的 lambda）
    """
    N = X.shape[0]
    W = W_init.copy()
    m = np.zeros_like(W)
    v = np.zeros_like(W)
    t = 0
    loss_history = []

    num_iters_per_epoch = N // batch_size

    for epoch in range(num_epochs):
        idx = np.random.permutation(N)
        X_shuffled = X[idx]
        y_shuffled = y[idx]

        for i in range(num_iters_per_epoch):
            t += 1
            start = i * batch_size
            end = start + batch_size
            X_batch = X_shuffled[start:end]
            y_batch = y_shuffled[start:end]

            # 注意：梯度计算中不包含 L2 正则化项
            scores = X_batch.dot(W)
            loss, dW = svm_loss_without_reg(scores, y_batch)

            m = beta1 * m + (1 - beta1) * dW
            v = beta2 * v + (1 - beta2) * (dW ** 2)

            m_unbiased = m / (1 - beta1 ** t)
            v_unbiased = v / (1 - beta2 ** t)

            # 自适应更新 + 解耦的权重衰减
            W -= learning_rate * m_unbiased / (np.sqrt(v_unbiased) + eps)
            W -= learning_rate * weight_decay * W  # 独立的权重衰减步骤

            loss_history.append(loss)

    return W, loss_history

# 优化器对比总结

方法	动量/惯性	自适应学习率	偏差修正	核心特点
SGD	✗	✗	✗	最基础、最朴素
SGD+Momentum	✓	✗	✗	惯性冲过鞍点，平滑噪声
RMSProp	✗	✓ (EMA)	✗	逐参数自适应，解决病态条件
Adam	✓	✓ (EMA)	✓	动量 + 自适应 + 偏差修正，全能选手
AdamW	✓	✓ (EMA)	✓	Adam + 解耦权重衰减，泛化更好

# 学习率调度策略 Learning Rate Scheduling

学习率 $\alpha$ 不一定在整个训练过程中保持不变。一个好的学习率调度策略往往能显著提升最终性能。

# 常用策略

阶梯衰减 Step Decay：在预设的 epoch 节点将学习率乘以一个衰减因子（如 0.1）。例如 ResNet 在 epoch 30、60、90 各衰减一次。这是 CNN 时代的标准做法。

余弦退火 Cosine Annealing：

$\alpha_t = \frac{1}{2} \cdot \alpha_0 \cdot (1 + \cos(\frac{t}{T}\pi))$

学习率沿着余弦曲线平滑地从初始值衰减到零。目前是 Transformer 和大模型训练的主流选择。

线性衰减 Linear Decay：

$\alpha_t = \alpha_0 \cdot (1 - t/T)$

简单稳定，适合中小规模模型。

线性预热 Linear Warmup：在训练刚开始的若干步（通常前 5-10 个 epoch），将学习率从 0 线性增加到目标值。这防止了随机初始化的权重在最初几步产生过大的梯度导致训练不稳定。

# 实践建议

默认选择：AdamW + 线性预热 + 余弦退火衰减，这是 2025 年深度学习社区的主流方案
备选方案：如果计算资源充裕且需要极致性能，可以尝试 SGD + Momentum + 精心调参（学习率、动量、衰减策略），在一些大规模视觉任务上仍有超越 Adam 的可能
经验法则：batch size 翻倍时，学习率也翻倍（线性缩放法则）
不要过早优化：先用固定学习率观察 loss 曲线，确定模型能正常训练后再加入衰减策略

# 声明

本blog由Yumengmeng基于2025春季李飞飞斯坦福CS231n计算机视觉课程的视频内容结合Claude Code抓取网上开源笔记进行美化与排版,仅供个人复习使用。

CS231n——Lecture2 使用线性分类器进行图像分类

2026-05-31T06:27:50.000Z

# 图像分类 Image Classification

图像分类的核心任务：给定一张图像和一组类别标签，设计算法将其中一个标签分配给此图像。

图像在计算机中就是一个巨大的数字网格，每个像素值介于 [0,255] 之间。对于一个 800×600 分辨率的彩色图像，其数据张量为 800 × 600 × 3，因为有 RGB 三个颜色通道（红、绿、蓝）。

语义鸿沟 Semantic Gap：人类看到图像能轻松识别物体，但计算机看到的只是一个巨大的整数矩阵。这个差距就是我们需要跨越的核心问题。

图像分类面临的六大挑战：
- 视角变化 viewpoint variation：即使物体完全静止，只要相机视角发生微小变化，数据张量就可能完全不同
- 光照条件 illumination conditions：RGB 像素值是表面材料颜色与光源共同作用的函数，同一物体在不同光线下数值差异巨大
- 形变 deformation：物体本身具有非刚性，姿态变化导致像素分布改变
- 遮挡 occlusion：物体被部分遮挡，人类可以通过部分信息做出精确判断，计算机则非常困难
- 背景杂乱 background clutter：物体与背景混杂在一起，难以分离前景和背景
- 类内变化 intraclass variation：同一类别内的个体差异本身就很大（比如不同品种、不同颜色的猫）

传统的基于边缘检测器的方法（找到图像边缘 → 提取特征 → 映射成输出类）效果有限，无法应对这些复杂性。

数据驱动方法 Data-driven approach 的核心思路：

收集足够多的图像及其标签的数据集
使用机器学习算法训练分类器——用训练函数接受图像与标签，建立一个将图像与标签关联的模型
在新的图像上测试分类器——创建预测函数，输入测试图像，预测标签并返回

def train(images, labels):
    # 记忆数据与标签
    return model

def predict(model, test_images):
    # 为测试图像找到最相近的训练图像，输出该图像标签
    return test_labels

# 最近邻分类器 Nearest Neighbor Classifier

最简单的数据驱动方法：记住所有训练数据，预测时在训练集中找到与测试图像最相似的一张，输出其标签。

我们需要一个距离函数来衡量两张图片的相似程度。

L1 距离（曼哈顿距离 Manhattan Distance）：

$d_1(I_1, I_2) = \sum_p |I_1^p - I_2^p|$

对每个像素位置 p，直接求像素差的绝对值并累加。如果两张图完全一样，L1 距离为零；差异越大，距离值越大。

L2 距离（欧氏距离 Euclidean Distance）：

$d_2(I_1, I_2) = \sqrt{\sum_p (I_1^p - I_2^p)^2}$

L2 是几何意义上的直线距离。

完整的 Nearest Neighbor 分类器实现：

import numpy as np

class NearestNeighbor:
    def __init__(self):
        pass

    def train(self, X, y):
        """训练就是记住所有训练数据，只需 O(1) 时间"""
        self.Xtr = X
        self.ytr = y

    def predict(self, X):
        """预测：对每个测试样本，遍历训练集找到最近邻"""
        num_test = X.shape[0]
        Ypred = np.zeros(num_test, dtype=self.ytr.dtype)

        for i in range(num_test):
            # 使用 L1 距离：广播计算测试样本与所有训练样本的差值
            distances = np.sum(np.abs(self.Xtr - X[i, :]), axis=1)
            # 找到距离最小的训练样本索引
            min_index = np.argmin(distances)
            # 输出该训练样本的标签
            Ypred[i] = self.ytr[min_index]

        return Ypred

这个分类器的设计哲学是：训练快（O(1)），预测慢（O(N)）。但实际应用中我们恰好需要相反的特性——可以接受训练慢一些，但预测必须快，因为用户不会等。

L1 与 L2 距离的关键区别：
- L1 距离对特征值敏感：它的决策边界几乎平行于坐标轴，对图像的旋转会导致 L1 形状变化
- L2 距离对特征值不敏感：它的决策边界不受坐标轴方向限制，旋转图像后 L2 看不出变化
- 实际选择取决于特征向量中每个维度的含义——如果各维度有明确的物理意义，L1 可能更好；如果只是通用空间向量，L2 更合适

# K-邻近算法 K-Nearest Neighbor

最邻近算法可以自然地扩展为 K 邻近算法：选择距离最近的 K 个邻居进行多数投票，票数最多的类别作为预测结果。

当 K > 1 时，决策边界变得更平滑，对噪声和离群点更鲁棒
图中白色区域是 K 个邻居中平票的区域，无法确定标签——说明这个区域数据不足，适合收集更多数据

在 CIFAR-10 数据集上（10 个类别，50000 张训练集，10000 张测试集），KNN 的准确率约为 28%～29%，仅比随机猜测（10%）好一些。

超参数 Hyperparameters 是由用户设定的变量（如 K 值、距离函数的选择），模型无法从数据中自动学到。如何选择超参数是机器学习中的关键问题。

四种超参数设置策略（递进式推理）：
1. ❌ 选择在训练集上表现最好的超参数：模型会"记住"训练数据，训练准确率始终接近 100%，但严重过拟合，无法泛化到新数据
2. ❌ 选择在测试集上表现最好的超参数：这是"作弊"行为——测试集信息泄露到超参数选择中，我们无法知道算法在新数据上的真实表现
3. ✅ 将数据分为训练集 train、验证集 validation、测试集 test：在训练集上用不同超参数训练，在验证集上评估并选出最佳超参数，最后仅在测试集上运行一次得到最终结果。测试集是一种极其宝贵的资源，在最后一步之前永远不要碰它。这个方法的难点在于需要选择合适的验证集划分
4. ✅ K-Fold 交叉验证 Cross-Validation：将训练数据折叠成 K 个褶皱，每个褶皱轮流充当一次验证集，其余 K-1 个做训练集。训练 K 次后取平均精度。最后用最佳超参数在全部训练数据上重新训练，在测试集上评估一次。这可以产生更可靠的结果，但在大数据集上计算负担很重，深度学习实践中不常用

# 交叉验证示例：在 CIFAR-10 上为 KNN 寻找最佳 K 值
# 假设 Xtr_rows 和 Ytr 是训练数据
Xval_rows = Xtr_rows[:1000, :]    # 取前 1000 个作为验证集
Yval = Ytr[:1000]
Xtr_rows = Xtr_rows[1000:, :]     # 剩余作为训练集
Ytr = Ytr[1000:]

validation_accuracies = []
for k in [1, 3, 5, 10, 20, 50, 100]:
    # 对每个 k 值评估验证集精度
    nn = NearestNeighbor()
    nn.train(Xtr_rows, Ytr)
    Yval_predict = nn.predict(Xval_rows, k=k)
    acc = np.mean(Yval_predict == Yval)
    validation_accuracies.append((k, acc))

实验结果表明 CIFAR-10 上最优 K 值约为 7。

KNN 的三大缺陷：

预测时间极慢：训练 O(1)，预测 O(N)，与实际需求完全相反。我们关注的是测试效率，用户不会为了分类一张图片等上几分钟
像素距离不等于语义距离：从人眼来看四张完全不同的图片，它们的 L2 像素距离可能完全相同——背景、姿态、光照的不同导致逐像素比较彻底失效
维度灾难 Curse of Dimensionality：在高维空间中，距离的概念变得反直觉——所有点看起来都很远，最近邻失去意义。要密集覆盖高维空间，所需样本数以指数级增长

但 KNN 仍然是一个理解数据驱动方法和超参数调优的绝佳起点。

# 线性分类器 Linear Classifier

线性分类器是整个神经网络和卷积网络的基础构件。大规模神经网络实质上就是这些基础单元一层层堆叠起来的。

# 核心公式

$f(x, W) = Wx + b$

x：输入图像，展开为列向量。CIFAR-10 图像为 32×32×3 = 3072 维
W：权重矩阵 Weights，又称为参数。输出是 10 个类别的得分，所以 W 的维度为 10 × 3072
b：偏置向量 Bias，维度为 10 × 1，表示数据独立的类别偏好值（例如数据集中猫的图像比狗多，则猫对应的偏置会更大）
f(x, W)：输出是一个 10 维向量，每个元素对应一个类别的得分 score

W 的每一行对应一个类别的分类器。线性分类器的几何本质是：在 3072 维空间中找到一个超平面，将不同类别区分开来。

如果没有偏置 b，每条分界线都必须穿过原点，分类将失去灵活性——比如当某个类别的所有样本都落在第一象限时，穿过原点的直线无法很好地分离它们。

# 技巧：将 W 和 b 合并

在 x 向量的末尾添加一个常数维度 1，同时将 b 作为新的一列附加到 W 中：

$f(x, W) = Wx$

这样公式更简洁，实现时也更方便。

# 模板匹配视角 Template Matching

线性分类器还可以从另一个角度理解：

W 的每一行可以重新排列成与输入图像相同的大小（32×32×3），想象成一张"模板"图像
线性分类就是使用内积来比较输入图像与每个类别的模板，找到最相似的那个
以船分类器为例：蓝色通道（水和天空）有许多正权重，而红色和绿色通道多为负权重——这恰好是一张蓝色大海背景下船只轮廓的模糊模板

# 图像预处理

在输入分类器之前，建议将像素值从 [0, 255] 归一化到 [-1, 1] 范围，有助于训练稳定。

# 线性分类器的局限性

线性分类器每类只能学习一个模板，无法处理多模态数据。以奇偶像素计数分类为例：蓝色类别在平面上占据两个相反的象限——没有办法绘制一条单独的直线来同时覆盖两个离散的蓝色区域。

以下三类问题线性分类器无法解决：

奇偶问题（类别按奇偶数分布在两个相反的象限）
同心圆问题（内外圆分属两类）
多模态分布（同一类分布在空间中不相邻的多个区域）

这些局限正是后续引入神经网络和非线性激活函数的原因。

# 损失函数 Loss Function

现在的问题是：如何量化 W 的好坏？ 损失函数用于衡量分类器的"糟糕程度"。我们的目标是找到一个 W 使得损失函数值最小。

# 多分类 SVM 损失 Multiclass SVM Loss（Hinge Loss）

$L_i = \sum_{j \neq y_i} \max(0, s_j - s_{y_i} + \Delta)$

$s_{y_i}$ ：正确类别的得分
$s_j$ ：错误类别的得分
$\Delta$ ：安全间隔 margin，通常取 1

直观理解：我们希望正确类别的得分比所有错误类别高出至少 $\Delta$ 。如果某个错误类别的得分与正确类别差距小于 $\Delta$ ，则产生损失；如果差距足够大（大于 $\Delta$ ），则损失为零。这个损失被称为 Hinge Loss，因为它的形状像合页一样在 $\Delta$ 处弯折。

# Softmax 分类器（交叉熵损失 Cross-Entropy Loss）

将得分转化为概率分布：

指数化：取 $e^{s_k}$ ，确保所有值 > 0
归一化：除以所有指数之和 $\sum_j e^{s_j}$ ，使所有概率之和为 1

$P(Y=k|X=x_i) = \frac{e^{s_k}}{\sum_j e^{s_j}}$

例如模型输出 [cat: 0.13, car: 0.87, frog: 0.00]，意味着模型认为这张图是猫的概率为 13%，是车的概率为 87%，是青蛙的概率为 0%。

损失函数直接取负对数似然 Negative Log Likelihood：

$L_i = -\log P(Y=y_i|X=x_i)$

本质是在做最大似然估计 Maximum Likelihood Estimation——我们希望正确类别的概率越大越好。

# 交叉熵与 KL 散度的关系

$H(P, Q) = -\sum_x P(x) \log Q(x)$

$D_{KL}(P \parallel Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)}$

$H(P, Q) = H(P) + D_{KL}(P \parallel Q)$

P 是真实概率分布，Q 是模型预测的概率分布
H(P) 是真实分布的熵（常数，真实标签固定不变）
交叉熵 = KL 散度 + 常数，所以最小化交叉熵就是在最小化 KL 散度，让预测分布逼近真实分布

# 两个实用的 Debug 问题

Q1：Softmax 损失函数的最大值是多少？

理论上为无穷大。当正确类别的概率趋近于 0 时， $-\log(0) \to \infty$ 。实际中由于数值精度限制，概率不会精确为零，但可以非常大。

Q2：初始化时所有权重为小随机数，所有 $s_i$ 近似相等，损失函数的值是多少？

所有类别概率相等， $P = 1/C$ ：

$L_i = -\log(1/C) = \log(C)$

当 C = 10 时， $L_i = \log(10) \approx 2.3$ 。这是一个很有用的 sanity check：训练刚开始时如果 loss 偏离这个值太多，说明实现中很可能有 bug。

# 正则化 Regularization

完整损失函数 = 数据损失 Data Loss + 正则化项 Regularization：

$L = \frac{1}{N} \sum_i L_i + \lambda R(W)$

数据损失：让模型拟合训练数据，最小化预测误差
正则化项：惩罚复杂模型，鼓励简单权重，防止过拟合
$\lambda$ ：平衡两个目标的超参数

常见的正则化方式：

L2 正则化： $R(W) = \sum_k \sum_l W_{k,l}^2$ ，鼓励权重分散到所有维度，惩罚个别过大的权重值
L1 正则化： $R(W) = \sum_k \sum_l |W_{k,l}|$ ，鼓励稀疏权重
Elastic Net：L1 + L2 的结合

# 声明

本blog由Yumengmeng基于2025春季李飞飞斯坦福CS231n计算机视觉课程的视频内容结合Claude Code抓取网上开源笔记进行美化与排版,仅供个人复习使用。

AI浪潮下的小小避风港

CS231n——Lecture6 卷积神经网络架构

CS231n——Lecture5 基于CNN的图像分类

# 第一部分回顾：深度学习基础（Lecture2—Lecture4）

# 图像分类与线性分类器

# 损失函数

# 优化

# 线性分类器的局限

# 神经网络的引入

# 计算图与反向传播

# 完整流程总结

# 图像特征表示 Image Features

# 为什么需要特征？

# 特征提取 + 分类器的组合范式

# 端到端神经网络

# 从全连接层到卷积层

# 全连接层的局限

# 如何尊重二维信息？

# 卷积层 Convolutional Layer

# 基本思想：局部连接 + 参数共享

# 卷积运算的直观过程

# 卷积层的定义

# 批量处理：四维张量

# 空间维度计算

# 感受野 Receptive Field

# 1×11 \times 11×1 卷积

# 卷积的其他变体

# 卷积层参数计算

# 池化层 Pooling Layer

# 为什么需要池化？

# 最大池化 Max Pooling

# 池化的设计约定

# 平均池化 Average Pooling

# 池化层的形状公式

# 其他池化方法

# 输入尺寸不统一怎么办？

# CNN 架构设计

# 典型架构模式

# 参数量分布规律

# 设计中的关键归纳偏置

# 代码实现

# 基本卷积运算的 NumPy 实现

# CNN 架构示例（类似 LeNet-5 风格）

# Convolution Summary

# Pooling Summary

# 声明

CS231n——Lecture4 神经网络与反向传播

# 从线性分类器到神经网络

# 回顾：线性函数

# 双层神经网络

# 为什么要引入非线性？

# 激活函数 Activation Functions

# Sigmoid

# Tanh

# ReLU

# Leaky ReLU

# ELU

# GELU 与 SILU (Swish)

# 选择建议

# 一个完整的双层神经网络

# 第一步：定义模型

# 第二步：前向传播 Forward Pass

# 第三步：反向传播 Backward Pass

# 第四步：梯度下降更新

# 模型容量与正则化

# 计算图与反向传播

# 什么是计算图？

# x 是标量，y 是标量 → 导数也是标量

# x 是向量，y 是标量 → 导数是向量

# x 是向量，y 是向量 → 导数是雅可比矩阵（重点）

# 实践要点

# 声明

CS231n——Lecture3 正则化与优化

# 正则化 Regularization

# 为什么需要正则化？

# 正则化的三个核心作用

# L1 正则化（Lasso）

# L2 正则化（Weight Decay / Ridge）

# Elastic Net

# 优化 Optimization

# $1 \times 1$ 卷积