[学习笔记]基于paddle（飞桨）的手写数字识别

# -*- coding: utf-8 -*-
# LeNet 识别手写数字# 训练使用的代码：Train.py
from mpl_toolkits.mplot3d import Axes3D#绘图所需库
from matplotlib import pyplot as plt#绘图所需的库
import numpy as np
import paddle
from model import LeNet#使用LeNet网络
from paddle.vision.transforms import ToTensor
from paddle.vision.datasets import MNIST
#epochs=[]#记录轮数的列表
#Loss=[]#记录每张图片LOSS的列表

def Train(model, opt, Train_loader, valid_loader):#opt:优化器 Train_loader:评价集 valid_loader:训练集
    use_gpu = True#是否使用gpu
    paddle.device.set_device('gpu:0') if use_gpu else paddle.device.set_device('cpu')#0号gpu
    model.Train()#切换到训练模式
    for epoch in range(EPOCH_NUM):
        for batch_id, data in enumerate(Train_loader()):#将可遍历的对象组合为一个索引序列，用在for循环中   
            img = data[0]              #[10,1,28,28]
            label = data[1]            #[10,1]
            # 计算模型输出
            logits = model(img)
            # 计算损失函数
            loss_func = paddle.nn.CrossEntropyLoss(reduction='none')#交叉熵
            loss = loss_func(logits, label)
            avg_loss = paddle.mean(loss)

            if batch_id % 500 == 0:
                print("epoch: {}, batch_id: {}, loss is: {:.4f}".format(epoch+1, batch_id, float(avg_loss.numpy())))
            avg_loss.BACkWARD()
            opt.step()#反馈器，修改回调函数
            opt.clear_grad()

        model.eval()#评价模式
        accuracies = []#初始化两个列表
        losses = []
        for batch_id, data in enumerate(valid_loader()):
            img = data[0]#把图片放到评价集中
            label = data[1] 
            # 计算模型输出
            logits = model(img)
            # 计算损失函数
            loss_func = paddle.nn.CrossEntropyLoss(reduction='none')
            loss = loss_func(logits, label)
            acc = paddle.metric.accuracy(logits, label)#预测值，标签值
            accuracies.append(acc.numpy())
            losses.append(loss.numpy())
            #Loss.append(np.mean(losses))
        #print("[validation] accuracy/loss: {:.4f}/{:.4f}".format(np.mean(accuracies), np.mean(losses)))
        model.Train()

    # 保存模型参数
    paddle.save(model.state_Dict(), '@H_961_114@mnist.pdparams')#保存，模型‘’中是名字


model = LeNet(num_classes=10)
EPOCH_NUM = 5#训练轮数
opt = paddle.optimizer.Momentum(learning_rate=0.001, parameters=model.parameters())#定义优化器
Train_loader = paddle.io.DataLoader(MNIST(mode='Train', transform=ToTensor()), batch_size=20, shuffle=TruE)#定义训练集，从MINST中导入数据集
valid_loader = paddle.io.DataLoader(MNIST(mode='test', transform=ToTensor()), batch_size=20)#定义评价集               batch_size:每次导入gpu的图片数量
Train(model, opt, Train_loader, valid_loader)#以下为可视化LOSS曲线的内容
'''
for i in np.arange(0,EPOCH_NUM,EPOCH_NUM/len(Loss)):#离散化，把图片映射在0-5
    epochs.append(i)
plt.xlabel('epochs')#用取得的列表绘制图像
plt.ylabel('Loss')
plt.title("一元一次函数")
plt.plot(epochs, Loss)
plt.show()
'''

import paddle
import numpy as np
from paddle.nn import Conv2D, MaxPool2D, Linear
import paddle.nn.functional as F

# 定义 LeNet 网络结构
class LeNet(paddle.nn.Layer):
    def @H_197_350@__init__(self, num_classes=1):
        super(LeNet, self).@H_197_350@__init__()
        self.conv1 = Conv2D(in_chAnnels=1, out_chAnnels=6, kernel_size=5)#维度，卷积核大小
        self.max_pool1 = MaxPool2D(kernel_size=2, Stride=2)#一层卷积，一层池化
        self.conv2 = Conv2D(in_chAnnels=6, out_chAnnels=16, kernel_size=5)#二层卷积，二层池化
        self.max_pool2 = MaxPool2D(kernel_size=2, Stride=2)
        self.conv3 = Conv2D(in_chAnnels=16, out_chAnnels=120, kernel_size=4)#三层卷积
        self.fc1 = Linear(in_features=120, out_features=64)
        self.fc2 = Linear(in_features=64, out_features=num_classes)
    def forWARD(self, X):                        #[N,1,28,28] 
        x = self.conv1(X)                        #[N,6,24,24]
        x = F.sigmoid(X)                         #[N,6,24,24]
        x = self.max_pool1(X)                    #[N,6,12,12]
        x = F.sigmoid(X)                         #[N,6,12,12]
        x = self.conv2(X)                        #[N,16,8,8]
        x = self.max_pool2(X)                    #[N,16,4,4]
        x = self.conv3(X)                        #[N,120,1,1]
        x = paddle.reshape(x, [x.shape[0], -1])  #[N,120]
        x = self.fc1(X)                          #[N,64] 全连接层
        x = F.sigmoid(X)                         #[N,64] 激活函数
        x = self.fc2(X)                          #[N,10] 线性层
        return x

import numpy as np
import paddle
from model import LeNet
from paddle.vision.datasets import MNIST
from paddle.vision.transforms import ToTensor
import paddle.nn.functional as F
import matplotlib.pyplot as plt
import random
valid_loader = MNIST(mode='test', transform=ToTensor())#载入数据集
x=random.randint(0,100)
img = np.array(valid_loader[20][0])#获取一张图片


plt.imshow(img.squeeze(), cmap='gray')#这两行是从MINST中获取一张图片，并且显示之
plt.show()#以下为测试模型的部分
'''
model = LeNet(num_classes=10)#加载模型
model_Dict = paddle.load("mnist.pdparams")#加载模型
model.set_state_Dict(model_Dict)#加载模型
model.eval()
x = valid_loader[0][0].reshape((1,1,28,28)).astype('float32')
plt.imshow(img.squeeze(), cmap='gray')
plt.show()
result = F.softmax(model(X))
print(result.numpy()[0])
'''