项目一手写数字识别

上文回顾，目前已经揭晓了CNN、DataLoader、Dataset、SGD、CrossEntropy、Square_error_cost的使用方式，最后还有一点点首尾工作就完成了第一阶段初识框架

1、优化器

SGD
随机梯度下降算法，每次训练少量数据，抽样偏差导致的参数收敛过程中震荡。

opt=paddle.optimizer.SGD(learning_rate=0.01,parameters=model.parameters())

Momentum
给梯度下降的过程加入一定的“惯性”累积，就可以减少更新路径上的震荡，即每次更新的梯度由“历史多次梯度的累积方向”和“当次梯度”加权相加得到。历史多次梯度的累积方向往往是从全局视角更正确的方向，

opt=paddle.optimizer.Momentum(learning_rate=0.01,momentum=0.9,parameters=model.parameters())

AdaGrad
根据不同参数距离最优解的远近，动态调整学习率。学习率逐渐下降，依据各参数变化大小调整学习率。

opt=paddle.optimizer.AdaGrad(learning_rate=0.01,parameters=model.parameters())

Adam
由于动量和自适应学习率两个优化思路是正交的，因此可以将两个思路结合起来，这就是当前广泛应用的算法。

opt=paddle.optimizer.Adam(learning_rate=0.01,parameters=model.parameters())

2 GPU环境配置

一开始我以为很容易，结果呵呵，我搞了几个钟，以下是我记录的报错记录
我目前的配置是cuda10 windows系统
(1) ‘is_compiled_with_rocm’ from ‘paddle.fluid.framework’
(2)ValueError: The device should not be <re.Match object; span=(0, 5), match='g
(3) paddle have not attribute nn
以上问题都可以归结为一点，没有做好paddlegpu 版本与cuda的适配，经过我多次尝试终于成功了

python -m pip install paddlepaddle-gpu==2.2.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

只有这个是ok的，其他都不行，相信我
当然，其他环境的配置可根据paddle 的官方文档来，但是就我笔记本cuda10 而言，就只有这个命令是安装成功的

最后看看结合了优化器以及cuda配置之后，是怎么使用的，这里有个很神奇的地方就是，竟然不用像torch一样需要对图片和标签都加入cuda修饰，而是直接paddle全局设置

from dataset import load_data
import paddle
import paddle.nn.functional as F
import numpy as np
from network import MNIST
def evaluation(model,flag):
    model.eval()
    val_loader=load_data(flag)
    avg_acc_list=[]
    for batch_id,data in enumerate(val_loader()):
        images,labels=data
        images=paddle.to_tensor(images)
        labels=paddle.to_tensor(labels)
        predicts=model(images)

        acc=paddle.metric.accuracy(input=predicts,label=labels)
        avg_acc_list.extend(acc)
    avg_acc=np.array(avg_acc_list)
    avg_acc=avg_acc.mean()
    return avg_acc

def train(model):
    # 开启GPU
    use_gpu = True
    paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu')
    model.train()
    train_loader=load_data('train')
    opt=paddle.optimizer.SGD(learning_rate=0.01,parameters=model.parameters())
    opt=paddle.optimizer.Momentum(learning_rate=0.01,momentum=0.9,parameters=model.parameters())
    opt=paddle.optimizer.Adagrad(learning_rate=0.01,parameters=model.parameters())
    opt=paddle.optimizer.Adam(learning_rate=0.01,parameters=model.parameters())

    EPOCH_NUM=3
    for epoch_id in range(EPOCH_NUM):
        for batch_id,data in enumerate(train_loader()):
            images,labels=data
            images=paddle.to_tensor(images)
            labels=paddle.to_tensor(labels)

            predicts=model(images)

            loss=F.cross_entropy(predicts,labels)
            avg_loss=paddle.mean(loss)
            if batch_id %200==0:
                print("epoch:{} batch :{} loss:{}".format(epoch_id,batch_id,avg_loss.numpy()))

            avg_loss.backward()
            opt.step()
            opt.clear_grad()

        acc_train_mean=evaluation(model,'train')
        acc_val_mean=evaluation(model,'valid')
        print('train_acc: {}, val acc: {}'.format(acc_train_mean, acc_val_mean))
    paddle.save(model.state_dict(),'mnist.pdparams')

model=MNIST()
train(model)

dataset.py

import os
import random
import numpy as np

import gzip
import json

def load_data(mode='train'):
    datafile='./work/mnist.json.gz'
    data=json.load(gzip.open(datafile))
    train_set,val_set,eval_set=data

    IMG_ROWS=28
    IMG_COLS=28
    if mode=='train':
        imgs=train_set[0]
        labels=train_set[1]
    elif mode=='valid':
        imgs=val_set[0]
        labels=val_set[1]
    elif mode=='eval':
        imgs=eval_set[0]
        labels=eval_set[1]

    imgs_length=len(imgs)
    assert len(imgs)==len(labels), "length of train_imgs({}) should be the same as train_labels({})".format(len(imgs),len(labels))
    index_list=list(range(imgs_length))

    BATCH_SIZE=100

    def data_generator():
        if mode=='train':
            random.shuffle(index_list)
        imgs_list=[]
        labels_list=[]
        for i in index_list:
            img=np.reshape(imgs[i],[1,IMG_ROWS,IMG_COLS]).astype('float32')
            label=np.reshape(labels[i],[1]).astype('int64')
            imgs_list.append(img)
            labels_list.append(label)
            if len(imgs_list)==BATCH_SIZE:
                yield np.array(imgs_list),np.array(labels_list)
                imgs_list=[]
                labels_list=[]
        if len(imgs_list)>0:
            yield np.array(imgs_list),np.array(labels_list)
    return data_generator

network.py

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

class MNIST(paddle.nn.Layer):
    def __init__(self):
        super(MNIST, self).__init__()

        self.conv1=Conv2D(in_channels=1,out_channels=20,kernel_size=5,stride=1,padding=2)
        self.max_pool1=MaxPool2D(kernel_size=2,stride=2)
        self.conv2=Conv2D(in_channels=20,out_channels=20,kernel_size=5,stride=1,padding=2)
        self.max_pool2=MaxPool2D(kernel_size=2,stride=2)
        self.fc=Linear(in_features=980,out_features=10)

    def forward(self,inputs):
        x=self.conv1(inputs)
        x=F.relu(x)
        x=self.max_pool1(x)
        x=self.conv2(x)
        x=F.relu(x)
        x=self.max_pool2(x)
        x=paddle.reshape(x,[x.shape[0],-1])
        x=self.fc(x)
        return x