之前的模型还是基于单层线性回归的网络，对mnist手写数字的识别效果并不好，这一章来跟随paddle官方教程来实现多层感知网络和卷积网络。
数据处理和加载函数和上一章一样
#数据处理部分之前的代码，保持不变
import os
import random
import paddle
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))
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')
# 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:
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接着跟着教程实现一下四层网络，激活函数用sigmoid
import paddle.nn.functional as F
from paddle.nn import Linear
# 定义多层全连接神经网络
class MNIST(paddle.nn.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义两层全连接隐含层，输出维度是10，当前设定隐含节点数为10，可根据任务调整
self.fc1 = Linear(in_features=784, out_features=10)
self.fc2 = Linear(in_features=10, out_features=10)
# 定义一层全连接输出层，输出维度是1
self.fc3 = Linear(in_features=10, out_features=1)
# 定义网络的前向计算，隐含层激活函数为sigmoid，输出层不使用激活函数
def forward(self, inputs):
# inputs = paddle.reshape(inputs, [inputs.shape[0], 784])
outputs1 = self.fc1(inputs)
outputs1 = F.sigmoid(outputs1)
outputs2 = self.fc2(outputs1)
outputs2 = F.sigmoid(outputs2)
outputs_final = self.fc3(outputs2)
return outputs_final之后来写训练过程，换成SGD优化器，paddle这SGD优化器的语法倒是和pytorch一样了
#网络结构部分之后的代码，保持不变
def train(model):
model.train()
#调用加载数据的函数，获得MNIST训练数据集
train_loader = load_data('train')
# 使用SGD优化器，learning_rate设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
# 训练5轮
EPOCH_NUM = 5
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.square_error_cost(predicts, labels)
avg_loss = paddle.mean(loss)
#每训练200批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
# 最小化loss,更新参数
opt.step()
# 清除梯度
opt.clear_grad()
#保存模型参数
paddle.save(model.state_dict(), 'mnist.pdparams')
model = MNIST()
train(model)按道理这种分类问题应该是输出10个结果，再用softmax函数得到最后结果的，不过这一章教程主要研究网络结构，损失函数以及softmax函数在下一章教程讲。
我们用torch也来实现一下,改一下Mnist类的结构就行了，其他都不变，本来torch的激活函数和paddle是一个路径的，即torch.nn.functional，但现在新的版本提示我用torch.sigmoid就好
import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torchvision
import json
import numpy as np
import gzip
import random
class Mnist(nn.Module):
def __init__(self):
super(Mnist,self).__init__()
self.fc1 = nn.Linear(28*28*1,10)
self.fc2 = nn.Linear(10,10)
self.fc3 = nn.Linear(10,1)
def forward(self,x):
x = x.view(-1,28*28*1)
x = self.fc1(x)
x = torch.sigmoid(x)
x = self.fc2(x)
x = torch.sigmoid(x)
x = self.fc3(x)
x = torch.sigmoid(x)
return x
# 训练配置，并启动训练过程
model = Mnist()
model.train(mode=True)
#调用加载数据的函数
train_loader = load_data('train')
optimizer = optim.SGD(model.parameters(),lr= 0.001)
criterion = nn.MSELoss()
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，变得更加简洁
image_data, label_data = data
image = torch.tensor(image_data)
label = torch.tensor(label_data)
#前向计算的过程
predict = model(image)
#计算损失，取一个批次样本损失的平均值
loss = criterion(predict, label)
avg_loss = torch.mean(loss)
#每训练了200批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.detach().numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
optimizer.step()
model.zero_grad()这loss还是很大啊，没啥用，图像分类还是得用卷积，paddle这一章教程还没有细说卷积的原理，不过我们可以先来实现一下，具体原理可以看下一章教程。首先改一下网络结构，注意到这里输入的是单通道图像，也就是【1×28×28】的数组，所以后面输入数据也要reshape成[batch_size, 1, 28, 28]
# 定义 SimpleNet 网络结构
import paddle
from paddle.nn import Conv2D, MaxPool2D, Linear
import paddle.nn.functional as F
# 多层卷积神经网络实现
class MNIST(paddle.nn.Layer):
def __init__(self):
super(MNIST, 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)
# 定义卷积层，输出特征通道out_channels设置为20，卷积核的大小kernel_size为5，卷积步长stride=1，padding=2
self.conv2 = Conv2D(in_channels=20, out_channels=20, kernel_size=5, stride=1, padding=2)
# 定义池化层，池化核的大小kernel_size为2，池化步长为2
self.max_pool2 = MaxPool2D(kernel_size=2, stride=2)
# 定义一层全连接层，输出维度是1
self.fc = Linear(in_features=980, out_features=1)
# 定义网络前向计算过程，卷积后紧接着使用池化层，最后使用全连接层计算最终输出
# 卷积层激活函数使用Relu，全连接层不使用激活函数
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训练过程也要改一下输入shape
#网络结构部分之后的代码，保持不变
def train(model):
model.train()
#调用加载数据的函数，获得MNIST训练数据集
train_loader = load_data('train')
# 使用SGD优化器，learning_rate设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
# 训练5轮
EPOCH_NUM = 5
# MNIST图像高和宽
IMG_ROWS, IMG_COLS = 28, 28
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据
images, labels = data
images = paddle.to_tensor(images)
images = paddle.reshape(images, [images.shape[0],1,IMG_ROWS,IMG_COLS])
labels = paddle.to_tensor(labels)
#前向计算的过程
predicts = model(images)
#计算损失，取一个批次样本损失的平均值
loss = F.square_error_cost(predicts, labels)
avg_loss = paddle.mean(loss)
#每训练了200批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
# 最小化loss,更新参数
opt.step()
# 清除梯度
opt.clear_grad()
#保存模型参数
paddle.save(model.state_dict(), 'mnist.pdparams')
#创建模型
model = MNIST()
#启动训练过程
train(model)torch版本我们也改一下
from torch.nn import Conv2d,MaxPool2d,Linear
#数据处理部分之后的代码，数据读取的部分调用load_data函数
# 定义网络结构，同上一节所使用的网络结构
class Mnist(nn.Module):
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=1)
def forward(self,x):
x = self.conv1(x)
x = torch.relu(x)
x = self.max_pool1(x)
x = self.conv2(x)
x = torch.relu(x)
x = self.max_pool2(x)
x = torch.reshape(x,[x.shape[0],-1])
x = self.fc(x)
return x
# 训练配置，并启动训练过程
model = Mnist()
model.train(mode=True)
#调用加载数据的函数
train_loader = load_data('train')
optimizer = optim.SGD(model.parameters(),lr= 0.001)
criterion = nn.MSELoss()
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，变得更加简洁
image_data, label_data = data
image = torch.tensor(image_data)
label = torch.tensor(label_data)
image = torch.reshape(image,[image.shape[0],1,28,28])
#前向计算的过程
predict = model(image)
#计算损失，取一个批次样本损失的平均值
loss = criterion(predict, label)
avg_loss = torch.mean(loss)
#每训练了200批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.detach().numpy()))
#后向传播，更新参数的过程
avg_loss.backward()
optimizer.step()
model.zero_grad()卷积网络loss就小了很多了
Comments NOTHING