Week1,实现MNIST手写数字识别
Week1-pytoch实现MNIST手写数字识别
- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍦 参考文章:365天深度学习训练营-第P1周:实现mnist手写数字识别
- 🍖 原作者:K同学啊 | 接辅导、项目定制
- 🚀 文章来源:K同学的学习圈子
MNIST手写数字数据集是机器学习中常用的数据集,很适合作为深度学习的入门学习内容。下面本文以MNIST数据集为例实现一个两层卷积神经网络的简单模型。
本人电脑配置
Python 3.8.0
Pytorch 1.8.1
torchvision 0.9.1 + cu10.2
前期准备
1. 设置GPU
在这里想要说明一点是,如果电脑有显卡,在装pytorch时需要安装gpu版本的,可参考网上其他博主,不能直接“pip install torch”,否则会默认安装CPU版本。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
2. 导入数据
使用dataset下载MNIST数据集,并划分好训练集与测试集;使用dataloader加载数据,并设置好基本的batch_size。
下载数据到主目录的文件夹的data文件夹里
train_ds = torchvision.datasets.MNIST('data',
train=True,
transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
download=True)
test_ds = torchvision.datasets.MNIST('data',
train=False,
transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
download=True)
加载数据,定义batch_size为32
batch_size = 32
train_d1 = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)
test_d1 = torch.utils.data.DataLoader(test_ds, batch_size=batch_size)
3. 数据可视化
可视化部分MNIST数据集
import numpy as np
plt.figure(figsize=(20,5))
for i, imgs in enumerate(imgs[:20]):
npimg = np.squeeze(imgs.numpy())
plt.subplot(2,10,i+1)
plt.imshow(npimg, cmap=plt.cm.binary)
plt.axis('off')
构建网络模型
1. 搭建模型
构建两层卷积、两层全连接的神经网络。
import torch.nn.functional as F
num_classes = 10
class Model(nn.Module):
def __init__(self):
super().__init__()
# 特征提取网络
self.conv1 = nn.Conv2d(1, 32, kernel_size=3) # 第一层卷积,卷积核大小为3*3
self.pool1 = nn.MaxPool2d(2) # 设置池化层,池化核大小为2*2
self.conv2 = nn.Conv2d(32, 64, kernel_size=3) # 第二层卷积,卷积核大小为3*3
self.pool2 = nn.MaxPool2d(2)
# 分类网络
self.fc1 = nn.Linear(1600, 64)
self.fc2 = nn.Linear(64, num_classes)
# 前向传播
def forward(self, x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.relu(self.conv2(x)))
x = torch.flatten(x, start_dim=1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
2. 可视化模型
利用torchinfo包查看模型的结构并计算模型每一层的参数量,显示出来的结果如下。
from torchinfo import summary
model = Model().to(device)
summary(model)
=================================================================
Layer (type:depth-idx) Param #
=================================================================
Model --
├─Conv2d: 1-1 320
├─MaxPool2d: 1-2 --
├─Conv2d: 1-3 18,496
├─MaxPool2d: 1-4 --
├─Linear: 1-5 102,464
├─Linear: 1-6 650
=================================================================
Total params: 121,930
Trainable params: 121,930
Non-trainable params: 0
=================================================================
3. 编写训练函数
在进行前向传播后,需要把梯度清零,再进行loss回传。
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
num_batches = len(dataloader)
train_loss, train_acc = 0, 0
for X, y in dataloader:
X, y = X.to(device), y.to(device)
pred = model(X)
loss = loss_fn(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
4. 编写测试函数
当不进行训练时,停止梯度更新,节省计算内存消耗。
def test (dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小,一共10000张图片
num_batches = len(dataloader) # 批次数目,313(10000/32=312.5,向上取整)
test_loss, test_acc = 0, 0
# 当不进行训练时,停止梯度更新,节省计算内存消耗
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
5. 主函数
设置迭代epoch次数,这里设定为100,并记录训练误差、精度,测试误差、精度。
epochs = 100
train_loss = []
train_acc = []
test_loss = []
test_acc = []
for epoch in range(epochs):
model.train()
epoch_train_acc, epoch_train_loss = train(train_d1, model, loss_fn, opt)
model.eval()
epoch_test_acc, epoch_test_loss = test(test_d1, model, loss_fn)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')
至此,训练过程结果结束,下附上训练误差、精度与测试误差、精度随迭代次数变化曲线吧。在上述的参数下,epoch为62时,训练集的精度已经达到100%,而之后,测试集精度一直在99%,98.9%,98.8%左右。