基于PaddlePaddle的Mnist手写数字分类

2025-06-23

字数统计: 493字 | 阅读时长: 3分

使用PaddlePaddle写的Mnist手写数字识别，测试集准确率99.50%。

代码如下:

import paddle
from paddle import nn, io, vision, optimizer
import numpy as np

import os


class LeNet(nn.Layer):
    def __init__(self, num_classes=10):
        super(LeNet, self).__init__()

        self.conv1 = nn.Conv2D(1, 32, 5)
        self.pool1 = nn.MaxPool2D(2, stride=2)
        self.conv2 = nn.Conv2D(32, 64, 5)
        self.pool2 = nn.MaxPool2D(2, stride=2)

        self.act = nn.ReLU()

        self.fc1 = nn.Linear(1024, 512)
        self.dropout = nn.Dropout(0.5)
        self.out = nn.Linear(512, num_classes)

    def forward(self, x):
        x = self.pool1(self.act(self.conv1(x)))
        x = self.pool2(self.act(self.conv2(x)))

        x = paddle.flatten(x, 1)

        x = self.fc1(x)
        x = self.dropout(x)
        return self.out(x)


class Solver:
    def __init__(self, epochs=100, batch_size=32, lr=0.01):
        self.train_loader = io.DataLoader(vision.MNIST(mode="train", transform=vision.Compose([
            vision.RandomResizedCrop(28, scale=(0.8, 1.2)),
            vision.ToTensor()
        ])), batch_size=batch_size, shuffle=True)
        self.val_loader = io.DataLoader(vision.MNIST(mode="test", transform=vision.ToTensor()), batch_size=batch_size)

        self.model = LeNet()
        self.loss = nn.CrossEntropyLoss()
        self.scheduler = optimizer.lr.StepDecay(learning_rate=lr, step_size=5, gamma=0.8)
        self.optimizer = optimizer.Momentum(parameters=self.model.parameters(), learning_rate=self.scheduler, momentum=0.9, weight_decay=1e-4)

        self.epochs = epochs
        self.output_dir = "output"
        os.makedirs(self.output_dir, exist_ok=True)

    def train(self):
        for epoch in range(1, self.epochs + 1):
            self.train_epoch(epoch)

            acc = self.val_epoch()
            self.save_checkpoint(epoch, acc)

            self.scheduler.step()
            print()

    def train_epoch(self, epoch):
        loss_ls, acc_ls = [], []
        for step, (img, label) in enumerate(self.train_loader):
            pred = self.model(img)

            loss = self.loss(pred, label)
            acc = paddle.metric.accuracy(pred, label)

            self.optimizer.clear_grad()
            loss.backward()
            self.optimizer.step()

            loss, acc = float(loss), float(acc)
            loss_ls.append(loss)
            acc_ls.append(acc)
            print(f"[epoch={epoch}/{self.epochs}] "
                  f"step={step + 1:04}/{len(self.train_loader)} "
                  f"loss={loss:.4f}/{np.mean(loss_ls):.4f} "
                  f"acc={acc:.4f}/{np.mean(acc_ls):.4f} "
                  , end="\r", flush=True)
        print()

    @paddle.no_grad()
    def val_epoch(self):
        acc_ls = []
        for step, (img, label) in enumerate(self.val_loader):
            pred = self.model(img)
            acc = paddle.metric.accuracy(pred, label)

            acc = float(acc)
            acc_ls.append(acc)
            print(f"[VAL] "
                  f"step={step + 1}/{len(self.val_loader)} "
                  f"acc={acc:.4f}/{np.mean(acc_ls):.4f} ", end="\r", flush=True)
        return np.mean(acc_ls)

    def save_checkpoint(self, epoch, acc):
        model_file = os.path.join(self.output_dir, f"lenet_{epoch:04f}_{acc:.4f}.pdparams")
        paddle.save(self.model.state_dict(), model_file)

    def load_checkpoint(self, model_file):
        self.model.set_state_dict(paddle.load(model_file))


if __name__ == '__main__':
    Solver().train()

本文作者： killf
本文链接： https://www.killf.info/机器学习/基于PaddlePaddle的Mnist手写数字分类/
版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！