基于paddle2.2.2 手写数字识别

代码参考来源

多层感知机

原始三层感知机

首先导入必要的库

numpy：可以创建多维数组对象以及处理数组

PIL：全称pillow，用于图像处理

matplotlib.pyplot：绘制图形，用于图行可视化

os：处理文件和目录

paddlepaddle的api参考文档

import numpy as np
import paddle as paddle
import paddle.nn as nn
import paddle.nn.functional as F
from PIL import Image
import matplotlib.pyplot as plt
import os

导入Compose是将用于数据预处理的接口以列表的方式组合

导入Normalize的作用是对图像归一化，有两种方式：

1.用统一的均值和标准差值对图像的每个通道进行归一化处理

2.对每个通道指定不同的均值和标准差值进行归一化处理

transform函数是定义了一个归一化标准化的标准

#使用transform对数据集做归一化
from paddle.vision.transforms import Compose,Normalize
transform=Compose([Normalize(mean=[127.5],std=[127.5],data_format='CHW')])


print("下载并加载训练数据")
train_dataset=paddle.vision.datasets.MNIST(mode='train',transform=transform)
test_dataset=paddle.vision.datasets.MNIST(mode='test',transform=transform,backend='cv2')
print("加载完成")

数据处理

train_data0, train_label_0 = train_dataset[0][0], train_dataset[0][1]
train_data0=train_data0.reshape([28,28])
plt.figure(figsize=(2,2))    #指定图片大小为2*2英寸
print(plt.imshow(train_data0,cmap=plt.cm.binary))
'''
cmap:颜色图实例或注册的颜色图名称
plt.cm.binary 二值图
'''
print('train_data0的标签为'+str(train_label_0))#输出train_data0的标签

定义模型

# 定义多层感知器
#结构为全连接1--relu激活函数1--全连接2--relu激活函数2--全连接3--softmax回归
class mnist(paddle.nn.Layer):
    def __init__(self):
        super(mnist,self).__init__()
        self.fc1=nn.Linear(in_features=28*28,out_features=100)
        self.fc2=nn.Linear(in_features=100,out_features=100)
        self.fc3=nn.Linear(in_features=100,out_features=10)
    def forward(self,input_):
        x=paddle.reshape(input_,[input_.shape[0],-1])
        x=self.fc1(x)
        x=F.relu(x)
        x=self.fc2(x)
        x=F.relu(x)
        x=self.fc3(x)
        y=F.softmax(x)
        return y

封装模型，定义优化器，配置模型

from paddle.metric import Accuracy
# 用Model封装模型
model=paddle.Model(mnist())

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

# 配置模型
model.prepare(optim,paddle.nn.CrossEntropyLoss(),Accuracy())

训练

这里的save_dir是训练模型保存的路径

verbose是保存日志，1代表保存，0代表不保存

# 训练保存并验证模型
model.fit(train_dataset,test_dataset,epochs=10,batch_size=64,save_dir='save_dir',verbose=1)

模型预测

# 获取测试集的第一个图片
test_data0, test_label_0 = test_dataset[0][0],test_dataset[0][1]
test_data0 = test_data0.reshape([28,28])
plt.figure(figsize=(2,2))

# 展示测试集中的第一个图片
print(plt.imshow(test_data0, cmap=plt.cm.binary))
print('test_data0的标签为' + str(test_label_0))

# 模型预测
result = model.predict(test_dataset, batch_size=1)
#若模型是单一输出：[(numpy_ndarray_1,numpy_ndarray_2,……,numpy_ndarray_n)]

print('test_data0预测的数值为：%d' % np.argsort(result[0][0])[0][-1]))

结果分析：

不难发现，预测值和标签相差很大，训练的loss最好的在1.4612，acc：0.9759（这里我尝试了三次，epoch分别为2，10，100，如下图所示）

epoch轮数增加确实会提高acc、减少loss，但是，这个提升是有限的，最好的办法就是换个模型或者把感知机层次加深

五层感知机（不建议采用）

可以发现五层感知机的loss为1.46，acc为0.92，准确率降低，损失基本没有变化

LeNet框架

把多层感知机的模型框架换成LeNet的模型框架

class LeNet(paddle.nn.Layer):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = paddle.nn.Conv2D(in_channels=1,out_channels=6,kernel_size=5,stride=1)
        #池化层L2
        self.pool1 = paddle.nn.MaxPool2D(kernel_size=2,stride=2)
        #卷积层L3
        self.conv2 = paddle.nn.Conv2D(in_channels=6,out_channels=16,kernel_size=5,stride=1)
        #池化层L4
        self.pool2 = paddle.nn.MaxPool2D(kernel_size=2,stride=2)
        #线性层L5
        self.fc1=paddle.nn.Linear(256,120)
        #线性层L6
        self.fc2=paddle.nn.Linear(120,84)
        #线性层L7
        self.fc3=paddle.nn.Linear(84,10)
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.pool1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = paddle.flatten(x, start_axis=1,stop_axis=-1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        out = self.fc3(x)
        return out

可以看到，loss几乎趋近于0，acc无限靠近1，

预测的结果也十分正确