当前位置：首页 > article >正文

【漫话机器学习系列】012.深度学习（Deep Learning）基础

article 2024/12/23 23:05:45

深度学习基础概述

深度学习（Deep Learning）是一种基于人工神经网络的大规模机器学习方法，在图像识别、语音处理、自然语言理解等领域具有广泛的应用。深度学习模型的构建包括数据准备、损失函数设计、优化算法选择、网络架构搭建、测试数据验证以及结果评价等环节。以下将从这些方面系统介绍深度学习的核心组成部分。

1. 数据

数据是深度学习的基础，模型的表现很大程度上取决于数据的质量与数量。

深度学习需要大量高质量数据作为训练基础。常见的数据形式包括：

图像数据（如 CIFAR-10, ImageNet）
文本数据（如 IMDB 影评数据集）
时间序列数据（如股票价格、天气数据）

数据集划分

训练集（Training Set）：用于训练模型，提供样本和目标标签。
验证集（Validation Set）：用于调整超参数，监控模型在训练过程中的表现，避免过拟合。
测试集（Test Set）：在模型完全训练后，用于评估最终性能。

数据预处理

标准化：将数据转化为均值为0，方差为1的分布。
归一化：将数据缩放到[0,1]或[-1,1]之间。
分割数据集：将数据划分为训练集、验证集和测试集（如 70%:15%:15%）。
数据增强：对于图像或音频等数据，通过旋转、翻转、裁剪等方法增加数据量，提高模型的泛化能力。

2. 损失函数（Loss Function）

损失函数用于衡量模型的预测值与真实值之间的差距，是优化模型的重要依据。根据任务不同，可以选择不同的损失函数。

分类任务

交叉熵损失（Cross-Entropy Loss）
用于多分类任务：
$L = - \frac{1}{N} \sum_{i=1}^{N} \sum_{k=1}^{K} y_{i,k} \log \hat{y}_{i,k}$

N：样本数量
C：类别数
$y_{i,k}$ ：真实标签（one-hot 编码）
$\hat{y}_{i,k}$ ：模型预测的概率分布（通过 softmax 输出）
交叉熵损失惩罚模型在目标类别上预测概率较低的情况，目标是最小化损失值。
二分类交叉熵（Binary Cross-Entropy, BCE）
$L = - \frac{1}{N} \sum_{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]$
焦点损失（Focal Loss）
适用于类别极不平衡场景。

回归任务

均方误差（Mean Squared Error, MSE）
$L = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2$
平均绝对误差（Mean Absolute Error, MAE）
$L = \frac{1}{N} \sum_{i=1}^{N} |y_i - \hat{y}_i|$
Huber 损失
对异常值鲁棒：
$L = \begin{cases} \frac{1}{2}(y - \hat{y})^2, & \text{if } |y - \hat{y}| \leq \delta \\ \delta |y - \hat{y}| - \frac{1}{2}\delta^2, & \text{otherwise} \end{cases}$

多任务学习

对于多个任务，可以使用加权损失函数：

$L = \sum_{k=1}^{K} \alpha_k L_k$

其中， $\alpha_k$ 是任务 k 的权重。

3. 优化算法（Optimization Algorithms）

优化算法用于调整模型权重以最小化损失函数。

基础优化算法

随机梯度下降（SGD） 每次更新仅计算一个样本的梯度：
$\theta_{t+1} = \theta_t - \eta \cdot g_t$
动量法（Momentum） 在 SGD 的基础上引入动量项，缓解梯度震荡：
$v_{t+1} = \gamma v_t + \eta \cdot g_t, \quad \theta_{t+1} = \theta_t - v_{t+1}$

改进算法

Adam
Adam 是一种自适应优化算法，结合了动量法和 RMSProp 的优点。公式如下：
参数更新：
$\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \cdot \hat{m}_t$
梯度一阶矩估计：
$m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t$

$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}$
梯度二阶矩估计：
$v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2$

$\hat{v}_t = \frac{v_t}{1 - \beta_2^t}$
$\theta_t$ ：参数

$\eta$ ：学习率

$g_t$ ：梯度

$\beta_1$ , $\beta_2$ ：指数衰减率（通常为 0.9 和 0.999）

Adam 优化器在实践中表现稳定，适用于大多数深度学习任务。
RMSProp
动态调整学习率，抑制梯度爆炸：
$v_t = \beta v_{t-1} + (1 - \beta) g_t^2$ , $\quad \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{v_t + \epsilon}} g_t$
AdaGrad
适用于稀疏数据，考虑梯度累积历史。
AMSGrad
改进 Adam 的理论收敛性。

二阶优化算法

牛顿法
利用 Hessian 矩阵（损失函数的二阶导数）加速收敛：

$\theta_{t+1} = \theta_t - H^{-1} \nabla L$

4. 网络架构（Network Architecture）

深度学习网络由多个层组成，每层执行特定的计算任务。

常见网络组件

全连接层（Fully Connected Layer）
每个神经元与上一层所有神经元相连，适合结构化数据。
卷积层（Convolutional Layer）
用于提取图像特征，核心是卷积核。
池化层（Pooling Layer）
用于降维：
- 最大池化（Max Pooling）：提取局部最大值。
- 平均池化（Average Pooling）：计算局部平均值。
Dropout 层
随机丢弃部分神经元，防止过拟合。

常见网络类型

全连接网络（MLP）
- 应用：结构化数据分类或回归。
卷积神经网络（CNN）
- 应用：图像分类、目标检测。
循环神经网络（RNN）及其变种
- 长短期记忆网络（LSTM）
- 门控循环单元（GRU）
- 应用：时间序列分析、自然语言处理。
生成对抗网络（GAN）
- 包含生成器和判别器。
- 应用：图像生成。
Transformer
- 基于自注意力机制，适用于自然语言处理。
- 变种包括 BERT、GPT、ViT（视觉 Transformer）。

5. 测试数据

测试数据用于评估模型的泛化性能，不能在训练过程中被模型“看到”。
通常的流程：

训练阶段：模型基于训练数据优化参数。
验证阶段：通过验证集调整超参数。
测试阶段：使用测试集评估模型最终性能。

6. 评价指标

评价指标用来衡量模型的预测质量。

分类任务的评价指标

准确率（Accuracy）：
精确率（Precision）：
召回率（Recall）：
F1 分数：
$F1 = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}$

回归任务的评价指标

均方误差（MSE）：
$\text{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2$
平均绝对误差（MAE）：
$\text{MAE} = \frac{1}{N} \sum_{i=1}^{N} |y_i - \hat{y}_i|$

生成任务的评价指标：Inception Score、BLEU 分数。

7. 深度学习完整示例：基于卷积神经网络的 MNIST 分类

以下代码实现了一个简单的卷积神经网络（CNN）进行 MNIST 数据集的分类任务。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from sklearn.metrics import accuracy_score

# 数据准备
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# 网络定义
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = self.dropout(self.relu(self.fc1(x)))
        x = self.fc2(x)
        return x

model = CNN()

# 定义损失函数与优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(10):
    model.train()
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch + 1}, Loss: {loss.item()}")

# 测试模型
model.eval()
all_preds, all_labels = [], []
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        preds = torch.argmax(outputs, axis=1)
        all_preds.extend(preds.numpy())
        all_labels.extend(labels.numpy())

accuracy = accuracy_score(all_labels, all_preds)
print(f"Test Accuracy: {accuracy:.2f}")