基于Fashion‐MNIST数据集和MNIST数据集的多层感知机（MLP）两个案例代码实现

这个函数可导2024-04-05 9:30

文章目录

前言

这篇文章是本人在学习 《动手学深度学习》这本书的 4.2. 多层感知机的从零开始实现和4.3. 多层感知机的简洁实现这两节的记录。以上两节的多层感知机模型代码实现是基于Fashion‐MNIST数据集的，对此在文章的最后，添加了一个案例使用多层感知机模型实现MNIST数据集分类。

多层感知机的从零开始实现

1、导入所需要的库

python 复制代码 
import torch
from torch import nn
from d2l import torch as d2l

2、读取Fashion‐MNIST数据集

python 复制代码 
# 读取Fashion‐MNIST数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

3、初始化模型参数

Fashion‐MNIST中的每个图像由28×28=784个灰度像素值组成。所有图像共分为10个类别。

忽略像素之间的空间结构，我们可以将每个图像 视为具有784个输入特征 和10个类 的简单分类数据集 。

我们将实现一个具有单隐藏层的多层感知机 ，它包含256个隐藏单元 。

对于每一层我们都要记录一个权重矩阵和一个偏置向量。

python 复制代码 
num_inputs, num_outputs, num_hiddens = 784, 10, 256
W1 = nn.Parameter(torch.randn(
num_inputs, num_hiddens, requires_grad=True) * 0.01)
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
W2 = nn.Parameter(torch.randn(
num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))
params = [W1, b1, W2, b2]

4、选择激活函数

为了确保我们对模型的细节了如指掌，我们将实现ReLU激活函数，而不是直接调用内置的relu函数。

python 复制代码 
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

5、定义模型

因为我们忽略了空间结构，所以我们使用reshape将每个二维图像转换为一个长度为num_inputs的向量。

python 复制代码 
def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X@W1 + b1) # 这里"@"代表矩阵乘法
    return (H@W2 + b2)

6、定义损失函数

在这里我们直接使用高级API中的内置函数来计

算softmax和交叉熵损失。

python 复制代码 
loss = nn.CrossEntropyLoss()

7、训练

python 复制代码 
num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

8、模型评估

为了对学习到的模型进行评估，我们将在一些测试数据上应用这个模型。

python 复制代码 
d2l.predict_ch3(net, test_iter)

9、图像显示

python 复制代码 
# 图像显示
d2l.plt.show()

10、效果展示


完整代码

python 复制代码 
import torch
from torch import nn
from d2l import torch as d2l

# 读取Fashion‐MNIST数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 初始化模型参数
num_inputs, num_outputs, num_hiddens = 784, 10, 256
W1 = nn.Parameter(torch.randn(
num_inputs, num_hiddens, requires_grad=True) * 0.01)
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
W2 = nn.Parameter(torch.randn(
num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))
params = [W1, b1, W2, b2]

# 激活函数
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

# 定义模型
def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X@W1 + b1) # 这里"@"代表矩阵乘法
    return (H@W2 + b2)

# 损失函数
loss = nn.CrossEntropyLoss()

# 训练
num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

# 模型评估
d2l.predict_ch3(net, test_iter)

# 图像显示
d2l.plt.show()

多层感知机的简洁实现

Fashion‐MNIST数据集介绍

Fashion‐MNIST 是一个服装分类数据集，由10个类别 的图像组成，每个类别由训练数据集（traindataset）中的6000张图像和测试数据集（testdataset）中的1000张图像组成。

因此，训练集 和测试集 分别包含60000 和10000 张图像。测试数据集不会用于训练，只用于评估模型性能。

每个输入图像的高度和宽度均为28像素 。数据集由灰度图像组成，其通道数为1。

1、导入所需要的库

python 复制代码 
import torch
from torch import nn
from d2l import torch as d2l

2、读取Fashion‐MNIST数据集

python 复制代码 
# 读取Fashion‐MNIST数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

3、定义模型

添加了2个全连接层。第一层是隐藏层，它包含256个隐藏单元，并使用了ReLU激活函数。第二层是输出层。

python 复制代码 
num_imputs = 784 # 输入特征个数
num_outputs = 10 # 输出类别个数
num_hiddens = 256 # 隐藏层的大小，即隐藏单元的个数，256个

"""
定义神经网络模型
nn.Flatten()即降维打击函数，将图片的多维度数据降维为1维
nn.Linear(num_imputs, num_hiddens)定义从输入层到隐藏层的线性模型
nn.ReLU()即激活函数，去除样本数据中的所有负数值
nn.Linear(num_hiddens, num_outputs)定义从隐藏层到输出层的线性模型
"""
net = nn.Sequential(nn.Flatten(),
                   nn.Linear(num_imputs, num_hiddens),
                   nn.ReLU(),
                   nn.Linear(num_hiddens,num_outputs))

4、初始化权重参数

python 复制代码 
#参数权重初始化函数，以正态分布初始化神经网络的参数
def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)

5、定义损失函数

python 复制代码 
# 定义内置的交叉熵损失函数
loss = nn.CrossEntropyLoss()

6、定义优化算法

python 复制代码 
lr = 0.1

# 使用小批量梯度下降算法
trainer = torch.optim.SGD(net.parameters(), lr=lr)

7、训练

python 复制代码 
num_epochs = 10

# 训练多层感知机模型
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

8、模型评估

python 复制代码 
# 模型评估，在一些测试数据上应用这个模型
d2l.predict_ch3(net, test_iter)

9、图像显示

python 复制代码 
# 图像显示
d2l.plt.show()

10、效果展示


完整代码

python 复制代码 
import torch
from torch import nn
from d2l import torch as d2l

# 读取Fashion‐MNIST数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

num_imputs = 784 # 输入特征个数
num_outputs = 10 # 输出类别个数
num_hiddens = 256 # 隐藏层的大小，即隐藏单元的个数，256个

"""
定义神经网络模型
nn.Flatten()即降维打击函数，将图片的多维度数据降维为1维
nn.Linear(num_imputs, num_hiddens)定义从输入层到隐藏层的线性模型
nn.ReLU()即激活函数，去除样本数据中的所有负数值
nn.Linear(num_hiddens, num_outputs)定义从隐藏层到输出层的线性模型
"""
net = nn.Sequential(nn.Flatten(),
                   nn.Linear(num_imputs, num_hiddens),
                   nn.ReLU(),
                   nn.Linear(num_hiddens,num_outputs))

#参数权重初始化函数，以正态分布初始化神经网络的参数
def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)

# 定义内置的交叉熵损失函数
loss = nn.CrossEntropyLoss()

lr = 0.1

# 使用小批量梯度下降算法
trainer = torch.optim.SGD(net.parameters(), lr=lr)

num_epochs = 10

# 训练多层感知机模型
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

# 模型评估，在一些测试数据上应用这个模型
d2l.predict_ch3(net, test_iter)

# 图像显示
d2l.plt.show()

多层感知机实现MNIST数据集分类

MNIST数据集介绍

MNIST数据集 共有70000张图像，其中训练集60000张 ，测试集10000张 。所有图像都是28×28的灰度图像 ，每张图像包含一个手写数字（0 ~ 9）。

1、导入所需要的库

python 复制代码 
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import matplotlib.pyplot as plt

2、加载MNIST数据集

python 复制代码 
# 加载MNIST数据集
train_dataset = datasets.MNIST(root='./dataset', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='./dataset', train=False, transform=transforms.ToTensor(), download=True)

参数说明如下：

  • root ='./dataset': 指定数据集的存储路径。在这里，数据集将被下载到当前目录下的dataset文件夹中。
  • train=True: 表明我们正在获取训练数据集。如果设置为False，则会获取测试数据集。
  • transform =transforms.ToTensor(): 这个参数定义了对数据进行的预处理操作 。在这个例子中，我们使用transforms.ToTensor()将PIL图像或NumPy数组转换为PyTorch张量。这是因为PyTorch模型需要输入的是张量形式的数据。
  • download =True: 这个参数指示是否从互联网下载数据集。当设置为True时，如果本地没有数据集，那么程序会自动从网上下载并将其保存到指定的路径。

3、定义MLP模型

python 复制代码 
# 定义MLP模型
class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

参数说明如下：
input_size ：输入层的大小
hidden_size ：隐藏层的大小
num_classes：输出层的大小

def init (self, input_size, hidden_size, num_classes): 这是MLP类的初始化方法，用于设置模型的参数 。

def forward (self, x): 这是MLP类的前向传播方法。

在这个例子中，MLP模型有两个全连接层。在初始化函数_init_()中，我们定义了两个全连接层 self.fc1和self.fc2，一个ReLU激活函数 self.relu。

在前向传播函数forward ()中，将输入x 传递给第一个全连接层（fc1 ），然后通过ReLU激活函数 ，再传递给第二个全连接层（fc2 ），最后得到输出out。

这段代码定义了一个简单的两层全连接神经网络，其中包含一个隐藏层（fc1）和一个输出层（fc2），以及一个ReLU激活函数。

4、设置超参数

python 复制代码 
# 设置超参数
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

参数说明如下：
input_size ：输入图像的大小（28x28=784）
hidden_size ：隐藏层的大小（隐藏层中神经元的数量）
num_classes ：输出的类别数（这里是10个数字）
num_epochs ：训练的轮数
batch_size ：每批训练样本的数量
learning_rate：学习率

5、准备数据加载器

python 复制代码 
# 准备数据加载器，用于将数据分成小批次进行训练和测试
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

参数说明如下：

  • dataset=train_dataset：指定要加载的数据集。
  • batch_size=batch_size：指定每批加载的数据量。
  • shuffle=True：指定是否在每个epoch开始时打乱数据。当设置为True时，数据在每个epoch开始时都会被打乱。
  • 在test_loader的数据加载器中，shuffle参数被设置为False，因为在测试阶段，我们通常不需要打乱数据。

6、实例化模型

python 复制代码 
model = MLP(input_size, hidden_size, num_classes)

7、定义损失函数和优化器

python 复制代码 
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

8、训练

python 复制代码 
# 训练模型
total_step = len(train_loader)# 计算训练数据加载器的长度，也就是总的训练步数。每一步对应于一个批次的训练数据。
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
    	# 将图像数据重塑为一个二维的张量，其中每一行代表一个扁平化的图像。
        images = images.reshape(-1, 28 * 28)

        # 前向传播和计算损失
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
		
		# 每100步打印一次当前的损失值
        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{total_step}], Loss: {loss.item()}')

这段代码实现了在每个训练周期中，进行前向传播、计算损失、反向传播和参数更新等步骤。

9、模型评估

python 复制代码 
# 在测试集上测试模型
model.eval() # 将模型设置为评估模式
with torch.no_grad():
    correct = 0 # 初始化正确预测的数量
    total = 0 # 初始化总预测的数量
    for images, labels in test_loader:
        images = images.reshape(-1, 28 * 28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0) # 累加总预测的数
        correct += (predicted == labels).sum().item() # 累加正确预测的数量

    print(f'该模型在10000张测试图像上的准确性: {100 * correct / total}%')

这段代码实现了在测试集上测试模型的过程，包括前向传播、计算预测结果和统计准确率等步骤。

  • _, predicted = torch.max(outputs.data, 1)代码解释：
    在Python中，下划线 _ 通常用作临时或不重要的变量的名称。
    torch.max 函数返回两个值：一个是最大值，另一个是最大值的索引。由于我们只关心预测的类别（即最大值的索引），所以我们使用 _ 来忽略最大值，然后将最大值的索引赋值给 predicted。
  • 举一个简单的例子:
python 复制代码 
import torch
# 假设我们有一个模型的输出outputs，它是一个包含三个元素的tensor，每个元素都是一个概率分布
outputs = torch.tensor([[0.1, 0.6, 0.3],
                        [0.3, 0.2, 0.5],
                        [0.4, 0.1, 0.5]])

# 使用torch.max函数来找出每个样本的概率最大的类别
# torch.max函数会返回两个值：第一个是所有元素中的最大值，第二个是最大值的索引。
_, predicted = torch.max(outputs.data, 1)

print(outputs.data)
print(predicted)

运行结果如下：

python 复制代码 
tensor([[0.1000, 0.6000, 0.3000],
        [0.3000, 0.2000, 0.5000],
        [0.4000, 0.1000, 0.5000]])
tensor([1, 2, 2])

在这个例子中，我们只关心最大值的索引，所以我们将第一个返回值赋给了_（这是一个惯例，用来表示我们不关心这个值），将第二个返回值赋给了predicted。

运行结果意味着对于第一个样本，最可能的类别是1；对于第二个样本，最可能的类别是2；对于第三个样本，最可能的类别是2。

10、效果展示

python 复制代码 
images, labels = next(iter(test_loader))
images = images[:5]
labels = labels[:5]
 
fig, axes = plt.subplots(1, 5, figsize=(10,2))
 
for i in range(5):
    image = images[i].numpy().squeeze()
    axes[i].imshow(image, cmap='gray')
    axes[i].axis('off')
    axes[i].set_title(f'Ground Truth: {labels[i]}')
 
plt.show()

我们对一些图像示例进行效果展示，代码运行结果如下：

python 复制代码 
Epoch [1/5], Step [100/600], Loss: 0.3604086637496948
Epoch [1/5], Step [200/600], Loss: 0.2783631682395935
Epoch [1/5], Step [300/600], Loss: 0.29356688261032104
Epoch [1/5], Step [400/600], Loss: 0.13155366480350494
Epoch [1/5], Step [500/600], Loss: 0.18544769287109375
Epoch [1/5], Step [600/600], Loss: 0.06006329879164696
Epoch [2/5], Step [100/600], Loss: 0.11900061368942261
Epoch [2/5], Step [200/600], Loss: 0.19561482965946198
Epoch [2/5], Step [300/600], Loss: 0.07113198935985565
Epoch [2/5], Step [400/600], Loss: 0.12459728121757507
Epoch [2/5], Step [500/600], Loss: 0.13040272891521454
Epoch [2/5], Step [600/600], Loss: 0.09031425416469574
Epoch [3/5], Step [100/600], Loss: 0.09412173926830292
Epoch [3/5], Step [200/600], Loss: 0.0353107750415802
Epoch [3/5], Step [300/600], Loss: 0.03482735529541969
Epoch [3/5], Step [400/600], Loss: 0.036286383867263794
Epoch [3/5], Step [500/600], Loss: 0.07363829016685486
Epoch [3/5], Step [600/600], Loss: 0.03800008445978165
Epoch [4/5], Step [100/600], Loss: 0.06861492246389389
Epoch [4/5], Step [200/600], Loss: 0.036878302693367004
Epoch [4/5], Step [300/600], Loss: 0.10551707446575165
Epoch [4/5], Step [400/600], Loss: 0.026761818677186966
Epoch [4/5], Step [500/600], Loss: 0.009054150432348251
Epoch [4/5], Step [600/600], Loss: 0.052843380719423294
Epoch [5/5], Step [100/600], Loss: 0.02340124174952507
Epoch [5/5], Step [200/600], Loss: 0.06188277155160904
Epoch [5/5], Step [300/600], Loss: 0.02213984914124012
Epoch [5/5], Step [400/600], Loss: 0.015961142256855965
Epoch [5/5], Step [500/600], Loss: 0.032785091549158096
Epoch [5/5], Step [600/600], Loss: 0.08630551397800446
该模型在10000张测试图像上的准确性: 97.79%

完整代码

python 复制代码 
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import matplotlib.pyplot as plt

# 加载MNIST数据集
train_dataset = datasets.MNIST(root='./dataset', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='./dataset', train=False, transform=transforms.ToTensor(), download=True)

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

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

# 设置超参数
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# 准备数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 实例化模型
model = MLP(input_size, hidden_size, num_classes)

# 定义损失函数
criterion = nn.CrossEntropyLoss()

# 定义优化器
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images.reshape(-1, 28 * 28)

        # 前向传播和计算损失
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{total_step}], Loss: {loss.item()}')

# 在测试集上测试模型
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28 * 28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'该模型在10000张测试图像上的准确性: {100 * correct / total}%')

# 显示图像示例
images, labels = next(iter(test_loader))
images = images[:20]
labels = labels[:20]

fig, axes = plt.subplots(4, 5, figsize=(10, 8))

for i in range(20):
    row = i // 5
    col = i % 5
    image = images[i].numpy().squeeze()
    axes[row, col].imshow(image, cmap='gray')
    axes[row, col].axis('off')
    axes[row, col].set_title(f'Ground Truth: {labels[i]}')

plt.show()
相关推荐
charles_vaez7 分钟前
开源模型应用落地-glm模型小试-glm-4-9b-chat-快速体验（一）
深度学习·语言模型·自然语言处理
北京搜维尔科技有限公司26 分钟前
搜维尔科技：【应用】Xsens在荷兰车辆管理局人体工程学评估中的应用
人工智能·安全
说私域29 分钟前
基于开源 AI 智能名片 S2B2C 商城小程序的视频号交易小程序优化研究
人工智能·小程序·零售
YRr YRr29 分钟前
深度学习：Transformer Decoder详解
人工智能·深度学习·transformer
知来者逆34 分钟前
研究大语言模型在心理保健智能顾问的有效性和挑战
人工智能·神经网络·机器学习·语言模型·自然语言处理
Shy96041838 分钟前
Bert完形填空
python·深度学习·bert
云起无垠43 分钟前
技术分享 | 大语言模型赋能软件测试：开启智能软件安全新时代
人工智能·安全·语言模型
老艾的AI世界1 小时前
新一代AI换脸更自然，DeepLiveCam下载介绍（可直播）
图像处理·人工智能·深度学习·神经网络·目标检测·机器学习·ai换脸·视频换脸·直播换脸·图片换脸
翔云API1 小时前
PHP静默活体识别API接口应用场景与集成方案
人工智能
浊酒南街1 小时前
吴恩达深度学习笔记：卷积神经网络（Foundations of Convolutional Neural Networks）4.9-4.10
人工智能·深度学习·神经网络·cnn
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解