{ "version": "https://jsonfeed.org/version/1", "title": "AI浪潮下的小小避风港", "subtitle": "思考ing：智能的本质是什么？", "icon": "https://yumengmeng.cn/assets/favicon.ico", "description": "只要不停下脚步，道路就会一直延伸", "home_page_url": "https://yumengmeng.cn", "items": [ { "id": "https://yumengmeng.cn/2026/06/03/CS231n%E2%80%94%E2%80%94lecture6%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E6%9E%B6%E6%9E%84/index/", "url": "https://yumengmeng.cn/2026/06/03/CS231n%E2%80%94%E2%80%94lecture6%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E6%9E%B6%E6%9E%84/index/", "title": "CS231n——Lecture6 卷积神经网络架构", "date_published": "2026-06-02T16:00:00.000Z", "content_html": "

<!-- 内容待补充 -->

\n", "tags": [ "CS231n学习笔记", "CS231n", "计算机视觉", "深度学习", "CNN", "架构设计" ] }, { "id": "https://yumengmeng.cn/2026/06/02/CS231n%E2%80%94%E2%80%94lecture5%E5%9F%BA%E4%BA%8ECNN%E7%9A%84%E5%9B%BE%E5%83%8F%E5%88%86%E7%B1%BB/index/", "url": "https://yumengmeng.cn/2026/06/02/CS231n%E2%80%94%E2%80%94lecture5%E5%9F%BA%E4%BA%8ECNN%E7%9A%84%E5%9B%BE%E5%83%8F%E5%88%86%E7%B1%BB/index/", "title": "CS231n——Lecture5 基于CNN的图像分类", "date_published": "2026-06-02T08:58:43.000Z", "content_html": "

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

\n

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

\n

# 图像分类与线性分类器

\n

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

\n

f(x,W)=Wxf(x, W) = Wx\nf(x,W)=Wx

\n

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

\n

# 损失函数

\n

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

\n\n

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

\n

# 优化

\n

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

\n

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

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

# 线性分类器的局限

\n

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

\n

\"线性分类器无法处理的多模态分布问题\"

\n

# 神经网络的引入

\n

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

\n

f(x,W1,W2)=W2max⁡(0,W1x)f(x, W_1, W_2) = W_2 \\max(0, W_1 x)\nf(x,W1​,W2​)=W2​max(0,W1​x)

\n

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

\n

# 计算图与反向传播

\n

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

\n\n

核心公式极为简洁：

\n

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

\n

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

\n

# 完整流程总结

\n

对于任意待解决的问题：

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

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

\n
\n

# 图像特征表示 Image Features

\n

# 为什么需要特征？

\n

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

\n

两个经典的例子：

\n

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

\n

\"颜色直方图：将像素按颜色分类，忽略空间结构\"

\n

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

\n

\"定向梯度直方图：只提取边缘方向，丢弃颜色\"

\n

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

\n

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

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

\"传统范式：图像

\n

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

\n

# 端到端神经网络

\n

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

\n\n

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

\n
\n

# 从全连接层到卷积层

\n

# 全连接层的局限

\n

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

\n

\"全连接层：将三维张量压扁为一维向量\"

\n

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

\n

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

\n

# 如何尊重二维信息？

\n

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

\n

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

\n
\n

# 卷积层 Convolutional Layer

\n

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

\n

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

\n\n

# 卷积运算的直观过程

\n

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

\n

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

\n

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

\n\n

\"卷积操作：滤波器在输入上滑动并计算点积\"

\n

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

\n

# 卷积层的定义

\n

卷积层的关键运算符：

\n
\n

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

\n

超参数：滤波器数量 CoutC_{out}Cout​（输出通道数）、滤波器尺寸 Kh×KwK_h \\times K_wKh​×Kw​

\n
\n

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

\n

# 批量处理：四维张量

\n

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

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
张量维度含义
输入N×Cin×H×WN \\times C_{in} \\times H \\times WN×Cin​×H×W一批图像（N 张）
滤波器Cout×Cin×Kh×KwC_{out} \\times C_{in} \\times K_h \\times K_wCout​×Cin​×Kh​×Kw​一组滤波器
输出N×Cout×H′×W′N \\times C_{out} \\times H' \\times W'N×Cout​×H′×W′一批输出特征图
\n

# 空间维度计算

\n

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

\n

不填充，步幅为 1：

\n

H′=H−K+1H' = H - K + 1\nH′=H−K+1

\n

例如：32×3232 \\times 3232×32 的输入，5×55 \\times 55×5 的卷积核 → 28×2828 \\times 2828×28 的输出。

\n

带零填充 Zero Padding：

\n

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

\n

H′=H−K+1+2PH' = H - K + 1 + 2P\nH′=H−K+1+2P

\n

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

\n

带步幅 Stride：

\n

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

\n

H′=H−K+2PS+1H' = \\frac{H - K + 2P}{S} + 1\nH′=SH−K+2P​+1

\n

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

\n

H′=⌊H−K+2PS⌋+1H' = \\left\\lfloor \\frac{H - K + 2P}{S} \\right\\rfloor + 1\nH′=⌊SH−K+2P​⌋+1

\n

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

\n

\"不同步幅对输出尺寸的影响\"

\n

# 感受野 Receptive Field

\n

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

\n

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

\n\n

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

\n

\"感受野逐层扩大示意图\"

\n

# 1×11 \\times 11×1 卷积

\n

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

\n\n

# 卷积的其他变体

\n

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

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
类型输入维度卷积核维度典型应用
1D 卷积N×C×LN \\times C \\times LN×C×LC×KC \\times KC×K序列数据（文本、音频、时间序列）
2D 卷积N×C×H×WN \\times C \\times H \\times WN×C×H×WC×Kh×KwC \\times K_h \\times K_wC×Kh​×Kw​图像处理
3D 卷积N×C×D×H×WN \\times C \\times D \\times H \\times WN×C×D×H×WC×Kd×Kh×KwC \\times K_d \\times K_h \\times K_wC×Kd​×Kh​×Kw​视频分析、医学影像（CT/MRI）
\n

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

\n

\"膨胀卷积示意图\"

\n

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

\n

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

\n

# 卷积层参数计算

\n

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

\n\n
\n

# 池化层 Pooling Layer

\n

# 为什么需要池化？

\n

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

\n

# 最大池化 Max Pooling

\n

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

\n

\"最大池化：取每个

\n

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

\n\n

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

\n

# 池化的设计约定

\n\n

# 平均池化 Average Pooling

\n

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

\n

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

\n

# 池化层的形状公式

\n

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

\n

H′=H−KS+1H' = \\frac{H - K}{S} + 1\nH′=SH−K​+1

\n

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

\n

H′=H2H' = \\frac{H}{2}\nH′=2H​

\n

# 其他池化方法

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

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

\n\n
\n

# CNN 架构设计

\n

# 典型架构模式

\n

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

\n

INPUT→[CONV→ReLU]N→POOL→[CONV→ReLU]M→POOL→FC→FC\\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}\nINPUT→[CONV→ReLU]N​→POOL→[CONV→ReLU]M​→POOL→FC→FC

\n

一个更具体的视觉模式：

\n

32×32×3→CONV+ReLU28×28×6→POOL14×14×6→CONV+ReLU10×10×10→POOL5×5×10→FlattenFC32 \\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}\n32×32×3CONV+ReLU​28×28×6POOL​14×14×6CONV+ReLU​10×10×10POOL​5×5×10Flatten​FC

\n

核心规律：

\n\n

\"典型

\n

# 参数量分布规律

\n

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

\n\n

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

\n

# 设计中的关键归纳偏置

\n

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

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

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

\n
\n

# 代码实现

\n

# 基本卷积运算的 NumPy 实现

\n
import numpy as np\n\ndef conv2d_forward(X, W, b, stride=1, pad=0):\n    \"\"\"\n    X: 输入 (N, C_in, H, W)\n    W: 滤波器 (C_out, C_in, K_h, K_w)\n    b: 偏置 (C_out,)\n    \"\"\"\n    N, C_in, H, W_in = X.shape\n    C_out, _, K_h, K_w = W.shape\n\n    H_out = (H + 2 * pad - K_h) // stride + 1\n    W_out = (W_in + 2 * pad - K_w) // stride + 1\n\n    # 填充\n    X_padded = np.pad(X, ((0,0), (0,0), (pad,pad), (pad,pad)))\n\n    out = np.zeros((N, C_out, H_out, W_out))\n\n    for n in range(N):\n        for c in range(C_out):\n            for h in range(H_out):\n                for w in range(W_out):\n                    h_start = h * stride\n                    w_start = w * stride\n                    patch = X_padded[n, :, h_start:h_start+K_h, w_start:w_start+K_w]\n                    out[n, c, h, w] = np.sum(patch * W[c]) + b[c]\n\n    return out\n\n\ndef max_pool2d_forward(X, pool_size=2, stride=2):\n    \"\"\"\n    最大池化前向传播\n    X: 输入 (N, C, H, W)\n    \"\"\"\n    N, C, H, W_in = X.shape\n    H_out = (H - pool_size) // stride + 1\n    W_out = (W_in - pool_size) // stride + 1\n\n    out = np.zeros((N, C, H_out, W_out))\n\n    for n in range(N):\n        for c in range(C):\n            for h in range(H_out):\n                for w in range(W_out):\n                    h_start = h * stride\n                    w_start = w * stride\n                    out[n, c, h, w] = np.max(\n                        X[n, c, h_start:h_start+pool_size, w_start:w_start+pool_size]\n                    )\n\n    return out
\n

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

\n
class SimpleCNN:\n    def __init__(self):\n        # 第一卷积层：3 → 6 通道, 5x5 卷积核\n        self.conv1_W = np.random.randn(6, 3, 5, 5) * 0.01\n        self.conv1_b = np.zeros(6)\n\n        # 第二卷积层：6 → 16 通道, 5x5 卷积核\n        self.conv2_W = np.random.randn(16, 6, 5, 5) * 0.01\n        self.conv2_b = np.zeros(16)\n\n        # 全连接层：16*5*5 = 400 → 120 → 10\n        self.fc1_W = np.random.randn(400, 120) * 0.01\n        self.fc1_b = np.zeros(120)\n        self.fc2_W = np.random.randn(120, 10) * 0.01\n        self.fc2_b = np.zeros(10)\n\n    def forward(self, X):\n        # 输入 X: (N, 3, 32, 32)\n        # Conv1: (N,3,32,32) → (N,6,28,28)\n        out = conv2d_forward(X, self.conv1_W, self.conv1_b)\n        out = np.maximum(0, out)  # ReLU\n\n        # Pool1: (N,6,28,28) → (N,6,14,14)\n        out = max_pool2d_forward(out, pool_size=2, stride=2)\n\n        # Conv2: (N,6,14,14) → (N,16,10,10)\n        out = conv2d_forward(out, self.conv2_W, self.conv2_b)\n        out = np.maximum(0, out)  # ReLU\n\n        # Pool2: (N,16,10,10) → (N,16,5,5)\n        out = max_pool2d_forward(out, pool_size=2, stride=2)\n\n        # Flatten: (N,16,5,5) → (N,400)\n        N = out.shape[0]\n        out = out.reshape(N, -1)\n\n        # FC1: (N,400) → (N,120)\n        out = out.dot(self.fc1_W) + self.fc1_b\n        out = np.maximum(0, out)  # ReLU\n\n        # FC2: (N,120) → (N,10)\n        scores = out.dot(self.fc2_W) + self.fc2_b\n        return scores
\n
\n

# Convolution Summary

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

# Pooling Summary

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

# 声明

\n

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

\n", "tags": [ "CS231n学习笔记", "CS231n", "计算机视觉", "深度学习", "卷积神经网络", "CNN" ] }, { "id": "https://yumengmeng.cn/2026/06/02/CS231n%E2%80%94%E2%80%94lecture4%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E4%B8%8E%E5%8F%8D%E5%90%91%E4%BC%A0%E6%92%AD/index/", "url": "https://yumengmeng.cn/2026/06/02/CS231n%E2%80%94%E2%80%94lecture4%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E4%B8%8E%E5%8F%8D%E5%90%91%E4%BC%A0%E6%92%AD/index/", "title": "CS231n——Lecture4 神经网络与反向传播", "date_published": "2026-06-02T05:06:16.000Z", "content_html": "

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

\n

# 回顾：线性函数

\n

线性分类器的核心公式：

\n

f(x,W)=Wxf(x, W) = Wx\nf(x,W)=Wx

\n

其中 x∈RDx \\in \\mathbb{R}^Dx∈RD，W∈RC×DW \\in \\mathbb{R}^{C \\times D}W∈RC×D。D 是输入维度，C 是类别数量（输出标签数量）。

\n

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

\n

# 双层神经网络

\n

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

\n

f(x,W1,W2)=W2max⁡(0,W1x)f(x, W_1, W_2) = W_2 \\max(0, W_1 x)\nf(x,W1​,W2​)=W2​max(0,W1​x)

\n

其中：

\n\n

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

\n

\"双层神经网络结构\"

\n

# 为什么要引入非线性？

\n

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

\n

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

\n

f=W2(W1x)=(W2W1)x=W3xf = W_2 (W_1 x) = (W_2 W_1) x = W_3 x\nf=W2​(W1​x)=(W2​W1​)x=W3​x

\n

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

\n

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

\n

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

\n
\n

# 激活函数 Activation Functions

\n

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

\n

# Sigmoid

\n

σ(x)=11+e−x\\sigma(x) = \\frac{1}{1+e^{-x}}\nσ(x)=1+e−x1​

\n

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

\n

\"Sigmoid\"

\n

# Tanh

\n

tanh⁡(x)=ex−e−xex+e−x\\tanh(x) = \\frac{e^x-e^{-x}}{e^x+e^{-x}}\ntanh(x)=ex+e−xex−e−x​

\n

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

\n

\"Tanh\"

\n

# ReLU

\n

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

\n

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

\n

\"ReLU\"

\n

\"ReLU

\n

# Leaky ReLU

\n

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

\n

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

\n

# ELU

\n

f(x)={xx≥0α(ex−1)x<0f(x) = \\begin{cases} x & x \\ge 0 \\\\ \\alpha(e^x-1) & x < 0 \\end{cases}\nf(x)={xα(ex−1)​x≥0x<0​

\n

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

\n

# GELU 与 SILU (Swish)

\n

GELU(x)=x⋅Φ(x),SILU(x)=x⋅σ(x)\\text{GELU}(x) = x \\cdot \\Phi(x), \\quad \\text{SILU}(x) = x \\cdot \\sigma(x)\nGELU(x)=x⋅Φ(x),SILU(x)=x⋅σ(x)

\n

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

\n

# 选择建议

\n\n
\n

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

\n

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

\n

# 第一步：定义模型

\n
import numpy as np\n\n# 超参数\nN = 100        # 样本数\nD = 3072       # 输入维度（如 CIFAR-10: 32×32×3）\nH = 100        # 隐藏神经元数量\nC = 10         # 输出类别数\n\n# 随机生成数据（仅示例）\nX = np.random.randn(N, D)\ny = np.random.randint(0, C, N)\n\n# 初始化权重：小随机数 × 缩放因子\nW1 = np.random.randn(D, H) * 0.01\nb1 = np.zeros(H)\nW2 = np.random.randn(H, C) * 0.01\nb2 = np.zeros(C)
\n

# 第二步：前向传播 Forward Pass

\n
# 隐藏层：线性变换 + ReLU 激活\nh = X @ W1 + b1          # [N, H]\nh_relu = np.maximum(0, h) # ReLU\n\n# 输出层：线性变换得到得分\nscores = h_relu @ W2 + b2 # [N, C]\n\n# Softmax 交叉熵损失\nexp_scores = np.exp(scores - np.max(scores, axis=1, keepdims=True))\nprobs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\n\n# 数据损失：负对数似然\nloss = -np.mean(np.log(probs[np.arange(N), y]))\n\n# 正则化损失：L2\nreg = 0.001 * (np.sum(W1**2) + np.sum(W2**2))\ntotal_loss = loss + reg
\n

# 第三步：反向传播 Backward Pass

\n
# Softmax 梯度\ndscores = probs.copy()\ndscores[np.arange(N), y] -= 1\ndscores /= N\n\n# W2 和 b2 的梯度\ndW2 = h_relu.T @ dscores + 2 * 0.001 * W2  # 包含正则化梯度\ndb2 = np.sum(dscores, axis=0)\n\n# 反向传播通过 ReLU：只路由到激活的神经元\ndh = dscores @ W2.T\ndh[h <= 0] = 0   # ReLU 反向：h≤0 的位置梯度为零\n\n# W1 和 b1 的梯度\ndW1 = X.T @ dh + 2 * 0.001 * W1\ndb1 = np.sum(dh, axis=0)
\n

# 第四步：梯度下降更新

\n
learning_rate = 1e-3\nW1 -= learning_rate * dW1\nb1 -= learning_rate * db1\nW2 -= learning_rate * dW2\nb2 -= learning_rate * db2
\n
\n

# 模型容量与正则化

\n

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

\n

实践中更推荐的做法是：

\n
\n

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

\n
\n

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

\n\n

\"不同隐藏层神经元数量下的决策边界\"

\n

\"不同正则化强度下的决策边界\"

\n

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

\n

得分: s=W2max⁡(0,W1x)\\text{得分: } s = W_2 \\max(0, W_1 x)\n得分: s=W2​max(0,W1​x)

\n

数据损失（Hinge）: Li=∑j≠yimax⁡(0,sj−syi+1)\\text{数据损失（Hinge）: } L_i = \\sum_{j \\neq y_i} \\max(0, s_j - s_{y_i} + 1)\n数据损失（Hinge）: Li​=j=yi​∑​max(0,sj​−syi​​+1)

\n

正则化（L2）: R(W)=∑k∑lWk,l2\\text{正则化（L2）: } R(W) = \\sum_k \\sum_l W_{k,l}^2\n正则化（L2）: R(W)=k∑​l∑​Wk,l2​

\n

总损失: L=1N∑iLi+λR(W1)+λR(W2)\\text{总损失: } L = \\frac{1}{N} \\sum_i L_i + \\lambda R(W_1) + \\lambda R(W_2)\n总损失: L=N1​i∑​Li​+λR(W1​)+λR(W2​)

\n
\n

# 计算图与反向传播

\n

# 什么是计算图？

\n

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

\n

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

\n

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

\n

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

\n
\n

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

\n

xxx 和 yyy 以及所有中间变量都是标量，导数就是普通的 dydx\\frac{dy}{dx}dxdy​。最基础的情形。

\n

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

\n

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

\n

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

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
步骤计算结果
∂f∂z\\frac{\\partial f}{\\partial z}∂z∂f​q×1=3q \\times 1 = 3q×1=33
∂f∂q\\frac{\\partial f}{\\partial q}∂q∂f​z×1=−4z \\times 1 = -4z×1=−4-4
∂f∂x\\frac{\\partial f}{\\partial x}∂x∂f​∂f∂q⋅∂q∂x=−4×1\\frac{\\partial f}{\\partial q} \\cdot \\frac{\\partial q}{\\partial x} = -4 \\times 1∂q∂f​⋅∂x∂q​=−4×1-4
∂f∂y\\frac{\\partial f}{\\partial y}∂y∂f​同理-4
\n

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

\n\n

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

\n

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

\n

dσ(x)dx=(1−σ(x))⋅σ(x)\\frac{d\\sigma(x)}{dx} = (1 - \\sigma(x)) \\cdot \\sigma(x)\ndxdσ(x)​=(1−σ(x))⋅σ(x)

\n

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

\n
# 前向\ndot = w[0]*x[0] + w[1]*x[1] + w[2]\nf = 1.0 / (1 + math.exp(-dot))   # sigmoid 复合门\n\n# 反向：一行公式得到梯度\nddot = (1 - f) * f               # σ'(x) = (1-σ)σ\ndx = [w[0] * ddot, w[1] * ddot]\ndw = [x[0] * ddot, x[1] * ddot, 1.0 * ddot]
\n
\n

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

\n

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

\n

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

\n

对于 y=f(x)y = f(x)y=f(x)，x∈Rn,y∈Rmx \\in \\mathbb{R}^n, y \\in \\mathbb{R}^mx∈Rn,y∈Rm，LLL 为标量：

\n

∂L∂x=(∂y∂x)T⋅∂L∂y\\frac{\\partial L}{\\partial x} = \\left(\\frac{\\partial y}{\\partial x}\\right)^T \\cdot \\frac{\\partial L}{\\partial y}\n∂x∂L​=(∂x∂y​)T⋅∂y∂L​

\n

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

\n

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

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

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

\n

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

\n

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

\n\n

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

\n

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

\n

∂L∂W=XT⋅∂L∂Y\\frac{\\partial L}{\\partial W} = X^T \\cdot \\frac{\\partial L}{\\partial Y}\n∂W∂L​=XT⋅∂Y∂L​

\n

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

\n

∂L∂X=∂L∂Y⋅WT\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot W^T\n∂X∂L​=∂Y∂L​⋅WT

\n

用代码写出来就两行：

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

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

\n

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

\n
\n

# 实践要点

\n
    \n
  1. 分阶段计算：把复杂函数拆成简单中间变量，每个独立求导，链式组合
    2. \n
  2. 缓存前向值：反向需要前向的中间结果，别重复算
    3. \n
  3. 分支处用 +=：同一变量被多次使用时，梯度必须累加
    4. \n
  4. 梯度形状 = 变量形状：所有向量化反向传播的推导起点
    5. \n
  5. 先数值梯度检查，再切解析梯度：调试时用有限差分验证实现正确性
    6. \n
\n
class MultiplyGate:\n    def forward(self, x, y):\n        self.x, self.y = x, y  # 缓存\n        return x * y\n\n    def backward(self, dout):\n        return self.y * dout, self.x * dout  # 交换 + 乘上游梯度
\n

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

\n
\n

# 声明

\n

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

\n", "tags": [ "CS231n学习笔记", "CS231n", "计算机视觉", "深度学习", "神经网络", "反向传播" ] }, { "id": "https://yumengmeng.cn/2026/05/31/CS231n%E2%80%94%E2%80%94lecture3%E6%AD%A3%E5%88%99%E5%8C%96%E4%B8%8E%E4%BC%98%E5%8C%96/index/", "url": "https://yumengmeng.cn/2026/05/31/CS231n%E2%80%94%E2%80%94lecture3%E6%AD%A3%E5%88%99%E5%8C%96%E4%B8%8E%E4%BC%98%E5%8C%96/index/", "title": "CS231n——Lecture3 正则化与优化", "date_published": "2026-05-31T07:27:56.000Z", "content_html": "

# 正则化 Regularization

\n

# 为什么需要正则化？

\n

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

\n

L(W)=1N∑iLi(f(xi,W),yi)+λR(W)L(W) = \\frac{1}{N} \\sum_i L_i(f(x_i, W), y_i) + \\lambda R(W)\nL(W)=N1​i∑​Li​(f(xi​,W),yi​)+λR(W)

\n

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

\n

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

\n

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

\n

# 正则化的三个核心作用

\n\n

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

\n\n
\n

# L1 正则化（Lasso）

\n

公式：

\n

R(W)=∑k∑l∣Wk,l∣R(W) = \\sum_k \\sum_l |W_{k,l}|\nR(W)=k∑​l∑​∣Wk,l​∣

\n

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

\n

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

\n

代码实现：

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

# L2 正则化（Weight Decay / Ridge）

\n

公式：

\n

R(W)=∑k∑lWk,l2R(W) = \\sum_k \\sum_l W_{k,l}^2\nR(W)=k∑​l∑​Wk,l2​

\n

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

\n

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

\n\n

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

\n

代码实现：

\n
def l2_regularization(W, lambda_reg):\n    \"\"\"\n    L2 正则化损失\n    W: 权重矩阵\n    lambda_reg: 正则化强度超参数\n    \"\"\"\n    reg_loss = lambda_reg * np.sum(W * W)\n    return reg_loss\n\ndef l2_gradient(W, lambda_reg):\n    \"\"\"\n    L2 正则化的梯度：d(R)/dW = 2 * lambda * W\n    \"\"\"\n    dW = 2 * lambda_reg * W\n    return dW
\n
\n

# Elastic Net

\n

公式：

\n

R(W)=∑k∑l(β⋅Wk,l2+∣Wk,l∣)R(W) = \\sum_k \\sum_l \\left(\\beta \\cdot W_{k,l}^2 + |W_{k,l}|\\right)\nR(W)=k∑​l∑​(β⋅Wk,l2​+∣Wk,l​∣)

\n

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

\n

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

\n\n
\n

# 优化 Optimization

\n

# 优化问题概述

\n

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

\n

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

\n
\n

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

\n

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

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

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

\n

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

\n
\n

# 梯度下降法 Gradient Descent

\n

# 介绍

\n

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

\n

# 思路

\n

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

\n

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

\n

# 原理

\n

一维情况：导数 dfdx=lim⁡h→0f(x+h)−f(x)h\\frac{df}{dx} = \\lim_{h \\to 0} \\frac{f(x+h) - f(x)}{h}dxdf​=limh→0​hf(x+h)−f(x)​，表示函数在该点的瞬时变化率。

\n

多维情况：梯度 ∇WL=(∂L∂w1,∂L∂w2,...,∂L∂wn)\\nabla_W L = \\left(\\frac{\\partial L}{\\partial w_1}, \\frac{\\partial L}{\\partial w_2}, ..., \\frac{\\partial L}{\\partial w_n}\\right)∇W​L=(∂w1​∂L​,∂w2​∂L​,...,∂wn​∂L​)，是一个 n 维向量。

\n

更新公式：

\n

W←W−α⋅∇WLW \\leftarrow W - \\alpha \\cdot \\nabla_W L\nW←W−α⋅∇W​L

\n

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

\n

θt+1=θt−α⋅∇θJ(θt)\\theta_{t+1} = \\theta_t - \\alpha \\cdot \\nabla_\\theta J(\\theta_t)\nθt+1​=θt​−α⋅∇θ​J(θt​)

\n

\"不同步长（学习率）对梯度下降的影响\"

\n

# 数值梯度 vs 解析梯度

\n

计算梯度有两种方式：

\n

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

\n

dfdx≈f(x+h)−f(x−h)2h\\frac{df}{dx} \\approx \\frac{f(x+h) - f(x-h)}{2h}\ndxdf​≈2hf(x+h)−f(x−h)​

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

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

\n

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

\n

∇WLi={0if syi≥sj+1xiif syi<sj+1\\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}\n∇W​Li​={0xi​​if syi​​≥sj​+1if syi​​<sj​+1​

\n\n

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

\n

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

\n
def gradient_descent(X, y, W_init, learning_rate, num_iters):\n    \"\"\"\n    全量梯度下降（Batch Gradient Descent）\n    每次迭代使用全部训练数据计算梯度\n    \"\"\"\n    W = W_init.copy()\n    loss_history = []\n\n    for i in range(num_iters):\n        # 计算在整个训练集上的梯度\n        scores = X.dot(W)\n        loss, dW = svm_loss(scores, y)  # 包含数据损失 + 正则化损失的梯度\n\n        # 沿负梯度方向更新\n        W -= learning_rate * dW\n\n        loss_history.append(loss)\n\n    return W, loss_history
\n

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

\n
\n

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

\n

# 介绍

\n

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

\n

# 思路

\n

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

\n
\n

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

\n
\n

# 原理

\n

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

\n

W←W−α⋅1N∑i=1N∇WLiW \\leftarrow W - \\alpha \\cdot \\frac{1}{N}\\sum_{i=1}^N \\nabla_W L_i\nW←W−α⋅N1​i=1∑N​∇W​Li​

\n

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

\n

W←W−α⋅1m∑k=1m∇WLikW \\leftarrow W - \\alpha \\cdot \\frac{1}{m}\\sum_{k=1}^m \\nabla_W L_{i_k}\nW←W−α⋅m1​k=1∑m​∇W​Lik​​

\n

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

\n

# SGD 面临的三大挑战

\n

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

\n

挑战一：病态条件 Ill-Conditioning

\n

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

\n

挑战二：鞍点 Saddle Points

\n

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

\n

挑战三：梯度噪声 Gradient Noise

\n

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

\n

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

\n

# 代码实现

\n
def sgd(X, y, W_init, learning_rate, batch_size, num_epochs):\n    \"\"\"\n    小批量随机梯度下降\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        # 每个 epoch 开始时打乱数据顺序\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            # 取一个 mini-batch\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            # 计算 mini-batch 梯度\n            scores = X_batch.dot(W)\n            loss, dW = svm_loss(scores, y_batch)\n\n            # 更新\n            W -= learning_rate * dW\n            loss_history.append(loss)\n\n    return W, loss_history
\n
\n

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

\n

# 介绍

\n

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

\n

# 思路

\n

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

\n

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

\n

# 原理

\n

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

\n

vt+1=ρ⋅vt+∇WLv_{t+1} = \\rho \\cdot v_t + \\nabla_W L\nvt+1​=ρ⋅vt​+∇W​L

\n

W←W−α⋅vt+1W \\leftarrow W - \\alpha \\cdot v_{t+1}\nW←W−α⋅vt+1​

\n

其中：

\n\n

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

\n

vt+1≈ρ⋅vtv_{t+1} \\approx \\rho \\cdot v_t\nvt+1​≈ρ⋅vt​

\n

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

\n

# Nesterov 加速梯度（NAG）

\n

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

\n

vt+1=ρ⋅vt−α⋅∇WL(W+ρ⋅vt)v_{t+1} = \\rho \\cdot v_t - \\alpha \\cdot \\nabla_W L(W + \\rho \\cdot v_t)\nvt+1​=ρ⋅vt​−α⋅∇W​L(W+ρ⋅vt​)

\n

W←W+vt+1W \\leftarrow W + v_{t+1}\nW←W+vt+1​

\n

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

\n

\"Nesterov

\n

# 代码实现

\n
def sgd_momentum(X, y, W_init, learning_rate, momentum, batch_size, num_epochs):\n    \"\"\"\n    带动量的随机梯度下降\n    momentum: 动量系数，典型值 0.9\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    v = np.zeros_like(W)  # 初始化速度为零\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            scores = X_batch.dot(W)\n            loss, dW = svm_loss(scores, y_batch)\n\n            # 核心：速度更新 + 参数更新\n            v = momentum * v + dW          # 累积历史梯度\n            W -= learning_rate * v          # 用速度（而非原始梯度）更新\n\n            loss_history.append(loss)\n\n    return W, loss_history\n\n# Nesterov 动量版本\ndef sgd_nesterov(X, y, W_init, learning_rate, momentum, batch_size, num_epochs):\n    \"\"\"\n    Nesterov 加速梯度下降\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    v = np.zeros_like(W)\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            # 在\"前瞻\"位置计算梯度\n            W_ahead = W - momentum * v\n            scores = X_batch.dot(W_ahead)\n            loss, dW = svm_loss(scores, y_batch)\n\n            v = momentum * v + learning_rate * dW\n            W -= v\n\n            loss_history.append(loss)\n\n    return W, loss_history
\n
\n

# RMSProp

\n

# 介绍

\n

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

\n

# 思路

\n

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

\n

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

\n

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

\n

# 原理

\n

cachet+1=ρ⋅cachet+(1−ρ)⋅(∇WL)2\\text{cache}_{t+1} = \\rho \\cdot \\text{cache}_t + (1 - \\rho) \\cdot (\\nabla_W L)^2\ncachet+1​=ρ⋅cachet​+(1−ρ)⋅(∇W​L)2

\n

W←W−αcachet+1+ϵ⋅∇WLW \\leftarrow W - \\frac{\\alpha}{\\sqrt{\\text{cache}_{t+1}} + \\epsilon} \\cdot \\nabla_W L\nW←W−cachet+1​​+ϵα​⋅∇W​L

\n

其中：

\n\n

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

\n

cacheAdaGrad=cache+(∇WL)2\\text{cache}_{\\text{AdaGrad}} = \\text{cache} + (\\nabla_W L)^2\ncacheAdaGrad​=cache+(∇W​L)2

\n

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

\n

# 代码实现

\n
def rmsprop(X, y, W_init, learning_rate, decay_rate, batch_size, num_epochs, eps=1e-7):\n    \"\"\"\n    RMSProp 优化器\n    decay_rate: 梯度平方的衰减率 (rho)，典型值 0.9 或 0.99\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    cache = np.zeros_like(W)  # 梯度平方的移动平均\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            scores = X_batch.dot(W)\n            loss, dW = svm_loss(scores, y_batch)\n\n            # 更新梯度平方的移动平均\n            cache = decay_rate * cache + (1 - decay_rate) * dW ** 2\n\n            # 逐元素自适应学习率\n            W -= learning_rate * dW / (np.sqrt(cache) + eps)\n\n            loss_history.append(loss)\n\n    return W, loss_history
\n
\n

# Adam（Adaptive Moment Estimation）

\n

# 介绍

\n

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

\n

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

\n

# 思路

\n

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

\n\n

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

\n

W←W−α⋅mtvt+ϵW \\leftarrow W - \\alpha \\cdot \\frac{m_t}{\\sqrt{v_t} + \\epsilon}\nW←W−α⋅vt​​+ϵmt​​

\n

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

\n

# 原理

\n

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

\n

mt=β1⋅mt−1+(1−β1)⋅∇WLm_t = \\beta_1 \\cdot m_{t-1} + (1 - \\beta_1) \\cdot \\nabla_W L\nmt​=β1​⋅mt−1​+(1−β1​)⋅∇W​L

\n

vt=β2⋅vt−1+(1−β2)⋅(∇WL)2v_t = \\beta_2 \\cdot v_{t-1} + (1 - \\beta_2) \\cdot (\\nabla_W L)^2\nvt​=β2​⋅vt−1​+(1−β2​)⋅(∇W​L)2

\n

第二步：偏差修正

\n

m^t=mt1−β1t\\hat{m}_t = \\frac{m_t}{1 - \\beta_1^t}\nm^t​=1−β1t​mt​​

\n

v^t=vt1−β2t\\hat{v}_t = \\frac{v_t}{1 - \\beta_2^t}\nv^t​=1−β2t​vt​​

\n

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

\n

第三步：参数更新

\n

W←W−α⋅m^tv^t+ϵW \\leftarrow W - \\alpha \\cdot \\frac{\\hat{m}_t}{\\sqrt{\\hat{v}_t} + \\epsilon}\nW←W−α⋅v^t​​+ϵm^t​​

\n

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

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

# AdamW：解耦权重衰减

\n

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

\n

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

\n

W←W−α⋅m^tv^t+ϵ−α⋅λ⋅WW \\leftarrow W - \\alpha \\cdot \\frac{\\hat{m}_t}{\\sqrt{\\hat{v}_t} + \\epsilon} - \\alpha \\cdot \\lambda \\cdot W\nW←W−α⋅v^t​​+ϵm^t​​−α⋅λ⋅W

\n

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

\n

# 代码实现

\n
def adam(X, y, W_init, learning_rate, beta1, beta2, batch_size, num_epochs, eps=1e-8):\n    \"\"\"\n    Adam 优化器\n    beta1: 一阶矩衰减率，默认 0.9\n    beta2: 二阶矩衰减率，默认 0.999\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    m = np.zeros_like(W)  # 一阶矩（动量）\n    v = np.zeros_like(W)  # 二阶矩（RMSProp cache）\n    t = 0                 # 时间步计数\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            t += 1\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            scores = X_batch.dot(W)\n            loss, dW = svm_loss(scores, y_batch)\n\n            # 更新一阶矩和二阶矩\n            m = beta1 * m + (1 - beta1) * dW\n            v = beta2 * v + (1 - beta2) * (dW ** 2)\n\n            # 偏差修正\n            m_unbiased = m / (1 - beta1 ** t)\n            v_unbiased = v / (1 - beta2 ** t)\n\n            # 参数更新\n            W -= learning_rate * m_unbiased / (np.sqrt(v_unbiased) + eps)\n\n            loss_history.append(loss)\n\n    return W, loss_history\n\n\ndef adamw(X, y, W_init, learning_rate, beta1, beta2,\n          weight_decay, batch_size, num_epochs, eps=1e-8):\n    \"\"\"\n    AdamW 优化器：将权重衰减从自适应学习率中解耦\n    weight_decay: 权重衰减系数（即原 L2 正则化的 lambda）\n    \"\"\"\n    N = X.shape[0]\n    W = W_init.copy()\n    m = np.zeros_like(W)\n    v = np.zeros_like(W)\n    t = 0\n    loss_history = []\n\n    num_iters_per_epoch = N // batch_size\n\n    for epoch in range(num_epochs):\n        idx = np.random.permutation(N)\n        X_shuffled = X[idx]\n        y_shuffled = y[idx]\n\n        for i in range(num_iters_per_epoch):\n            t += 1\n            start = i * batch_size\n            end = start + batch_size\n            X_batch = X_shuffled[start:end]\n            y_batch = y_shuffled[start:end]\n\n            # 注意：梯度计算中不包含 L2 正则化项\n            scores = X_batch.dot(W)\n            loss, dW = svm_loss_without_reg(scores, y_batch)\n\n            m = beta1 * m + (1 - beta1) * dW\n            v = beta2 * v + (1 - beta2) * (dW ** 2)\n\n            m_unbiased = m / (1 - beta1 ** t)\n            v_unbiased = v / (1 - beta2 ** t)\n\n            # 自适应更新 + 解耦的权重衰减\n            W -= learning_rate * m_unbiased / (np.sqrt(v_unbiased) + eps)\n            W -= learning_rate * weight_decay * W  # 独立的权重衰减步骤\n\n            loss_history.append(loss)\n\n    return W, loss_history
\n
\n

# 优化器对比总结

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

\"各优化器在损失曲面上的收敛轨迹对比\"

\n
\n

# 学习率调度策略 Learning Rate Scheduling

\n

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

\n

# 常用策略

\n

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

\n

余弦退火 Cosine Annealing：

\n

αt=12⋅α0⋅(1+cos⁡(tTπ))\\alpha_t = \\frac{1}{2} \\cdot \\alpha_0 \\cdot (1 + \\cos(\\frac{t}{T}\\pi))\nαt​=21​⋅α0​⋅(1+cos(Tt​π))

\n

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

\n

线性衰减 Linear Decay：

\n

αt=α0⋅(1−t/T)\\alpha_t = \\alpha_0 \\cdot (1 - t/T)\nαt​=α0​⋅(1−t/T)

\n

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

\n

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

\n

# 实践建议

\n\n

\"不同学习率对

\n

\"数据流总览：输入

\n
\n

# 声明

\n

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

\n", "tags": [ "CS231n学习笔记", "CS231n", "计算机视觉", "深度学习", "正则化", "优化算法" ] }, { "id": "https://yumengmeng.cn/2026/05/31/CS231n%E2%80%94%E2%80%94lecture2%E4%BD%BF%E7%94%A8%E7%BA%BF%E6%80%A7%E5%88%86%E7%B1%BB%E5%99%A8%E8%BF%9B%E8%A1%8C%E5%9B%BE%E5%83%8F%E5%88%86%E7%B1%BB/index/", "url": "https://yumengmeng.cn/2026/05/31/CS231n%E2%80%94%E2%80%94lecture2%E4%BD%BF%E7%94%A8%E7%BA%BF%E6%80%A7%E5%88%86%E7%B1%BB%E5%99%A8%E8%BF%9B%E8%A1%8C%E5%9B%BE%E5%83%8F%E5%88%86%E7%B1%BB/index/", "title": "CS231n——Lecture2 使用线性分类器进行图像分类", "date_published": "2026-05-31T06:27:50.000Z", "content_html": "

# 图像分类 Image Classification

\n

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

\n

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

\n

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

\n\n

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

\n

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

\n\n

\"CIFAR-10

\n
def train(images, labels):\n    # 记忆数据与标签\n    return model\n\ndef predict(model, test_images):\n    # 为测试图像找到最相近的训练图像，输出该图像标签\n    return test_labels
\n
\n

# 最近邻分类器 Nearest Neighbor Classifier

\n

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

\n

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

\n

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

\n

d1(I1,I2)=∑p∣I1p−I2p∣d_1(I_1, I_2) = \\sum_p |I_1^p - I_2^p|\nd1​(I1​,I2​)=p∑​∣I1p​−I2p​∣

\n

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

\n

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

\n

d2(I1,I2)=∑p(I1p−I2p)2d_2(I_1, I_2) = \\sqrt{\\sum_p (I_1^p - I_2^p)^2}\nd2​(I1​,I2​)=p∑​(I1p​−I2p​)2​

\n

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

\n

完整的 Nearest Neighbor 分类器实现：

\n
import numpy as np\n\nclass NearestNeighbor:\n    def __init__(self):\n        pass\n\n    def train(self, X, y):\n        \"\"\"训练就是记住所有训练数据，只需 O(1) 时间\"\"\"\n        self.Xtr = X\n        self.ytr = y\n\n    def predict(self, X):\n        \"\"\"预测：对每个测试样本，遍历训练集找到最近邻\"\"\"\n        num_test = X.shape[0]\n        Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\n\n        for i in range(num_test):\n            # 使用 L1 距离：广播计算测试样本与所有训练样本的差值\n            distances = np.sum(np.abs(self.Xtr - X[i, :]), axis=1)\n            # 找到距离最小的训练样本索引\n            min_index = np.argmin(distances)\n            # 输出该训练样本的标签\n            Ypred[i] = self.ytr[min_index]\n\n        return Ypred
\n

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

\n\n

\"L1

\n
\n

# K-邻近算法 K-Nearest Neighbor

\n

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

\n\n

\"不同

\n

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

\n

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

\n\n
# 交叉验证示例：在 CIFAR-10 上为 KNN 寻找最佳 K 值\n# 假设 Xtr_rows 和 Ytr 是训练数据\nXval_rows = Xtr_rows[:1000, :]    # 取前 1000 个作为验证集\nYval = Ytr[:1000]\nXtr_rows = Xtr_rows[1000:, :]     # 剩余作为训练集\nYtr = Ytr[1000:]\n\nvalidation_accuracies = []\nfor k in [1, 3, 5, 10, 20, 50, 100]:\n    # 对每个 k 值评估验证集精度\n    nn = NearestNeighbor()\n    nn.train(Xtr_rows, Ytr)\n    Yval_predict = nn.predict(Xval_rows, k=k)\n    acc = np.mean(Yval_predict == Yval)\n    validation_accuracies.append((k, acc))
\n

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

\n

\"交叉验证中不同

\n

\"K-Fold

\n

KNN 的三大缺陷：

\n\n

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

\n
\n

# 线性分类器 Linear Classifier

\n

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

\n

# 核心公式

\n

f(x,W)=Wx+bf(x, W) = Wx + b\nf(x,W)=Wx+b

\n\n

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

\n

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

\n

# 技巧：将 W 和 b 合并

\n

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

\n

f(x,W)=Wxf(x, W) = Wx\nf(x,W)=Wx

\n

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

\n

\"偏置技巧：将

\n

# 模板匹配视角 Template Matching

\n

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

\n\n

\"CIFAR-10

\n

# 图像预处理

\n

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

\n

# 线性分类器的局限性

\n

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

\n

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

\n\n

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

\n
\n

# 损失函数 Loss Function

\n

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

\n

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

\n

Li=∑j≠yimax⁡(0,sj−syi+Δ)L_i = \\sum_{j \\neq y_i} \\max(0, s_j - s_{y_i} + \\Delta)\nLi​=j=yi​∑​max(0,sj​−syi​​+Δ)

\n\n

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

\n

\"多分类

\n

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

\n

将得分转化为概率分布：

\n
    \n
  1. 指数化：取 eske^{s_k}esk​，确保所有值 > 0
    2. \n
  2. 归一化：除以所有指数之和 ∑jesj\\sum_j e^{s_j}∑j​esj​，使所有概率之和为 1
    3. \n
\n

P(Y=k∣X=xi)=esk∑jesjP(Y=k|X=x_i) = \\frac{e^{s_k}}{\\sum_j e^{s_j}}\nP(Y=k∣X=xi​)=∑j​esj​esk​​

\n

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

\n

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

\n

Li=−log⁡P(Y=yi∣X=xi)L_i = -\\log P(Y=y_i|X=x_i)\nLi​=−logP(Y=yi​∣X=xi​)

\n

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

\n

# 交叉熵与 KL 散度的关系

\n

H(P,Q)=−∑xP(x)log⁡Q(x)H(P, Q) = -\\sum_x P(x) \\log Q(x)\nH(P,Q)=−x∑​P(x)logQ(x)

\n

DKL(P∥Q)=∑xP(x)log⁡P(x)Q(x)D_{KL}(P \\parallel Q) = \\sum_x P(x) \\log \\frac{P(x)}{Q(x)}\nDKL​(P∥Q)=x∑​P(x)logQ(x)P(x)​

\n

H(P,Q)=H(P)+DKL(P∥Q)H(P, Q) = H(P) + D_{KL}(P \\parallel Q)\nH(P,Q)=H(P)+DKL​(P∥Q)

\n\n

\"SVM

\n

# 两个实用的 Debug 问题

\n

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

\n

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

\n

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

\n

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

\n

Li=−log⁡(1/C)=log⁡(C)L_i = -\\log(1/C) = \\log(C)\nLi​=−log(1/C)=log(C)

\n

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

\n

# 正则化 Regularization

\n

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

\n

L=1N∑iLi+λR(W)L = \\frac{1}{N} \\sum_i L_i + \\lambda R(W)\nL=N1​i∑​Li​+λR(W)

\n\n

常见的正则化方式：

\n\n
\n

# 声明

\n

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

\n", "tags": [ "CS231n学习笔记", "CS231n", "计算机视觉", "深度学习" ] } ] }