Day03 深度学习基础笔记

神经网络的结构

多层感知机：输入层+隐藏层+输出层

最常用的优化算法：

• 随机梯度下降算法

• Adam 算法

欠拟合（underfitting）：模型不能降低训练误差，训练误差和验证误差都很严重，而且它们之间仅有一点差距。这可能意味着模型过于简单（即表达能力不足）， 无法捕获试图学习的模式。

过拟合（overfitting）：训练误差明显低于验证误差时。注意，过拟合并不总是一件坏事。 特别是在深度学习领域。

通常更关心验证误差，而不是训练误差和验证误差之间的差距。

训练数据集中的样本越少，就越有可能过拟合。

缓解过拟合的方法：权重衰退、暂退法

案例：神经网络代码

使用 MNIST 数字识别数据集

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

# 定义应用于数据的转换
transform = transforms.Compose([transforms.ToTensor()])

# 加载 MNIST 数据集
# 使用torchvision库中的datasets模块来加载MNIST数据集
# root参数指定了数据集保存的位置
# train=True表示加载训练集，train=False表示加载测试集
# download=True表示如果本地没有数据集，则自动从网上下载
# transform参数指定了应用于数据集的转换流程
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
# 设置超参数
# batch_size定义了每个批次的数据量
batch_size = 64
# input_size定义了输入数据的维度，由于MNIST图像是28x28像素，所以总的输入维度是28*28
input_size = 28 * 28
# hidden_size定义了神经网络中隐藏层的维度
hidden_size = 128
# output_size定义了输出数据的维度，对于MNIST数据集，由于有10个类别，所以输出维度是10
output_size = 10
# learning_rate定义了学习率，这是优化算法在更新权重时使用的步长
learning_rate = 0.001
# num_epochs定义了训练的轮数，即整个数据集被遍历的次数
num_epochs = 10
# 创建数据加载器
trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False)


# 定义 MLP 模型
class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x


# 初始化模型
model = MLP(input_size, hidden_size, output_size)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# 训练循环
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(trainloader):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {running_loss / len(trainloader):.4f}')

# 测试
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'测试集的准确性: {(100 * correct / total):.2f}%')

Epoch [1/10], Loss: 0.3497
Epoch [2/10], Loss: 0.1622
Epoch [3/10], Loss: 0.1120
Epoch [4/10], Loss: 0.0851
Epoch [5/10], Loss: 0.0669
Epoch [6/10], Loss: 0.0539
Epoch [7/10], Loss: 0.0435
Epoch [8/10], Loss: 0.0362
Epoch [9/10], Loss: 0.0299
Epoch [10/10], Loss: 0.0242
测试集的准确性: 97.75%