🕸️ 神经网络与深度学习

🧠 一、从感知机到神经网络

1.1 生物神经元：一切灵感的起点

1943 年，神经生理学家 Warren McCulloch 和数学家 Walter Pitts 提出了第一个人工神经元模型 McCulloch-Pitts 神经元，首次用数学方式描述了生物神经元的工作原理 [1]。

1.2 感知机：第一个可学习的模型 (1958)

1958 年，Frank Rosenblatt 在康奈尔航空实验室发明了感知机 (Perceptron)——第一个可以通过数据自动学习权重的模型 [1]。它使用了一个简单的学习规则来调整权重：

1.3 多层感知机 (MLP)：突破 XOR

解决方案很简单：增加隐藏层。一个只有 2 个隐藏神经元的多层感知机就能完美解决 XOR 问题。

1.4 反向传播算法：让深度学习成为可能 (1986)

多层网络的关键问题是：如何高效地计算每个权重的梯度？ 1986 年，Rumelhart、Hinton 和 Williams 发表了里程碑论文，将反向传播 (Backpropagation)算法普及开来 [2]。

⚙️ 二、深度学习的关键组件

2.1 激活函数：神经网络的"非线性灵魂"

如果没有激活函数，无论网络多深，都等价于一个线性变换。激活函数为网络引入非线性，使其能够拟合任意复杂的函数。

2.2 损失函数：衡量预测的好坏

2.3 优化器：如何高效地找到最优解

优化器决定了模型参数如何根据梯度进行更新。从最基本的 SGD 到如今广泛使用的 AdamW，优化器的发展经历了多次重要演进。

2.4 正则化：防止过拟合的艺术

2.5 梯度消失与梯度爆炸

这是深度网络训练中最经典的问题之一，尤其在 RNN 中尤为严重。

🖼️ 三、CNN 卷积神经网络

3.1 发展历程

3.2 核心操作详解

3.3 案例详解：AlexNet 如何改变历史

3.4 应用场景

🔁 四、RNN 循环神经网络

4.1 处理序列数据的动机

自然界充满了序列数据：文本是一串单词、语音是一串声学信号、视频是一串帧、股票是一串价格……前馈神经网络（MLP、CNN）假设输入之间相互独立，无法捕捉序列中的时序依赖关系。

RNN 的核心创新：引入隐藏状态 (Hidden State) hₜ 作为"记忆"，将过去的信息传递到未来。

4.2 基本 RNN 的致命缺陷

4.3 LSTM：长短期记忆网络 (1997)

1997 年，Sepp Hochreiter 和 Jürgen Schmidhuber 提出了 LSTM (Long Short-Term Memory) [5]，通过精巧的门控机制 (Gating Mechanism)解决了梯度消失问题。

4.4 GRU：更简洁的 LSTM (2014)

2014 年，Kyunghyun Cho 等人提出了 GRU (Gated Recurrent Unit)，将 LSTM 的遗忘门和输入门合并为一个更新门 (Update Gate)，参数量减少约 25%，训练更快，效果相当。

4.5 RNN 的典型应用

👁️ 五、Attention 注意力机制

5.1 为什么需要 Attention？

Seq2Seq 模型使用编码器-解码器架构：编码器将整个输入序列压缩为一个固定长度的向量（上下文向量），解码器根据这个向量生成输出。

5.2 Seq2Seq + Attention (2015 Bahdanau)

2015 年，Dzmitry Bahdanau 等人提出了突破性的Additive Attention [6]。核心思想：解码器在每个时间步动态关注输入序列的不同部分，而非依赖一个固定的上下文向量。

5.3 Self-Attention：序列内部的自注意力

2017 年，Transformer 论文 [7] 将 Attention 的思想推向了一个新的高度：Self-Attention 不再局限于编码器和解码器之间，而是让序列中的每个元素都"注意"序列中的其他元素。

5.4 从 Attention 到 Transformer 的跃迁

这个架构后来成为了 GPT、BERT、T5、PaLM 等所有大语言模型的基石——我们将在 PAGE 03: Transformer 架构 中深入拆解。

🚀 六、深度学习的突破性应用

💻 七、Python 代码示例

用 PyTorch 构建多层感知机 (MLP)

以下代码展示如何用 PyTorch 从零构建一个完整的 MLP，包括数据准备、模型定义、训练循环和评估。

Python · PyTorch MLP
"""
PyTorch 多层感知机 (MLP) 完整示例
任务：MNIST 手写数字分类 (10 分类)
结构：784 → 256 → 128 → 10
"""

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms


# ─── 1. 超参数设置 ───
BATCH_SIZE = 64          # 每个 mini-batch 的样本数
LEARNING_RATE = 0.001     # 学习率 (Adam 优化器的默认值)
EPOCHS = 10               # 训练轮次
HIDDEN_DIMS = [256, 128]  # 隐藏层维度列表
DROPOUT_RATE = 0.2        # Dropout 概率
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")


# ─── 2. 数据准备 ───
# 定义数据变换：将图像展平为向量并归一化
transform = transforms.Compose([
    transforms.ToTensor(),                      # PIL Image → Tensor (0~1)
    transforms.Normalize((0.1307,), (0.3081,)),     # 标准化 (MNIST 均值/标准差)
    transforms.Lambda(lambda x: x.view(-1)),          # 展平为 784 维向量
])

# 下载 MNIST 数据集
train_dataset = datasets.MNIST(
    root="./data", train=True, download=True, transform=transform
)
test_dataset = datasets.MNIST(
    root="./data", train=False, download=True, transform=transform
)

# 创建数据加载器 (自动 shuffle 和 batching)
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)

print(f"训练集大小: {len(train_dataset)} 样本")
print(f"测试集大小: {len(test_dataset)} 样本")
print(f"使用设备: {DEVICE")


# ─── 3. 定义 MLP 模型 ───
class MLP(nn.Module):
    """
    多层感知机 (Multi-Layer Perceptron)
    结构: 输入层(784) → 隐藏层1(256) → ReLU → Dropout →
          隐藏层2(128) → ReLU → Dropout → 输出层(10)
    """

    def __init__(self, input_dim, hidden_dims, output_dim, dropout_rate):
        super().__init__()
        layers = []

        # 构建隐藏层
        prev_dim = input_dim
        for hidden_dim in hidden_dims:
            layers.extend([
                nn.Linear(prev_dim, hidden_dim),  # 全连接层
                nn.ReLU(),                       # ReLU 激活函数
                nn.Dropout(dropout_rate),          # Dropout 正则化
            ])
            prev_dim = hidden_dim

        # 输出层 (不需要激活函数，CrossEntropyLoss 内含 Softmax)
        layers.append(nn.Linear(prev_dim, output_dim))

        self.network = nn.Sequential(*layers)

    def forward(self, x):
        """前向传播"""
        return self.network(x)


# 实例化模型
model = MLP(
    input_dim=28 * 28,              # MNIST 图像 28x28 = 784
    hidden_dims=HIDDEN_DIMS,      # [256, 128]
    output_dim=10,                 # 10 个数字类别
    dropout_rate=DROPOUT_RATE,
).to(DEVICE)

print(f"\n模型结构:\n{model}\n")


# ─── 4. 定义损失函数和优化器 ───
criterion = nn.CrossEntropyLoss()             # 交叉熵损失 (含 Softmax)
optimizer = optim.AdamW(                       # AdamW 优化器
    model.parameters(),
    lr=LEARNING_RATE,
    weight_decay=1e-4,                     # L2 正则化 (权重衰减)
)


# ─── 5. 训练循环 ───
def train(model, loader, criterion, optimizer):
    """训练一个 epoch"""
    model.train()           # 设置为训练模式 (启用 Dropout)
    total_loss = 0
    correct = 0
    total = 0

    for batch_idx, (data, target) in enumerate(loader):
        data, target = data.to(DEVICE), target.to(DEVICE)

        # 前向传播
        output = model(data)
        loss = criterion(output, target)

        # 反向传播 + 参数更新
        optimizer.zero_grad()   # 清除上一步的梯度
        loss.backward()        # 反向传播计算梯度
        optimizer.step()        # 根据梯度更新参数

        # 统计
        total_loss += loss.item()
        _, predicted = output.max(1)
        total += target.size(0)
        correct += predicted.eq(target).sum().item()

    avg_loss = total_loss / len(loader)
    accuracy = 100.0 * correct / total
    return avg_loss, accuracy


# ─── 6. 评估函数 ───
def evaluate(model, loader, criterion):
    """评估模型性能"""
    model.eval()            # 设置为评估模式 (关闭 Dropout)
    total_loss = 0
    correct = 0
    total = 0

    with torch.no_grad():   # 不计算梯度 (节省内存 + 加速)
        for data, target in loader:
            data, target = data.to(DEVICE), target.to(DEVICE)
            output = model(data)
            loss = criterion(output, target)

            total_loss += loss.item()
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()

    avg_loss = total_loss / len(loader)
    accuracy = 100.0 * correct / total
    return avg_loss, accuracy


# ─── 7. 开始训练 ───
print("="*50)
print("开始训练 MLP 模型...")
print("="*50))

for epoch in range(1, EPOCHS + 1):
    train_loss, train_acc = train(model, train_loader, criterion, optimizer)
    test_loss, test_acc = evaluate(model, test_loader, criterion)

    print(
        f"Epoch [{epoch}/{EPOCHS}] "
        f"训练 - Loss: {train_loss:.4f, Acc: {train_acc:.2f% | "
        f"测试 - Loss: {test_loss:.4f, Acc: {test_acc:.2f%"
    )

print("="*50)
print(f"训练完成! 最终测试准确率: {test_acc:.2f%")
print("="*50))

📚 参考文献

1. [1] McCulloch, W. S. & Pitts, W. (1943). "A logical calculus of the ideas immanent in nervous activity." Bulletin of Mathematical Biophysics, 5(4), 115-133.
2. [2] Rumelhart, D. E., Hinton, G. E. & Williams, R. J. (1986). "Learning representations by back-propagating errors." Nature, 323, 533-536.
3. [3] LeCun, Y., Bottou, L., Bengio, Y. & Haffner, P. (1998). "Gradient-based learning applied to document recognition." Proceedings of the IEEE, 86(11), 2278-2324.
4. [4] Krizhevsky, A., Sutskever, I. & Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks." NeurIPS 2012. (aka "AlexNet")
5. [5] Hochreiter, S. & Schmidhuber, J. (1997). "Long Short-Term Memory." Neural Computation, 9(8), 1735-1780.
6. [6] Bahdanau, D., Cho, K. & Bengio, Y. (2015). "Neural Machine Translation by Jointly Learning to Align and Translate." ICLR 2015.
7. [7] Vaswani, A. et al. (2017). "Attention Is All You Need." NeurIPS 2017.
8. [8] Goodfellow, I., Bengio, Y. & Courville, A. (2016). Deep Learning. MIT Press. deeplearningbook.org
9. [9] LeCun, Y., Bengio, Y. & Hinton, G. (2015). "Deep learning." Nature, 521, 436-444.
10. [10] Kingma, D. P. & Ba, J. (2015). "Adam: A Method for Stochastic Optimization." ICLR 2015.
11. [11] He, K. et al. (2016). "Deep Residual Learning for Image Recognition." CVPR 2016. (ResNet)
12. [12] Loshchilov, I. & Hutter, F. (2019). "Decoupled Weight Decay Regularization." ICLR 2019. (AdamW)