经典CNN架构：LeNet、AlexNet、VGGNet

一句话概述

LeNet、AlexNet和VGGNet是CNN发展史上三座里程碑式的经典架构。LeNet（1998）开创了卷积神经网络用于图像识别的先河，奠定了"卷积+池化+全连接"的基本范式；AlexNet（2012）以更深更宽的网络和ReLU激活函数在ImageNet竞赛中以压倒性优势夺冠，引爆了深度学习革命；VGGNet（2014）通过"全3×3小卷积核堆叠"的设计哲学，证明了网络的深度是提升性能的关键。这三代架构的演进清晰地展示了CNN从雏形到成熟的发展历程。

💡 核心要点：①LeNet-5是第一个成功的CNN，7层结构奠定了Conv→Pool→FC的基本范式 ②AlexNet首次使用ReLU、Dropout和GPU训练，在ImageNet上错误率降低近10个百分点 ③VGGNet统一使用3×3小卷积核堆叠，通过增加深度（16-19层）提升性能 ④三者的演进体现了"更深、更宽、更简单规则"的发展趋势

教学与演示

一、LeNet-5：卷积神经网络的开山之作

是什么（定义）：LeNet-5由Yann LeCun于1998年提出，是第一个成功应用于商业场景（手写数字识别）的CNN。它包含7层（3个卷积层+2个池化层+2个全连接层），输入为32×32的灰度图像，输出为10个类别的概率。其"卷积→池化→卷积→池化→全连接→全连接→输出"的结构成为后续20年CNN设计的模板。

大白话 LeNet就是最早的"看图识字"AI——给它一张手写数字的照片，它能认出是0到9中的哪一个。它的结构像一个漏斗：前面用卷积提取特征，中间用池化压缩，最后用全连接层做决策。

为什么（原理）：LeNet的设计体现了三个核心思想：①局部感受野——每个神经元只连接输入的一小块区域；②权重共享——同一卷积核在整个图像上共享参数；③子采样（池化）——通过平均池化降低分辨率和计算量。这三个思想至今仍是CNN的基础。

怎么做（实现）：

import numpy as np

# ========================================
# LeNet-5 简化实现 —— 经典手写数字识别网络
# 结构: Conv(6@5×5)→Pool(2×2)→Conv(16@5×5)→Pool(2×2)→FC(120)→FC(84)→FC(10)
# ========================================

class LeNet5:
    """
    LeNet-5 简化版（无RBF输出层，使用Softmax代替）
    输入: 32×32 灰度图（1通道）
    输出: 10类数字（0-9）
    """
    def __init__(self):
        # ---- 卷积层1: 1×32×32 → 6×28×28 ----
        # 6个5×5卷积核，无填充，步长1
        self.conv1_W = np.random.randn(6, 1, 5, 5) * 0.1  # (6, 1, 5, 5)
        self.conv1_b = np.zeros(6)
        
        # ---- 卷积层2: 6×14×14 → 16×10×10 ----
        # 16个5×5卷积核（LeNet原始使用非全连接，这里简化为全连接）
        self.conv2_W = np.random.randn(16, 6, 5, 5) * 0.1  # (16, 6, 5, 5)
        self.conv2_b = np.zeros(16)
        
        # ---- 全连接层1: 16×5×5=400 → 120 ----
        self.fc1_W = np.random.randn(400, 120) * 0.1
        self.fc1_b = np.zeros(120)
        
        # ---- 全连接层2: 120 → 84 ----
        self.fc2_W = np.random.randn(120, 84) * 0.1
        self.fc2_b = np.zeros(84)
        
        # ---- 输出层: 84 → 10 ----
        self.fc3_W = np.random.randn(84, 10) * 0.1
        self.fc3_b = np.zeros(10)
        
        self._summarize_params()
    
    def _summarize_params(self):
        """统计总参数量"""
        total = 0
        for name, param in [
            ("Conv1", self.conv1_W), ("Conv1_b", self.conv1_b),
            ("Conv2", self.conv2_W), ("Conv2_b", self.conv2_b),
            ("FC1", self.fc1_W), ("FC1_b", self.fc1_b),
            ("FC2", self.fc2_W), ("FC2_b", self.fc2_b),
            ("FC3", self.fc3_W), ("FC3_b", self.fc3_b),
        ]:
            n = param.size
            total += n
            print(f"  {name}: {n:,} 参数")
        print(f"  总计: {total:,} 参数\n")
    
    def _conv2d_single(self, x, W, b):
        """单样本卷积（简化版）"""
        C_out, C_in, kH, kW = W.shape
        _, H, W_in = x.shape
        out_H, out_W = H - kH + 1, W_in - kW + 1
        out = np.zeros((C_out, out_H, out_W))
        for co in range(C_out):
            for ci in range(C_in):
                for i in range(out_H):
                    for j in range(out_W):
                        out[co, i, j] += np.sum(
                            x[ci, i:i+kH, j:j+kW] * W[co, ci])
            out[co] += b[co]
        return out
    
    def _max_pool(self, x, size=2):
        """2×2最大池化"""
        C, H, W = x.shape
        out_H, out_W = H // size, W // size
        out = np.zeros((C, out_H, out_W))
        for c in range(C):
            for i in range(out_H):
                for j in range(out_W):
                    out[c, i, j] = np.max(
                        x[c, i*size:(i+1)*size, j*size:(j+1)*size])
        return out
    
    def _relu(self, x):
        return np.maximum(0, x)
    
    def _softmax(self, x):
        """Softmax：将输出转化为概率分布"""
        e_x = np.exp(x - np.max(x))  # 减去最大值防数值溢出
        return e_x / np.sum(e_x)
    
    def forward(self, x):
        """
        前向传播：输入 32×32 灰度图
        返回: 10个类别的概率分布
        """
        # 添加通道维度: (32,32) → (1,32,32)
        if x.ndim == 2:
            x = x[np.newaxis, :, :]
        
        # Stage 1: Conv1 → Pool1
        # 32×32 → 6×28×28 → 6×14×14
        c1 = self._relu(self._conv2d_single(x, self.conv1_W, self.conv1_b))
        p1 = self._max_pool(c1)
        
        # Stage 2: Conv2 → Pool2
        # 6×14×14 → 16×10×10 → 16×5×5
        c2 = self._relu(self._conv2d_single(p1, self.conv2_W, self.conv2_b))
        p2 = self._max_pool(c2)
        
        # Stage 3: 全连接部分
        # 16×5×5=400 → 120 → 84 → 10
        flat = p2.reshape(-1)  # 展平为 400 维向量
        fc1 = self._relu(np.dot(flat, self.fc1_W) + self.fc1_b)
        fc2 = self._relu(np.dot(fc1, self.fc2_W) + self.fc2_b)
        logits = np.dot(fc2, self.fc3_W) + self.fc3_b
        probs = self._softmax(logits)
        return probs


# --- 创建LeNet-5实例 ---
print("LeNet-5 网络结构：")
print("=" * 40)
print("输入:  1×32×32 (灰度手写数字)")
print("  ↓ Conv1: 6@5×5, stride=1, no padding")
print("  6×28×28")
print("  ↓ MaxPool: 2×2, stride=2")
print("  6×14×14")
print("  ↓ Conv2: 16@5×5, stride=1, no padding")
print("  16×10×10")
print("  ↓ MaxPool: 2×2, stride=2")
print("  16×5×5")
print("  ↓ Flatten → 400")
print("  ↓ FC1: 400 → 120 (ReLU)")
print("  ↓ FC2: 120 → 84 (ReLU)")
print("  ↓ FC3: 84 → 10 (Softmax)")
print("输出:  10类概率 (数字0-9)\n")

net = LeNet5()

# 测试前向传播
test_img = np.random.randn(32, 32)  # 随机输入
probs = net.forward(test_img)
predicted_class = np.argmax(probs)
print(f"测试结果: 预测类别={predicted_class}, 置信度={probs[predicted_class]:.4f}")

大白话 LeNet的流程：输入32×32的手写数字图像 → 第一轮卷积提取简单笔画特征（6张28×28图）→ 池化压缩一半 → 第二轮卷积提取笔画组合特征（16张10×10图）→ 再压缩 → 展开成一长串数字 → 全连接判断是哪个数字。

什么用（AI关联）：LeNet的成功证明了CNN可以通过反向传播自动学习层次化的视觉特征。它直接启发了后续所有CNN架构的设计。今天在MNIST数据集上，LeNet可以达到99%以上的准确率。PyTorch官方教程中的第一个CNN示例通常就是LeNet。

哪些坑（缺点）：①层数太少（7层），表达能力有限，只能处理简单任务。②使用Sigmoid/Tanh激活，存在梯度消失问题。③使用平均池化而非最大池化。④计算资源限制（1998年的硬件），无法扩展到更大数据集。

二、AlexNet：深度学习革命的引爆者

是什么（定义）：AlexNet由Alex Krizhevsky、Ilya Sutskever和Geoffrey Hinton在2012年提出，在ImageNet LSVRC-2012竞赛中以15.3%的top-5错误率夺冠（第二名错误率为26.2%）。它包含8层（5个卷积层+3个全连接层），约6000万参数，是深度学习在计算机视觉领域取得突破性胜利的标志。

大白话 AlexNet就是LeNet的"究极加强版"——层数从7加到8，参数从6万暴增到6000万，首次用上了GPU训练和ReLU激活函数。它在2012年的ImageNet比赛中以10个百分点的巨大优势碾压了所有传统CV方法，宣告了深度学习时代的到来。

为什么（原理）：AlexNet有五个关键创新使其成功：①ReLU激活——训练速度比Tanh快6倍，且无梯度饱和。②双GPU并行训练——将网络分成两半在两张GTX 580 GPU上分别训练。③重叠池化——3×3池化窗口、步长2，轻微提升精度。④Dropout——在前两个全连接层使用50%的Dropout防止过拟合。⑤数据增强——随机裁剪、水平翻转、PCA颜色增强扩大有效数据集。

怎么做（实现）：

import numpy as np

# ========================================
# AlexNet 核心创新模拟
# 演示 ReLU vs Sigmoid 的训练速度差异
# 和 Dropout 的正则化效果
# ========================================

def compare_activations():
    """
    模拟 ReLU 和 Sigmoid 在深层网络中的梯度传播差异
    """
    print("AlexNet 关键创新1: ReLU vs Sigmoid")
    print("=" * 50)
    
    # 模拟一个6层网络的梯度传播
    # 假设每层对梯度乘以激活函数的导数
    def propagate_grad(n_layers, activation_type):
        grad = 1.0
        history = [grad]
        for _ in range(n_layers):
            if activation_type == 'sigmoid':
                # Sigmoid导数平均值约0.2（实际训练中）
                grad *= 0.2
            elif activation_type == 'relu':
                # ReLU正半轴导数恒为1（约50%神经元激活）
                grad *= 1.0
            history.append(grad)
        return history
    
    layers = 6
    sig_grad = propagate_grad(layers, 'sigmoid')
    relu_grad = propagate_grad(layers, 'relu')
    
    for l in range(layers + 1):
        s = "→ 输出层" if l == 0 else f"→ 第{l}层"
        print(f"  梯度 {s}: Sigmoid={sig_grad[l]:.4f}, ReLU={relu_grad[l]:.4f}")
    print(f"  → ReLU的梯度畅通无阻，而Sigmoid的梯度在第6层已衰减到最初的{sig_grad[-1]:.6f}")


def demonstrate_dropout():
    """
    演示 Dropout 的效果
    在训练时随机"关闭"一部分神经元，防止过拟合
    """
    print(f"\nAlexNet 关键创新2: Dropout 正则化")
    print("=" * 50)
    
    np.random.seed(42)
    # 模拟一层10个神经元的输出
    activations = np.array([0.8, 0.3, 0.9, 0.2, 0.7, 0.5, 0.1, 0.6, 0.4, 0.95])
    dropout_rate = 0.5  # 50%的神经元被随机丢弃
    
    # 生成dropout掩码
    mask = np.random.binomial(1, 1 - dropout_rate, size=activations.shape)
    dropped = activations * mask
    # 训练时需要对保留下来的神经元进行缩放（inverted dropout）
    scaled = dropped / (1 - dropout_rate)
    
    print(f"  原始激活:      {activations}")
    print(f"  Dropout掩码:   {mask}")
    print(f"  Dropout后:     {dropped}")
    print(f"  缩放恢复后:    {scaled}")
    print(f"  → 每次迭代随机丢弃50%神经元，迫使网络学习冗余表示，防止过拟合")


def alexnet_structure_summary():
    """
    AlexNet 结构总结
    """
    print(f"\nAlexNet 结构概览（输入: 3×227×227）：")
    print("=" * 60)
    
    layers = [
        ("Conv1", "96@11×11, stride=4, ReLU", "96×55×55", "3×3 MaxPool, stride=2 → 96×27×27"),
        ("Conv2", "256@5×5, stride=1, ReLU", "256×27×27", "3×3 MaxPool, stride=2 → 256×13×13"),
        ("Conv3", "384@3×3, stride=1, ReLU", "384×13×13", "—"),
        ("Conv4", "384@3×3, stride=1, ReLU", "384×13×13", "—"),
        ("Conv5", "256@3×3, stride=1, ReLU", "256×13×13", "3×3 MaxPool, stride=2 → 256×6×6"),
        ("FC6", "Flatten→4096, ReLU, Dropout(0.5)", "4096", "—"),
        ("FC7", "4096→4096, ReLU, Dropout(0.5)", "4096", "—"),
        ("FC8", "4096→1000, Softmax", "1000", "—"),
    ]
    
    total_params = 0
    for name, config, output, after in layers:
        print(f"  {name}: {config}")
        print(f"          → {output}  {after}")
    print(f"\n  总参数约 60M，双 GPU 训练，top-5 错误率 15.3%")


compare_activations()
demonstrate_dropout()
alexnet_structure_summary()

大白话 AlexNet的成功秘诀 = 更深更大（8层6000万参数）+ ReLU（训练不卡梯度）+ GPU（两块显卡并行算）+ Dropout（防止死记硬背）+ 数据增强（多角度看图）。五招齐出，一举拉开与传统方法的差距。

什么用（AI关联）：AlexNet是深度学习历史的转折点。它的成功直接推动了GPU厂商（NVIDIA）对深度学习的投入，催生了CuDNN等专用库。AlexNet中引入的ReLU、Dropout、数据增强等技术至今仍是训练深度网络的标准做法。

哪些坑（缺点）：①使用了较大的卷积核（11×11、5×5），参数效率低——后来的VGG证明了小卷积核堆叠更优。②全连接层参数过多（FC6有3770万参数，占总参数一半以上）。③依赖于特定的输入尺寸（227×227），不够灵活。

三、VGGNet：深度与简洁的胜利

是什么（定义）：VGGNet由牛津大学Visual Geometry Group于2014年提出，最经典的是VGG-16和VGG-19。其核心设计哲学极其简洁：全部使用3×3小卷积核（same padding）+ 2×2最大池化（stride 2），通过不断加深网络（16-19层）来提升性能。VGG-16在ImageNet上top-5错误率仅7.3%。

大白话 VGGNet的口号是"简单即美"——所有卷积都用最小号的3×3、所有池化都用2×2，整个网络只有一个设计模式反复堆叠。不耍花样，纯靠加深层数碾压对手。

为什么（原理）：VGGNet用两个3×3卷积替代一个5×5卷积（三个3×3替代一个7×7）——两者有相同大小的感受野，但参数量更少（2×3²=18 < 5²=25），且多了非线性激活（两次ReLU vs 一次ReLU），表达能力更强。这是VGGNet的精髓——"用小核堆出大感受野"。

大白话 两个3×3叠起来能"看到"的范围等于一个5×5，但参数更少、非线性更多。就像两个人各看一个小窗口合作拼出大画面，比一个人看大窗口更聪明高效。

怎么做（实现）：

import numpy as np

# ========================================
# VGG-16 结构模拟 —— 全3×3小卷积核堆叠
# 核心思想: 用两个3×3替代一个5×5，感受野相同但参数更少
# ========================================

def compare_kernel_efficiency():
    """
    对比"两个3×3"与"一个5×5"的参数量和感受野
    """
    print("VGGNet 核心洞察: 小核堆叠 vs 大核")
    print("=" * 55)
    
    # 假设输入和输出通道数相同 = C
    C = 64
    
    # 方案A: 一个5×5卷积，C→C
    params_5x5 = C * C * 5 * 5
    # 感受野: 5×5
    
    # 方案B: 两个3×3卷积堆叠，C→C→C
    params_3x3 = C * C * 3 * 3 + C * C * 3 * 3
    # 感受野: 3 + (3-1) = 5（等效5×5！）
    
    print(f"  输入{C}通道 → 输出{C}通道：")
    print(f"  一个5×5卷积:  {params_5x5:,} 参数, 感受野 5×5, 1次ReLU")
    print(f"  两个3×3卷积:  {params_3x3:,} 参数, 感受野 5×5, 2次ReLU")
    print(f"  节省参数: {(1 - params_3x3/params_5x5)*100:.1f}%")
    
    # 方案C: 三个3×3替代7×7
    params_7x7 = C * C * 7 * 7
    params_3x3x3 = C * C * 3 * 3 * 3
    print(f"\n  一个7×7卷积:  {params_7x7:,} 参数, 感受野 7×7, 1次ReLU")
    print(f"  三个3×3卷积:  {params_3x3x3:,} 参数, 感受野 7×7, 3次ReLU")
    print(f"  节省参数: {(1 - params_3x3x3/params_7x7)*100:.1f}%")


def receptive_field_calc():
    """
    计算感受野：两个3×3堆叠的感受野
    公式: RF_k = RF_{k-1} + (kernel_size - 1) * stride_{k-1}
    """
    print(f"\n感受野递推计算（步长均为1）：")
    rf = 1  # 初始感受野
    for layer, ks in enumerate([3, 3], 1):
        rf = rf + (ks - 1)
        print(f"  第{layer}层3×3卷积后: 感受野 = {rf}×{rf}")
    print(f"  → 两层3×3堆叠后的感受野 = 5×5，与一个5×5相同！")


def vgg16_structure():
    """
    VGG-16 结构总结
    """
    print(f"\nVGG-16 结构（输入: 3×224×224）：")
    print("=" * 60)
    
    config = [
        ("Block 1", "Conv3-64 × 2, MaxPool", "64×224×224 → 64×112×112"),
        ("Block 2", "Conv3-128 × 2, MaxPool", "128×112×112 → 128×56×56"),
        ("Block 3", "Conv3-256 × 3, MaxPool", "256×56×56 → 256×28×28"),
        ("Block 4", "Conv3-512 × 3, MaxPool", "512×28×28 → 512×14×14"),
        ("Block 5", "Conv3-512 × 3, MaxPool", "512×14×14 → 512×7×7"),
        ("FC", "Flatten → FC4096 → FC4096 → FC1000", "25088 → 1000"),
    ]
    
    for block, ops, dims in config:
        print(f"  {block}: {ops}")
        print(f"         {dims}")
    
    print(f"\n  总参数约 138M，全连接层占大部分（约 124M）")
    print(f"  top-5 错误率: 7.3% (VGG-16)")


compare_kernel_efficiency()
receptive_field_calc()
vgg16_structure()

大白话 感受野公式："前一层的感受野加上（核大小-1）乘以之前所有层步长的乘积"。简单情况（步长都是1）：加(核大小-1)就行。所以两个3×3：1+2+2=5。

什么用（AI关联）：VGGNet的预训练模型（尤其是VGG-16）至今仍广泛用作特征提取器——去掉最后的全连接层，用卷积部分提取图像特征。VGG的简洁结构也使其成为教学和研究中的标准baseline。其"重复使用相同尺寸卷积核"的设计哲学影响了后来的ResNet和DenseNet。

哪些坑（缺点）：①参数量巨大（138M），其中全连接层占了绝大部分（~124M），内存和计算开销大。②相比后来的ResNet和EfficientNet，训练速度慢且精度不是最高。③仅使用3×3卷积，缺乏多尺度特征提取能力（后来的Inception弥补了这一点）。

概念关系图谱

重点答疑

Q1: 为什么LeNet使用5×5卷积，而VGG用3×3？

这是技术演进的过程。LeNet时代（1998）没有足够的算力和数据来支撑更深更宽的网络，5×5卷积核一次能覆盖较大的感受野，在当时是合理的选择。到VGG时代（2014），GPU算力大幅提升，研究者发现用两个3×3堆叠可以达到5×5的感受野但参数更少（18 vs 25）、非线性更强（两次ReLU vs 一次）。这是一种"用深度换参数效率"的智慧。现代CNN大多使用3×3或更小的卷积核。

Q2: AlexNet为什么需要双GPU训练？

2012年的GPU（GTX 580）只有3GB显存，放不下整个AlexNet模型（约240MB的参数+中间激活）。AlexNet的解决方案是将网络分成两半：一半的特征图放在GPU1，一半在GPU2，仅在特定的层（Conv2、Conv4、Conv5、FC6-8）进行跨GPU通信。这种"模型并行"的思想至今仍用于超大模型的训练。今天我们有了更大的GPU显存和更高效的分布式训练框架，单卡就能训练AlexNet。

Q3: 既然VGG证明了"越深越好"，为什么后来又出现了ResNet？

VGG虽然深（16-19层），但再加深（如VGG-30）会遇到严重的梯度消失——即使使用ReLU和批归一化，20层以上的VGG也很难训练。ResNet通过残差连接（跳过连接）解决了这个问题，使得网络可以加深到100+层而不会梯度消失。简言之：VGG证明了"深度是好的"，ResNet解决了"怎么做到更深"。

章节单词汇总