首个神经网络代码

import os
import random
import paddle
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

import gzip
import json

def sigmoid(x):
    return 1. / (1. + np.exp(-x))

x = np.arange(-8, 8, 0.2)
#print(x)
y = sigmoid(x)
plt.plot(x, y)
#plt.show()

class MnistDataset(paddle.io.Dataset):
    def __init__(self, mode):
        datafile = './work/mnist.json.gz'
        data = json.load(gzip.open(datafile))

        train_set, val_set, eval_set = data

        self.IMG_ROWS = 28
        self.IMG_COLS = 28

        if mode == 'train':
            imgs, labels = train_set[0], train_set[1]
        elif mode == 'valid':
            imgs, labels = val_set[0], val_set[1]
        elif mode == 'eval':
            imgs, labels = eval_set[0], 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))

        self.imgs = imgs
        self.labels = labels
    
    def __getitem__(self, idx):
        img = np.reshape(self.imgs[idx], 
                         [1, self.IMG_ROWS, self.IMG_COLS]).astype('float32')
        label = np.reshape(self.labels[idx], [1]).astype('int64')
        
        return img, label
    
    def __len__(self):
        return len(self.imgs)
    
# 声明数据加载函数，使用训练模式，MnistDataset构建的迭代器每次迭代只返回batch=1的数据
train_dataset = MnistDataset(mode='train')

# 使用paddle.io.DataLoader 定义DataLoader对象用于加载Python生成器产生的数据，
# DataLoader 返回的是一个批次数据迭代器，并且是异步的；
train_loader = paddle.io.DataLoader(train_dataset, batch_size=100,
                                    shuffle=True, drop_last=True)
val_dataset = MnistDataset(mode='valid')
val_loader = paddle.io.DataLoader(val_dataset, batch_size=128, drop_last=True)


def load_data(mode='train'):
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {}'.format(datafile))
    data = json.load(gzip.open(datafile))
    print('mnist dataset load done')

    # 读取到的数据区分训练集、验证集和测试集
    train_set, val_set, eval_set = data

    # 数据集相关参数，图片高度IMG_ROWS 图片宽度IMG_COLS
    IMG_ROWS = 28
    IMG_COLS = 28

    if mode == 'train':
        imgs, labels = train_set[0], train_set[1]
    elif mode == 'valid':
        imgs, labels = val_set[0], val_set[1]
    elif mode == 'eval':
        imgs, labels = eval_set[0], 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.array(imgs[i]).astype('float32')
            #label = np.array(labels[i]).astype('float32')
            label = np.array(labels[i]).astype('int64')

            # 在使用卷积神经网络结构时，uncommet 下面两行代码
            img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
            #label = np.reshape(labels[i], [1]).astype('float32')
            label = np.reshape(labels[i], [1]).astype('int64')

            imgs_list.append(img)
            labels_list.append(label)

            if len(imgs_list) == BATCHSIZE:
                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

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

# 多层卷积神经网络实现
class MNIST_Conv(paddle.nn.Layer):
    def __init__(self):
        super(MNIST_Conv, self).__init__()
        # 定义卷积层，输出特征通道out_channels设置为20，卷积核大小kernel_size为5， 卷积步长stride=1，padding=2
        self.conv1 = Conv2D(in_channels=1, out_channels=20, kernel_size=5, stride=1, padding=2)
        # 定义池化层，池化核的大小kernel_size为2，池化步长为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)
        # 定义一层全连接层，输出维度为1
        #self.fc = Linear(in_features=980, out_features=1)
        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 = paddle.reshape(x, [x.shape[0], 980])
        x = self.fc(x)
        return x


# 确保从paddle.vision.datasets.MNIST中加载的图像数据是np.ndarray类型
paddle.vision.set_image_backend('cv2')

model = MNIST_Conv()

# 图像归一化函数，将数据范围为【0，255】的图像归一化到【0，1】
def norm_img(img):
    # 验证传入数据格式是否正确，img的shape为[batch_size, 28, 28]
    assert len(img.shape) == 3
    batch_size, img_h, img_w = img.shape[0], img.shape[1], img.shape[2]
    #归一化图像数据
    img = img / 255
    #将图像形式reshpe为[batch_size, 784]
    img = paddle.reshape(img, [batch_size, img_h*img_w])
    return img

def train(model):
    # 启用训练模式
    model.train()
    # 加载训练集
    train_loader = load_data('train')

    # 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
    opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())

    EPOCH_NUM = 10
    IMG_ROWS, IMG_COLS = 28, 28
    loss_list = []

    for epoch 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.square_error_cost(predicts, labels)
            loss = F.cross_entropy(predicts, labels)
            avg_loss = paddle.mean(loss)

            #每训练了1000批次的数据，打印下当前loss
            if batch_id % 200 == 0:
                loss = float(avg_loss)
                loss_list.append(loss)
                print("epoch_id: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, float(avg_loss)))

            #后向传播，更新参数过程
            avg_loss.backward()
            opt.step()
            opt.clear_grad()
    return loss_list

loss_list = train(model)
paddle.save(model.state_dict(), './mnist03covd.pdparams')    

def evaluation(model, datasets):
    model.eval()
    acc_set = list()

    for batch_id, data in enumerate(datasets()):
        images, labels = data
        images = paddle.to_tensor(images)
        labels = paddle.to_tensor(labels)
        pred = model(images)
        acc = paddle.metric.accuracy(input=pred, label=labels)
        acc_set.extend(acc.numpy())
    
    acc_val_mean = np.array(acc_set).mean()
    return acc_val_mean

def plot(loss_list):
    plt.figure(figsize=(10, 5))
    freqs = [i for i in range(len(loss_list))]
    # 绘制训练损失变化曲线
    plt.plot(freqs, loss_list, color='#e4007f', label='Train loss')
    # 绘制坐标和图例
    plt.ylabel('loss', fontsize='large')
    plt.xlabel('freq', fontsize='large')
    plt.legend(loc='upper right', fontsize='x-large')
    plt.show()

plot(loss_list)

from PIL import Image
img_path = './work/example_0.jpg'
#读取原始图像并显示
im = Image.open(img_path)
plt.imshow(im)
#plt.show()
# 将原始图转为灰度图
im = im.convert('L')
print('原始图像shape：', np.array(im).shape)
# 使用Image.ANTIALIAs方式采集原始图片
im = im.resize((28, 28), Image.LANCZOS)
plt.imshow(im)
plt.show()
print('采样后图片shape：',np.array(im).shape)

def load_image(img_path):
    im = Image.open(img_path).convert('L')
    im = im.resize((28, 28), Image.LANCZOS)
    im = np.array(im).reshape(1, -1).astype(np.float32)
    im = 1 - im / 255
    return im

model = MNIST_Conv()
params_file_path = 'mnist03covd.pdparams'
img_path = './work/example_0.jpg'
#加载模型参数
param_dict = paddle.load(params_file_path)
model.load_dict(param_dict)

#灌入数据
model.eval()

tensor_img = load_image(img_path)
imgarr = []
imgarr.append(np.reshape(tensor_img, [1, 28, 28]).astype('float32'))
tensor_img = np.array(imgarr)
result = model(paddle.to_tensor(tensor_img))
print('result', result)
print('本次预测的结果数字是：', result.numpy().astype('int32'))

训练手写数字识别