手写数字识别全连接神经网络

内容都是百度AIstudio的内容，我只是在这里做个笔记，不是原创。 

经典的全连接神经网络含有四层网络：两个隐含层，输入层和输出层。

• 输入层。准备数据，输入给神经网络。
• 隐含层。增加网络深度和复杂度，隐含层的节点数是可以调整的。节点数越多，神经网络表示能力越强，但同时参数量也会增加。
• 输出层。输出网络计算结果，输出层的节点数是固定的，比如手写数字识别有0-9十个数字，输出标签有10个，所以输出层必须是10个节点。

说明：

隐含层引入非线性激活函数sigmoid是为了增加神经网络的非线性能力，举例来说，一个神经网络有四个输入x1~x4，一个输出y，采用线性变换。假设第一层的变换是z1=x1-x2和z2=x3+x4，第二层的变换是y=z1+z2。将两层的变换展开后得到 y=x1-x2+x3+x4。原始输入和最终输出之间依然是线性关系，无论中间累积了多少层线性变换均是如此。

def sigmoid(x):
    # 直接返回sigmoid函数
    return 1. / (1. + np.exp(-x))
 
# param:起点，终点，间距
x = np.arange(-8, 8, 0.2)
y = sigmoid(x)
plt.plot(x, y)
plt.show()

#合并后代码
#数据处理部分之前的代码，加入部分数据处理的库
#数据处理部分之前的代码，保持不变
import os
import random
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

import gzip
import json

#数据处理部分的展开代码
# 定义数据集读取器
def load_data(mode='train'):

    # 数据文件
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    data = json.load(gzip.open(datafile))
    # 读取到的数据可以直接区分训练集，验证集，测试集
    train_set, val_set, eval_set = data

    # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
    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]
    else:
        raise Exception("mode can only be one of ['train', 'valid', 'eval']")

    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))

    # 读入数据时用到的batchsize
    BATCHSIZE = 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('float32')
            imgs_list.append(img) 
            labels_list.append(label)
            if len(imgs_list) == BATCHSIZE:
                # 产生一个batch的数据并返回
                yield np.array(imgs_list), np.array(labels_list)
                # 清空数据读取列表
                imgs_list = []
                labels_list = []

        # 如果剩余数据的数目小于BATCHSIZE，
        # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
        if len(imgs_list) > 0:
            yield np.array(imgs_list), np.array(labels_list)
    return data_generator

#数据处理部分之后的代码，数据读取的部分调用Load_data函数
# 定义网络结构，同上一节所使用的网络结构
class MNIST(fluid.dygraph.Layer):
    def __init__(self, name_scope):
        super(MNIST, self).__init__(name_scope)
        name_scope = self.full_name()
        # self.fc = FC(name_scope, size=1, act=None)
        # 定义两层全连接隐含层，输出维度是10，激活函数为sigmoid
        self.fc1 = FC(name_scope, size=10, act='sigmoid') # 隐含层节点为10，可根据任务调整
        self.fc2 = FC(name_scope, size=10, act='sigmoid')
        # 定义一层全连接输出层，输出维度是1，不使用激活函数
        self.fc3 = FC(name_scope, size=1, act=None)

    def forward(self, inputs):
        # outputs = self.fc(inputs)
        # return outputs
        outputs1 = self.fc1(inputs)
        outputs2 = self.fc2(outputs1)
        outputs_final = self.fc3(outputs2)
        return outputs_final

# 训练配置，并启动训练过程
with fluid.dygraph.guard():
    model = MNIST("mnist")
    model.train()
    #调用加载数据的函数
    train_loader = load_data('train')
    # 创建异步数据读取器
    place = fluid.CPUPlace()
    data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
    data_loader.set_batch_generator(train_loader, places=place)
    
    optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
    EPOCH_NUM = 10
    for epoch_id in range(EPOCH_NUM):
        for batch_id, data in enumerate(data_loader):
            image_data, label_data = data
            image = fluid.dygraph.to_variable(image_data)
            label = fluid.dygraph.to_variable(label_data)
            
            predict = model(image)
            
            loss = fluid.layers.square_error_cost(predict, label)
            avg_loss = fluid.layers.mean(loss)
            
            if batch_id % 200 == 0:
                print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
            
            avg_loss.backward()
            optimizer.minimize(avg_loss)
            model.clear_gradients()

    fluid.save_dygraph(model.state_dict(), 'mnist')

单个图片预测代码：

def load_image(img_path):
    # 从img_path中读取图像，并转为灰度图
    im = Image.open(img_path).convert('L')
    # print(np.array(im))
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.reshape(im,[1, 28,28]).astype(np.float32)
    # 图像归一化，保持和数据集的数据范围一致
    im = 1- im / 127.5 
    # print(im)
    img=np.array(im).reshape(28,28).astype(np.float32)
    plt.imshow(img)
    return im
 
# 定义预测过程
with fluid.dygraph.guard():
    # model = MNIST("mnist")
    # params_file_path = 'mnist'
    img_path = './work/example_0.png'
    # 加载模型参数
    model_dict, _ = fluid.load_dygraph("mnist")
    model.load_dict(model_dict)
    
    model.eval()
    tensor_img = load_image(img_path)
    result = model(fluid.dygraph.to_variable(tensor_img))
    #预测输出取整，即为预测的数字
    print("本次预测的数字是", result.numpy().astype('int32'))

在测试集上验证模型的有效性

自己写代码计算准确率

with fluid.dygraph.guard():
    print('start evaluation .......')
    #加载模型参数
    model = MNIST("mnist")
    model_state_dict, _ = fluid.load_dygraph('mnist')
    model.load_dict(model_state_dict)
 
    model.eval()
    eval_loader = load_data('eval')
 
    acc_set = []
    avg_loss_set = []
    cnt=0
    sum=0
    for batch_id, data in enumerate(eval_loader()):
        x_data, y_data = data
        img = fluid.dygraph.to_variable(x_data)
        label = fluid.dygraph.to_variable(y_data)
        prediction= model(img)
        prediction=prediction.numpy().astype('int32')
        label=label.numpy().astype('int32')
        for i in range(len(label)):
            # print(prediction[i],label[i])
            if(prediction[i]==label[i]):
                cnt+=1
        sum+=100
        # print(len(prediction))
        # print("hello:",prediction.numpy().astype('int32'),label.numpy().astype('int32'))
        # loss = fluid.layers.square_error_cost(input=prediction, label=label)
        # avg_loss = fluid.layers.mean(loss)
        # acc_set.append(float(acc.numpy()))
        # avg_loss_set.append(float(avg_loss.numpy()))
    
    #计算多个batch的平均损失和准确率
    # acc_val_mean = np.array(acc_set).mean()
    # avg_loss_val_mean = np.array(avg_loss_set).mean()

    print("acc:",cnt/sum)
    # print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

with fluid.dygraph.guard():
    print('start evaluation .......')
    #加载模型参数
    model = MNIST("mnist")
    model_state_dict, _ = fluid.load_dygraph('mnist')
    model.load_dict(model_state_dict)

    model.eval()
    eval_loader = load_data('eval')

    acc_set = []
    avg_loss_set = []
    for batch_id, data in enumerate(eval_loader()):
        x_data, y_data = data
        img = fluid.dygraph.to_variable(x_data)
        label = fluid.dygraph.to_variable(y_data)
        prediction, acc = model(img, label)
        loss = fluid.layers.cross_entropy(input=prediction, label=label)
        avg_loss = fluid.layers.mean(loss)
        acc_set.append(float(acc.numpy()))
        avg_loss_set.append(float(avg_loss.numpy()))
    
    #计算多个batch的平均损失和准确率
    acc_val_mean = np.array(acc_set).mean()
    avg_loss_val_mean = np.array(avg_loss_set).mean()

    print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

最后

以上就是老迟到过客为你收集整理的手写数字识别全连接神经网络的全部内容，希望文章能够帮你解决手写数字识别全连接神经网络所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。