深度学习(1)——CNN训练MINIST手写数字数据集

最新推荐文章于 2024-06-03 19:26:35 发布

初见。。

最新推荐文章于 2024-06-03 19:26:35 发布

阅读量832

点赞数 4

分类专栏：深度学习文章标签：深度学习 cnn 人工智能

本文链接：https://blog.csdn.net/qq_45144394/article/details/131669795

版权

深度学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

CNN训练MINIST手写数字数据集

卷积神经网络结构

在卷积神经网络中，有卷积层与池化层，首先来看看卷积层和池化层是什么吧！！

卷积

在实际生活中，一张图片的颜色组成分为R、G、B，所有的颜色都是由三原色组成，所以一张图片可以被拆分成为三层。拿一张大小为28-28的图片来说，可以被分为三张28-28大小的图像，当然这里不是针对二值图像或者灰度图像来说的。如果是二值图像或者灰度图像，那么它本身就是一个28-28的个体。

神经网络中卷积的含义就是通过一个固定大小的滤波器，去对图像像素矩阵做点乘，然后逐渐按照步长平移，在这里由于边缘像素利用率低，还需要进行填充操作。

滤波器的数量也是应该设置好的，这里的滤波器在术语中称为卷积核，同时卷积核的数量对应着通道的数量。而通过卷积核之后的尺寸大小应该与步长、卷积核大小和输入图像尺寸大小有关。

卷积层是CNN的核心组件，它通过使用一组可学习的滤波器（也称为卷积核或特征检测器）在输入图像上进行卷积运算来提取局部特征。卷积运算是一种通过将滤波器与输入图像的不同位置进行逐元素相乘并求和的方式来实现的。这样可以捕捉到图像中的边缘、纹理和其他局部特征。

池化

池化层用于减小特征图的空间尺寸，同时保留重要的特征信息。最常用的池化操作是最大池化，它将输入区域中的最大值作为输出。池化层有助于减少计算量，提高模型的计算效率，并且对于平移和缩放的输入具有一定程度的不变性。

池化其实就是为了减少图像像素图的尺寸，并且要保留其中的特征信息，常见的池化分为最大池化和平均池化。

在CNN中，卷积层和池化层可以通过堆叠和重复来构建深层网络结构。深层网络可以学习更复杂的特征表示，并在图像分类、目标检测、语义分割和图像生成等任务中取得出色的性能。

除了卷积层和池化层，CNN还包括全连接层（或称为密集连接层），用于将提取的特征映射与输出类别进行关联。全连接层通常位于CNN的末尾，并通过权重和偏置进行线性变换，并应用激活函数（如ReLU）来产生最终的输出。

CNN通过反向传播算法进行训练，使用大量标注的图像数据进行优化。通过最小化损失函数（如交叉熵损失），CNN可以自动学习从原始图像到目标类别之间的映射关系。

在这里插入图片描述

模型建立

该模型应用了两个卷积层和一个全连接层，第一个卷积层的卷积核数为16，卷积核尺寸为5-5，步长为1，填充大小为2；第二个卷积层的卷积核数为32，卷积核尺寸为5-5，步长为1，填充大小为2；第一个卷积层的卷积核数为16，卷积核尺寸为5-5，步长为1，填充大小为2；全连接线性层最后对应输出层为10个节点，分别代表图片中的数字为0-9的概率。

在卷积层后的激活函数用relu，池化层中的滤波窗口大小为2-2，EPOCH表示训练轮数，BATCH_SIZE表示更新一次参数的输入数量（批次数量）。

CPU版本与GPU版本的区别在于，有GPU的电脑用GPU训练卷积神经网络会非常快速，若没有则只能用CPU来训练网络，核心区别就是在搭建网络训练时加上.cuda。

模型的整体结构如下图所示

在这里插入图片描述

CPU版本

import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
from torchsummary import summary
import time


# 创建神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.output_layer = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.reshape(x.size(0), -1)
        output = self.output_layer(x)
        return output


# 超参数
EPOCH = 2
BATCH_SIZE = 200
LR = 0.001
DOWNLOAD = False  # 若已经下载mnist数据集则设为False

# 下载mnist数据
train_data = datasets.MNIST(
    root='./data',  # 保存路径
    train=True,  # True表示训练集，False表示测试集
    transform=transforms.ToTensor(),  # 将0~255压缩为0~1
    download=DOWNLOAD
)

# 旧的写法
print(train_data.train_data.size())
print(train_data.train_labels.size())

# 新的写法
print(train_data.data.size())
print(train_data.targets.size())

# 打印部分数据集的图片
for i in range(2):
    print(train_data.targets[i].item())
    plt.imshow(train_data.data[i].numpy(), cmap='gray')
    plt.show()

# DataLoader
train_loader = Data.DataLoader(
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=0
)

# 如果train_data下载好后，test_data也就下载好了
test_data = datasets.MNIST(
    root='./data',
    train=False
)

print(test_data.data.size())
print(test_data.targets.size())

# 新建网络
cnn = CNN()
print(cnn)

# 查看网络的结构
model = CNN()
if torch.cuda.is_available():
    model.cuda()
summary(model, input_size=(1, 28, 28))

# 优化器
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)

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

# 为了节约时间，只使用测试集的前2000个数据
test_x = Variable(
    torch.unsqueeze(test_data.data, dim=1),
    volatile=True
).type(torch.FloatTensor)[:2000] / 255  # 将将0~255压缩为0~1

test_y = test_data.targets[:2000]

# # 使用所有的测试集
# test_x = Variable(
#     torch.unsqueeze(test_data.test_data, dim=1),
#     volatile=True
# ).type(torch.FloatTensor)/255 # 将将0~255压缩为0~1

# test_y = test_data.test_labels

# 开始计时
start = time.time()

# 训练神经网络
for epoch in range(EPOCH):
    for step, (batch_x, batch_y) in enumerate(train_loader):
        output = cnn(batch_x)
        loss = loss_func(output, batch_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 每隔50步输出一次信息
        if step % 50 == 0:
            test_output = cnn(test_x)
            predict_y = torch.max(test_output, 1)[1].data.squeeze()
            accuracy = (predict_y == test_y).sum().item() / test_y.size(0)
            print('Epoch', epoch, '|', 'Step', step, '|', 'Loss', loss.data.item(), '|', 'Test Accuracy', accuracy)

# 结束计时
end = time.time()

# 训练耗时
print('Time cost:', end - start, 's')

# 预测
test_output = cnn(test_x[:100])
predict_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
real_y = test_y[:100].numpy()
print(predict_y)
print(real_y)

# 打印预测和实际结果
for i in range(10):
    print('Predict', predict_y[i])
    print('Real', real_y[i])
    plt.imshow(test_data.data[i].numpy(), cmap='gray')
    plt.show()

GPU版本

import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
from torchsummary import summary
import time


# 创建神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.output_layer = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.reshape(x.size(0), -1)
        output = self.output_layer(x)
        return output


# 超参数
EPOCH = 2
BATCH_SIZE = 100
LR = 0.001
DOWNLOAD = False  # 若已经下载mnist数据集则设为False

# 下载mnist数据
train_data = datasets.MNIST(
    root='./data',  # 保存路径
    train=True,  # True表示训练集，False表示测试集
    transform=transforms.ToTensor(),  # 将0~255压缩为0~1
    download=DOWNLOAD
)

# 旧的写法
print(train_data.train_data.size())
print(train_data.train_labels.size())

# 新的写法
print(train_data.data.size())
print(train_data.targets.size())

# 打印部分数据集的图片
for i in range(2):
    print(train_data.targets[i].item())
    plt.imshow(train_data.data[i].numpy(), cmap='gray')
    plt.show()

# DataLoader
train_loader = Data.DataLoader(
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=0
)

# 如果train_data下载好后，test_data也就下载好了
test_data = datasets.MNIST(
    root='./data',
    train=False
)

print(test_data.data.size())
print(test_data.targets.size())

# 新建网络
cnn = CNN()
# 将神经网络移到GPU上
cnn.cuda()
print(cnn)

# 查看网络的结构
model = CNN()
if torch.cuda.is_available():
    model.cuda()
summary(model, input_size=(1, 28, 28))

# 优化器
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)

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

# 为了节约时间，只使用测试集的前2000个数据
test_x = Variable(
    torch.unsqueeze(test_data.data, dim=1),
    volatile=True
).type(torch.FloatTensor)[:2000] / 255  # 将将0~255压缩为0~1

test_y = test_data.targets[:2000]

# # 使用所有的测试集
# test_x = Variable(
#     torch.unsqueeze(test_data.test_data, dim=1),
#     volatile=True
# ).type(torch.FloatTensor)/255 # 将将0~255压缩为0~1

# test_y = test_data.test_labels

# 将测试数据移到GPU上
test_x = test_x.cuda()
test_y = test_y.cuda()

# 开始计时
start = time.time()

# 训练神经网络
for epoch in range(EPOCH):
    for step, (batch_x, batch_y) in enumerate(train_loader):
        # 将训练数据移到GPU上
        batch_x = batch_x.cuda()
        batch_y = batch_y.cuda()
        output = cnn(batch_x)
        loss = loss_func(output, batch_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 每隔50步输出一次信息
        if step % 50 == 0:
            test_output = cnn(test_x)
            # 将预测结果移到GPU上
            predict_y = torch.max(test_output, 1)[1].cuda().data.squeeze()
            accuracy = (predict_y == test_y).sum().item() / test_y.size(0)
            print('Epoch', epoch, '|', 'Step', step, '|', 'Loss', loss.data.item(), '|', 'Test Accuracy', accuracy)

# 结束计时
end = time.time()

# 训练耗时
print('Time cost:', end - start, 's')

# 预测
test_output = cnn(test_x[:100])
# 为了将CUDA tensor转化为numpy，需要将数据移回CPU上
# 否则会报错：TypeError: can't convert CUDA tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.
predict_y = torch.max(test_output, 1)[1].cpu().data.numpy().squeeze()
real_y = test_y[:100].cpu().numpy()
print(predict_y)
print(real_y)

# 打印预测和实际结果
for i in range(10):
    print('Predict', predict_y[i])
    print('Real', real_y[i])
    plt.imshow(test_data.data[i].numpy(), cmap='gray')
    plt.show()