识别手写体训练

import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import os
import numpy as np
import matplotlib.pyplot as plt

train_dataset = paddle.vision.datasets.MNIST(mode='train')
train_data0 = np.array(train_dataset[0][0])
train_label_0 = np.array(train_dataset[0][1])

import matplotlib.pyplot as plt
plt.figure("Image") 
plt.figure(figsize=(2,2))
plt.imshow(train_data0, cmap=plt.cm.binary)
plt.axis('on') 
plt.title('image') 
plt.show()

print("图像数据形状和对应数据为:", train_data0.shape)
print("图像标签形状和对应数据为:", train_label_0.shape, train_label_0)
print("\n打印第一个batch的第一个图像，对应标签数字为{}".format(train_label_0))

<Figure size 432x288 with 0 Axes>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NGabMgMO-1634644077122)(output_0_1.png)]

图像数据形状和对应数据为: (28, 28)
图像标签形状和对应数据为: (1,) [5]

打印第一个batch的第一个图像，对应标签数字为[5]

class MNIST(paddle.nn.Layer):
    def __init__(self):
        super(MNIST, self).__init__()
        
        self.fc = paddle.nn.Linear(in_features=784, out_features=1)
        
    def forward(self, inputs):
        outputs = self.fc(inputs)
        return outputs
    
model = MNIST()

def train(model):
    # 启动训练模式
    model.train()
    # 加载训练集 batch_size 设为 16
    train_loader = paddle.io.DataLoader(paddle.vision.datasets.MNIST(mode='train'), 
                                        batch_size=16, 
                                        shuffle=True)
    # 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
    opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
    
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

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

# 声明网络结构
model = MNIST()

def train(model):
    # 启动训练模式
    model.train()
    # 加载训练集 batch_size 设为 16
    train_loader = paddle.io.DataLoader(paddle.vision.datasets.MNIST(mode='train'), 
                                        batch_size=16, 
                                        shuffle=True)
    # 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
    opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
    EPOCH_NUM = 10
    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)
            
            #每训练了1000批次的数据，打印下当前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')

epoch_id: 0, batch_id: 0, loss is: [35.403942]
epoch_id: 0, batch_id: 1000, loss is: [3.3787675]
epoch_id: 0, batch_id: 2000, loss is: [6.1969786]
epoch_id: 0, batch_id: 3000, loss is: [4.3007855]
epoch_id: 1, batch_id: 0, loss is: [2.09677]
epoch_id: 1, batch_id: 1000, loss is: [4.869377]
epoch_id: 1, batch_id: 2000, loss is: [4.388109]
epoch_id: 1, batch_id: 3000, loss is: [1.6821584]
epoch_id: 2, batch_id: 0, loss is: [2.491665]
epoch_id: 2, batch_id: 1000, loss is: [3.3969984]
epoch_id: 2, batch_id: 2000, loss is: [2.2498403]
epoch_id: 2, batch_id: 3000, loss is: [2.8166604]
epoch_id: 3, batch_id: 0, loss is: [1.5383272]
epoch_id: 3, batch_id: 1000, loss is: [5.3626423]
epoch_id: 3, batch_id: 2000, loss is: [4.950197]
epoch_id: 3, batch_id: 3000, loss is: [3.0365744]
epoch_id: 4, batch_id: 0, loss is: [2.5833237]
epoch_id: 4, batch_id: 1000, loss is: [2.9150538]
epoch_id: 4, batch_id: 2000, loss is: [2.7810657]
epoch_id: 4, batch_id: 3000, loss is: [2.3846889]
epoch_id: 5, batch_id: 0, loss is: [3.7310703]
epoch_id: 5, batch_id: 1000, loss is: [5.640292]
epoch_id: 5, batch_id: 2000, loss is: [2.4973407]
epoch_id: 5, batch_id: 3000, loss is: [1.522246]
epoch_id: 6, batch_id: 0, loss is: [2.2333567]
epoch_id: 6, batch_id: 1000, loss is: [2.6798303]
epoch_id: 6, batch_id: 2000, loss is: [4.607363]
epoch_id: 6, batch_id: 3000, loss is: [1.7579248]
epoch_id: 7, batch_id: 0, loss is: [2.5416288]
epoch_id: 7, batch_id: 1000, loss is: [3.3468866]
epoch_id: 7, batch_id: 2000, loss is: [6.2182436]
epoch_id: 7, batch_id: 3000, loss is: [1.7090782]
epoch_id: 8, batch_id: 0, loss is: [1.554079]
epoch_id: 8, batch_id: 1000, loss is: [3.5351539]
epoch_id: 8, batch_id: 2000, loss is: [2.2879343]
epoch_id: 8, batch_id: 3000, loss is: [2.482368]
epoch_id: 9, batch_id: 0, loss is: [2.4254403]
epoch_id: 9, batch_id: 1000, loss is: [2.6885557]
epoch_id: 9, batch_id: 2000, loss is: [3.3892422]
epoch_id: 9, batch_id: 3000, loss is: [4.632673]

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image

img_path = 'D:/1.jpg'
# 读取原始图像并显示
im = Image.open('D:/1.jpg')
plt.imshow(im)
plt.show()
# 将原始图像转为灰度图
im = im.convert('L')
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)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KiTWtEiA-1634644077129)(output_2_0.png)]

原始图像shape:  (28, 28)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i4QoYFH9-1634644077132)(output_2_2.png)]

采样后图片shape:  (28, 28)

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

# 定义预测过程
model = MNIST()
params_file_path = 'mnist.pdparams'
img_path = 'D:/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'))

result Tensor(shape=[1, 1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [[1.23619771]])
本次预测的数字是 [[1]]