2006年深度学习革命：从Hinton的突破到现代神经网络基础

1次阅读

没有评论

共计 2588 个字符，预计需要花费 7 分钟才能阅读完成。

在 2006 年之前，机器学习领域主要面临两大核心挑战：维度灾难和特征工程依赖。传统方法如支持向量机 (SVM) 虽然在理论上很优美，但在处理高维数据时表现受限。当时的特征提取主要依赖人工设计，这不仅耗时耗力，而且严重依赖领域专家的知识。

维度灾难：当数据维度增加时，所需的训练样本数量呈指数级增长，导致模型难以学习有效特征
特征工程瓶颈：人工设计的特征往往只能捕捉到数据的浅层模式，难以发现复杂的非线性关系

2006 年，Geoffrey Hinton 团队在《Science》发表里程碑论文，提出了两个关键创新：

受限玻尔兹曼机(RBM)：一种两层结构的概率图模型，包含可见层和隐藏层
深度信念网络(DBN)：通过堆叠多个 RBM 构建的深度网络，采用逐层贪婪训练策略

RBM 是一种基于能量的模型，其训练目标是最小化能量函数。关键创新在于：

使用对比散度 (Contrastive Divergence) 算法加速训练
通过吉布斯采样 (Gibbs Sampling) 进行近似推断
层间采用全连接但层内无连接的 ” 受限 ” 结构

数学上，RBM 的能量函数定义为：

E(v,h) = -aᵀv - bᵀh - vᵀWh

其中 v 是可见层，h 是隐藏层，W 是连接权重，a 和 b 是偏置项。

DBN 的训练采用了一种称为 ” 贪婪逐层训练 ” 的策略：

首先训练最底层的 RBM
固定底层参数，将隐藏层激活作为下一层的输入
重复这个过程直到所有层都训练完毕
最后使用反向传播进行微调

这种方法有效解决了深度网络梯度消失的问题。

下面是用 PyTorch 实现的一个简单 DBN，用于 MNIST 分类任务：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

# 定义 RBM 层
class RBM(nn.Module):
    def __init__(self, visible_dim, hidden_dim):
        super(RBM, self).__init__()
        self.W = nn.Parameter(torch.randn(hidden_dim, visible_dim) * 0.1)
        self.v_bias = nn.Parameter(torch.zeros(visible_dim))
        self.h_bias = nn.Parameter(torch.zeros(hidden_dim))

    def forward(self, v):
        # 使用对比散度训练
        h_prob = torch.sigmoid(F.linear(v, self.W, self.h_bias))
        h_sample = torch.bernoulli(h_prob)
        v_recon_prob = torch.sigmoid(F.linear(h_sample, self.W.t(), self.v_bias))
        return v_recon_prob, h_prob

# 构建 3 层 DBN
class DBN(nn.Module):
    def __init__(self):
        super(DBN, self).__init__()
        self.rbm1 = RBM(784, 500)
        self.rbm2 = RBM(500, 200)
        self.rbm3 = RBM(200, 50)
        self.classifier = nn.Linear(50, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        # 逐层训练 RBMs
        _, h1 = self.rbm1(x)
        _, h2 = self.rbm2(h1.detach())
        _, h3 = self.rbm3(h2.detach())
        out = self.classifier(h3)
        return out

# 训练循环
dbn = DBN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(dbn.parameters(), lr=0.01, momentum=0.9)

for epoch in range(10):
    for data, target in train_loader:
        optimizer.zero_grad()
        output = dbn(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

我们在 MNIST 数据集上进行了对比实验：