FashionMNIST数据集上的卷积神经网络（CNN）训练与评估

最新推荐文章于 2024-10-10 22:47:40 发布

model_s3xy

最新推荐文章于 2024-10-10 22:47:40 发布

阅读量819

点赞数 16

文章标签：深度学习人工智能

本文链接：https://blog.csdn.net/m0_60402335/article/details/140904970

版权

FashionMNIST数据集上的卷积神经网络（CNN）训练与评估

数据准备

首先，我们从FashionMNIST数据集中加载训练数据和测试数据。FashionMNIST是一个常用的数据集，用于图像识别，特别是对服装的分类，包含10个类别的60000张28x28灰度图像用于训练，和10000张图像用于测试。

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from torch.optim import Adam
import torch.utils.data as Data
from torchvision import transforms
from torchvision.datasets import FashionMNIST
import matplotlib.pyplot as plt
import seaborn as sns

# 准备训练数据集
train_data = FashionMNIST(root="./data/FashionMNIST", train=True, 
                           transform=transforms.ToTensor(), download=True)
# DataLoader用于批量加载数据，并支持自动打乱数据顺序
train_loader = Data.DataLoader(dataset=train_data, 
                                batch_size=64, shuffle=True, num_workers=2)

# 准备测试数据集
test_data = FashionMNIST(root="./data/FashionMNIST", train=False, download=True)
# 将图像数据转换为Tensor，并进行归一化处理
test_data_x = test_data.data.type(torch.FloatTensor) / 255.0
# 增加一个维度来表示单通道图像
test_data_x = test_data_x.unsqueeze(dim=1)
test_data_y = test_data.targets

模型定义

接下来，定义了一个简单的卷积神经网络（CNN）模型MyConvnet，包含两个卷积层，每个卷积层后接ReLU激活函数和平均池化层，最后是全连接层用于分类。

class MyConvnet(nn.Module):
    def __init__(self):
        super(MyConvnet, self).__init__()
        # 第一个卷积层，使用1个输入通道，16个输出通道，3x3的卷积核
        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            # 使用最大池化层来减少特征图的空间维度
            nn.MaxPool2d(2, 2)
        )
        # 第二个卷积层，使用16个输入通道，32个输出通道
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=0),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        # 全连接层，将卷积层的输出特征图展平后进行分类
        self.classifier = nn.Sequential(
            nn.Linear(32 * 7 * 7, 256),  # 根据输出特征图的大小计算输入特征数量
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)  # 10个输出对应10个类别
        )

    def forward(self, x):
        # 前向传播过程
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)  # 展平特征图
        x = self.classifier(x)
        return x

训练过程

定义了train_model函数，用于训练模型，包括训练和验证的循环，损失和准确率的计算。

def train_model(model, train_loader, train_rate, criterion, optimizer, num_epochs=25):
    ##计算训练使用的batch数量
    batch_num = len(traindataloader)
    train_batch_num = round(batch_num * train_rate)
    ##复制模型的参数
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    train_loss_all = []
    train_acc_all = []
    val_loss_all = []
    val_acc_all = []
    since = time.time()
    # 训练和验证循环
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)
        ##每个epoch有两个训练阶段
        train_loss = 0.0
        train_corrects = 0
        train_num = 0
        val_loss = 0.0
        val_corrects = 0
        val_num = 0
        for step, (b_x,b_y) in enumerate(traindataloader):
            if step < train_batch_num:
                model.train()##设置为训练模式
                output = model(b_x)
                pre_lab = torch.argmax(output,1)
                loss = criterion(output, b_y)
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                train_loss += loss.item() * b_x.size(0)
                train_corrects += torch.sum(pre_lab == b_y.data)
                train_num += b_x.size(0)
            else:
                model.eval()##设置为评估模式
                output = model(b_x)
                pre_lab = torch.argmax(output,1)
                loss = criterion(output,b_y)
        ##计算一个epoch再训练集和验证集上的损失和精度
       # 将当前epoch的训练损失平均值添加到总损失列表中
                train_loss_all.append(train_loss / train_num)

                # 将当前epoch的训练准确率添加到训练准确率列表中
                # 使用double()确保准确率以浮点数形式计算
                                      train_acc_all.append(train_corrects.double().item()/train_num)

                # 将当前epoch的验证损失平均值添加到总验证损失列表中
                # 这里val_loss / val_num实际上可能不执行任何计算，因为val_loss可能一直为0.0
                val_loss_all.append(val_loss / val_num)

                # 将当前epoch的验证准确率添加到验证准确率列表中
                # 同样使用double()确保准确率以浮点数形式计算
                val_acc_all.append(val_corrects.double().item()/val_num)

                # 打印当前epoch的训练损失和准确率
                # 使用format()函数格式化字符串，其中epoch是当前epoch的索引
                print('{} train_loss: {:.4f}  Train Acc: {:.4f}'.format(epoch, train_loss_all[-1], train_acc_all[-1]))

                # 打印当前epoch的验证损失和准确率
                # 同样使用format()函数格式化字符串
                # 注意这里可能存在问题，因为如果val_loss和val_corrects没有被更新，这里打印的将是初始值
                print('{} Val Loss: {:.4f}  val Acc: {:.4f}'.format(epoch, val_loss_all[-1], val_acc_all[-1])
        ##拷贝模型最高精度下参数
        if val_acc_all[-1] > best_acc:
            best_acc = val_acc_all[-1]
            best_model_wts = copy.deepcopy(model.state_dict())
        time_use = time.time() - since
        print("Train and val complete in  {:.0f}m {:.0f}s".format(time_use // 60, time_use % 60))

        ##使用最好模型的参数
        model.load_state_dict(best_model_wts)
        train_process = pd.DataFrame(
            data={"epoch":range(num_epochs),
                  "train_loss_all":train_loss_all,
                  "val_loss_all":val_loss_all,
                  "train_acc_all":val_acc_all
                }
        )
        return model,train_process

模型训练与评估

使用定义的train_model函数训练模型，并可视化训练和验证过程中的损失和准确率。

# 训练模型
optimizer = Adam(myconvnet.parameters(), lr=0.0003)
criterion = nn.CrossEntropyLoss()
myconvnet, train_process = train_model(myconvnet, train_loader, 0.8, criterion, optimizer, num_epochs=25)

# 可视化训练过程
##可视化模型
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(train_process.epoch, train_process.train_loss_all,
         "ro-",lable = "Train loss")
plt.plot(train_process.epoch,train_process.val_loss_all,
         "bs-",label = "Val loss")
plt.legend()
plt.xlabel("epoch")
plt.ylabel("Loss")
plt.subplot(1,2,2)
plt.plot(train_process.epoch,train_process.train_acc_all,
            "ro-",label = "Train acc")
plt.plot(train_process.epoch,train_process.val_acc_all,
         "bs-",label = "Val acc")
plt.xlabel("epoch")
plt.ylabel("acc")
plt.legend()
plt.show()

测试集上的预测

在测试集上评估模型的性能，并计算预测准确率和混淆矩阵。

# 测试集预测
myconvnet.eval()
output = myconvnet(test_data_x)
pre_lab = torch.argmax(output, 1)
acc = accuracy_score(test_data_y, pre_lab)
print("在测试集上的预测精度为：", acc)

# 混淆矩阵
conf_mat = confusion_matrix(test_data_y, pre_lab)
# 可视化代码
df_cm = pd.DataFrame(conf_mat, index=class_label,columns=class_label)
heatmap = sns.heatmap(df_cm, annot=True,fmt="d", cmap="YlGnBu")
heatmap.yaxis.set_ticklabels(heatmap.yaxis.get_ticklabels(),rotation=0
                             ,ha='right')
heatmap.xaxis.set_ticklabels(heatmap.xaxis.get_ticklabels(),rotation=45
                             ,ha='right')
plt.ylabel('True label')
plt.xlabel('Predictied lable')
plt.show()

使用带有扩张卷积的模型

最后，定义了一个带有扩张卷积的模型MyConvdilaNet，并重复上述训练和评估过程。

class MyConvdilaNet(nn.Module):
    def __init__(self):
        super(MyConvdilaNet,self)
        self.conv1 = nn.Sequential(
            nn.Conv2d(1,16,3,1,1,dilation=2),
            nn.ReLU(),
            nn.AvgPool2d(2,2)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,3,1,0,dilation=2),
            nn.ReLU(),
            nn.AvgPool2d(2,2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(32*4*4,256),
            nn.ReLU(),
            nn.Linear(256,128),
            nn.ReLU(),
            nn.Linear(128,10)
        )
    ##定义前向传播路径
        def forward(self, x):
            x = self.conv1(x)
            x = self.conv2(x)
            x = x.view(x.size(0), -1)
            output = self.classifier(x)
            return output
myconvdilanet = MyConvdilaNet()

##对模型进行训练
optimizer = torch.optim.Adam(myconvdilanet.parameters(), lr=0.0003)
criterion = nn.CrossEntropyLoss() ##损失函数
myconvdilanet, train_process = train_model(myconvdilanet, train_loader, 0.8,
                                       criterion, optimizer, num_epochs=25)
##可视化模型
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(train_process.epoch, train_process.train_loss_all,
         "ro-",lable = "Train loss")
plt.plot(train_process.epoch,train_process.val_loss_all,
         "bs-",label = "Val loss")
plt.legend()
plt.xlabel("epoch")
plt.ylabel("Loss")
plt.subplot(1,2,2)
plt.plot(train_process.epoch,train_process.train_acc_all,
            "ro-",label = "Train acc")
plt.plot(train_process.epoch,train_process.val_acc_all,
         "bs-",label = "Val acc")
plt.xlabel("epoch")
plt.ylabel("acc")
plt.legend()
plt.show()
##对测试机进行预测，并可视化预测效果
myconvnet.eval()
output = myconvnet(test_data_x)
pre_lab = torch.argmax(output,1)
acc = accuracy_score(test_data_y, pre_lab)
print("在测试集上的预测精度为：",acc)