P1:实现MNIDST手写数字识别

目录

一、前期准备

1.1 设置GPU

1.2 导入数据

 1.3 数据可视化

二、构建CNN网络

三、训练模型

3.1 设置超参数

3.2 编写训练函数

 3.3 测试函数

3.4 训练

四、结果可视化


一、前期准备

语言环境:Python3.8

1.1 设置GPU

如果设备上支持GPU就使用GPU,否则使用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')

1.2 导入数据

torchvision.datasets是Pytorch自带的一个数据库,我们可以通过代码在线下载数据,这里使用的是torchvision.datasets中的MNIST数据集。

MNIST是一个大型的手写数字数据库,通常用于训练各种图像处理系统。包含70,000张手写数字图像: 60,000张用于训练,10,000张用于测试。图像是灰度且28x28像素的,居中,以减少预处理和加快运行。

trian_ds = torchvision.datasets.MNIST('data',
                                      train=True,
                                      transform=torchvision.transforms.ToTensor(),
                                      download=True)
test_ds = torchvision.datasets.MNIST('data',
                                      train=False,
                                      transform=torchvision.transforms.ToTensor(),
                                      download=True)

参数说明 

root (string) :数据地址  
train (string) :True-训练集,False-测试集  
download (bool,optional) : 如果为True,从互联网上下载数据集,并把数据集放在root目录下。  
transform (callable, optional ):这里的参数选择一个你想要的数据转化函数,直接完成数据转化  
target_transform (callable,optional) :接受目标并对其进行转换的函数/转换。

torch.utils.data.DataLoader是Pytorch自带的一个数据加载器,结合了数据集和取样器,并且可以提供多个线程处理数据集。

batch_size = 32
trian_dl = torch.utils.data.DataLoader(trian_ds, batch_size, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds, batch_size)
imgs, labels = next(iter(trian_dl))
imgs.shape

 参数说明 

dataset(string) :加载的数据集  
batch_size (int,optional) :每批加载的样本大小(默认值:1)  
shuffle(bool,optional) : 如果为True,每个epoch重新排列数据。  
sampler (Sampler or iterable, optional) : 定义从数据集中抽取样本的策略。 可以是任何实现了 __len__ 的 Iterable。 如果指定,则不得指定 shuffle 。  
batch_sampler (Sampler or iterable, optional) : 类似于sampler,但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。  
num_workers(int,optional) : 用于数据加载的子进程数。 0 表示数据将在主进程中加载(默认值:0)。  
pin_memory (bool,optional) : 如果为 True,数据加载器将在返回之前将张量复制到设备CUDA 固定内存中。 如果数据元素是自定义类型,或者collate_fn返回一个自定义类型的批次。  
drop_last(bool,optional) : 如果数据集大小不能被批次大小整除,则设置为 True 以删除最后一个不完整的批次。 如果 False 并且数据集的大小不能被批大小整除,则最后一批将保留。 (默认值:False)  
timeout(numeric,optional) : 设置数据读取的超时时间 , 超过这个时间还没读取到数据的话就会报错。(默认值:0)  

worker_init_fn(callable,optional) : 如果不是 None,这将在步长之后和数据加载之前在每个工作子进程上调用,并使用工作 id([0,num_workers - 1] 中的一个 int)的顺序逐个导入。 (默认:None)

 1.3 数据可视化

import numpy as np
# 指定图片大小,图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5))
for i, imgs in enumerate(imgs[:20]):
    # 维度缩减
    npimg = np.squeeze(imgs.numpy())
    # 将整个figure分成2行10列,绘制第i+1个子图。
    plt.subplot(2,10,i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')

二、构建CNN网络

对于一般的CNN网络来说,都是由特征提取网络和分类网络构成,其中特征提取网络用于提取图片的特征,分类网络用于将图片进行分类。

●nn.Conv2d为卷积层,用于提取图片的特征,传入参数为输入channel,输出channel,池化核大小
●nn.MaxPool2d为池化层,进行下采样,用更高层的抽象表示图像特征,传入参数为池化核大小
●nn.ReLU为激活函数,使模型可以拟合非线性数据
●nn.Linear为全连接层,可以起到特征提取器的作用,最后一层的全连接层也可以认为是输出层,传入参数为输入特征数和输出特征数(输入特征数由特征提取网络计算得到,如果不会计算可以直接运行网络,报错中会提示输入特征数的大小) 

import torch.nn.functional as F
num_class = 10 # 10个类别
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1,32,kernel_size=3)#第一层卷积层
        self.pool1 = nn.MaxPool2d(2)#第一层池化层
        self.conv2 = nn.Conv2d(32,64,kernel_size=3)#第二层卷积层
        self.pool2 = nn.MaxPool2d(2)#第二层池化层

        #分类网络
        self.fc1 = nn.Linear(1600, 64)
        self.fc2 = nn.Linear(64, num_class)
    #前向传播
    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

加载并打印模型 

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.1 设置超参数

loss_fn = nn.CrossEntropyLoss()
learning_rate = 0.001
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

3.2 编写训练函数

import tqdm as tqdm
def train(dataloader , model ,loss_fn, optimizer):
        size = len(dataloader.dataset)
        num_batches = len(dataloader)
        train_acc = 0.0
        train_loss = 0.0
        par = tqdm.tqdm(dataloader)
        for x ,y in par:
            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
        par.set_description(desc= f'loss={train_loss:.4f} acc={train_acc:.4f}')
        return train_acc, train_loss

 3.3 测试函数

测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器

def test(dataloader, model ,loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss=0.0
    test_acc = 0.0
    par = tqdm.tqdm(dataloader)
    with torch.no_grad():
        for imgs, target in par:
            imgs, target = imgs.to(device), target.to(device)
            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
    par.set_description(desc= f'loss={test_loss:.4f} acc={test_acc:.4f}')
    return test_acc, test_loss

3.4 训练

epochs = 5
trian_acc = []
trian_loss = []
test_acc = []
test_loss = []
for epoch in range(epochs):
        model.train()
        epoch_acc, epoch_loss = train(trian_dl, model, loss_fn, optimizer)
        model.eval()
        epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

        trian_acc.append(epoch_acc)
        trian_loss.append(epoch_loss)
        test_acc.append(epoch_test_acc)
        test_loss.append(epoch_test_loss)
        tmp = ('Epoch: {:2d}, Train Loss: {:.4f}, Train Acc: {:.4f}%, Test Loss: {:.4f}, Test Acc: {:.4f}%')
        print(tmp.format(epoch+1, epoch_loss, epoch_acc*100, epoch_test_loss, epoch_test_acc*100))

四、结果可视化

plt.figure(dpi=100)
epoch_range = range(1, epochs+1)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epoch_range, trian_acc, label='Training Accuracy')
plt.plot(epoch_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training  and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epoch_range, trian_loss, label='Training Loss')
plt.plot(epoch_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training  and Validation Loss')
plt.show()

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值