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'))
训练手写数字识别