STEP1:数据加载和预处理(MNIST)
STEP2:模型的网络设计和开发
- 方式1:Sequential线性组网方式;快速堆叠组建网络
- 方式2:Subclass组网;可灵活自定义组织
- 方式3:高层API,Paddle框架内置模型
STEP3:模型训练
- Model封装 model = paddle.Model(mnist)
- 指定优化器 model.prepare() 进行参数配置
- 指定Loss计算方法
- 指定评估指标
- 按照训练轮次和数据批次迭代模型 modely.fit(train_dataset,epochs,batch_size,verbose)
STEP4:模型评估和测试
STEP3:模型保存和部署
# 模型网络结构搭建
network = paddle.nn.Sequential(
paddle.nn.Flatten(), # 拉平,将 (28, 28) => (784)
paddle.nn.Linear(784, 512), # 隐层:线性变换层
paddle.nn.ReLU(), # 激活函数
paddle.nn.Linear(512, 10) # 输出层
)
- 输入层:每张图片像素值为28*28的二维数组,将二维数组拼接拉平成一维数组,即就是784
- 隐藏层:512可根据实际情况进行调整,经验值
- 输出层:0~9的数字,一共由10类
>> 01 显示图片
# 导入图像读取第三方库
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
img_path = 'D:/Users/xuyf2/Desktop/123/8_1.JPG'
# 读取原始图像并显示
im = Image.open(img_path)
plt.imshow(im)
# 将原始图像转为灰度图
im = im.convert('L')
plt.show()
print('原始图像shape: ', np.array(im).shape)
# 使用Image.ANTIALIAS方式采样原始图片
im = im.resize((28, 28), Image.ANTIALIAS)
plt.imshow(im)
plt.show()
print("采样后图片shape: ", np.array(im).shape)
>> 02 模型训练
import paddle
import paddle.nn.functional as F
from paddle.vision.datasets import MNIST
# 01 数据处理
train_dataset = MNIST(mode='train')
paddle.vision.set_image_backend('cv2') # 确保从paddle.vision.datasets.MNIST中加载的图像数据是np.ndarray类型
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
# 将图像形式reshape为[batch_size, 784]
img = paddle.reshape(img, [batch_size, img_h * img_w])
return img
# 02 模型设计
class MNIST(paddle.nn.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义一层全连接层,输出维度是10
self.fc = paddle.nn.Linear(in_features=784, out_features=10)
# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputs
# 03 模型训练
model = MNIST()
def train(model):
# 启动训练模式
model.train()
# 加载训练集 batch_size 设为 16, shuffle:每轮训练都随机打乱一次训练数据
train_loader = paddle.io.DataLoader(paddle.vision.datasets.MNIST(mode='train'), batch_size=8,shuffle=True)
# 定义优化器,使用随机梯度下降SGD优化器,学习率设置为0.001
opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
#-------------------------------------训练过程采用二层循环嵌套方式------------------------------------------
EPOCH_NUM = 20 # 定义外层循环次数
for epoch in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
images = norm_img(data[0]).astype('float32')
labels = data[1].astype('float32')
# 前向计算的过程
predicts = model(images)
# 计算损失
loss = F.square_error_cost(predicts, labels)
avg_loss = paddle.mean(loss)
if batch_id % 1000 == 0:
print("epoch_id: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, avg_loss.numpy()))
# 后向传播,更新参数的过程
avg_loss.backward()
opt.step()
opt.clear_grad()
train(model)
paddle.save(model.state_dict(), 'mnist.pdparams')
>> 03 模型预测
- 预测过程:①声明实例 ②加载模型 ③灌入数据 ④打印结果
- 注意事项:①图片数据归一化 ②路径正确 ③模型“校验”状态
import numpy as np
from PIL import Image
import paddle
from paddle.vision.datasets import 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.array(im).reshape(1, -1).astype(np.float32)
# 图像归一化,保持和数据集的数据范围一致
im = 1 - im / 255
return im
class MNIST(paddle.nn.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义一层全连接层,输出维度是1
self.fc = paddle.nn.Linear(in_features=784, out_features=1)
# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputs
# 声明实例
model = MNIST()
params_file_path = 'mnist.pdparams'
img_path = 'D:/Users/xuyf2/Desktop/123/8_1.JPG'
# 加载模型
param_dict = paddle.load(params_file_path)
model.load_dict(param_dict)
# 灌入数据
model.eval()
tensor_img = load_image(img_path)
result = model(paddle.to_tensor(tensor_img))
# 打印结果
print('result',result)
print("本次预测的数字是", result.numpy().astype('int32'))