1. 参考文档：paddle官网文档
2. 环境：Python 3.12.2 ，pip 24.0 ，paddlepaddle 2.6.0
   python -m pip install paddlepaddle==2.6.0 -i https://pypi.tuna.tsinghua.edu.cn/simple
3. 调试代码如下：
   LeNet.py

import paddle
import paddle.nn.functional as F

class LeNet(paddle.nn.Layer):
    def __init__(self):
        super().__init__()
        self.conv1 = paddle.nn.Conv2D(in_channels=1,out_channels=6,kernel_size=5,stride=1,padding=2)
        self.max_pool1 = paddle.nn.MaxPool2D(kernel_size=2,  stride=2)
        self.conv2 = paddle.nn.Conv2D(in_channels=6, out_channels=16, kernel_size=5, stride=1)
        self.max_pool2 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)
        self.linear1 = paddle.nn.Linear(in_features=16*5*5, out_features=120)
        self.linear2 = paddle.nn.Linear(in_features=120, out_features=84)
        self.linear3 = paddle.nn.Linear(in_features=84, out_features=10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.max_pool2(x)
        x = paddle.flatten(x, start_axis=1,stop_axis=-1)
        x = self.linear1(x)
        x = F.relu(x)
        x = self.linear2(x)
        x = F.relu(x)
        x = self.linear3(x)
        return x

train.py

import paddle
from paddle.vision.transforms import Compose,Normalize,ToTensor
import paddle.vision.transforms as T  

import numpy as np
import matplotlib.pyplot as plt
from paddle.metric import Accuracy

from LeNet import LeNet
from PIL import Image



print(paddle.__version__)
transform = Compose([Normalize(mean=[127.5],std=[127.5],data_format='CHW')])
print('下载和加载训练数据...')
train_dataset = paddle.vision.datasets.MNIST(mode='train',transform=transform)
test_dataset = paddle.vision.datasets.MNIST(mode='test',transform=transform)
print('load finished')

train_data0,train_label_0 = train_dataset[0][0],train_dataset[0][1]
train_data0 = train_data0.reshape([28,28])
plt.figure(figsize=(2,2))
plt.imshow(train_data0,cmap=plt.cm.binary)
#plt.show()
print('train_data0 label is: '+str(train_label_0))


model = paddle.Model(LeNet())   # 用Model封装模型
optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())

# 配置模型
print('配置模型...')
model.prepare(
    optim,
    paddle.nn.CrossEntropyLoss(),
    Accuracy()
    )
# 训练模型
print('训练模型...')
model.fit(train_dataset,
        epochs=2,
        batch_size=64,
        verbose=1
        )
# 保存模型  
model.save('./model/mnist_model')  # 默认保存模型结构和参数 

#预测模型
print('预测模型...')
model.evaluate(test_dataset, batch_size=64, verbose=1)

predicted.py

import paddle

import numpy as np

from LeNet import LeNet
from PIL import Image

# 读取一张本地的样例图片，转变成模型输入的格式
def load_image(img_path):
    # 从img_path中读取图像，并转为灰度图
    im = Image.open(img_path).convert('L')
    #plt.imshow(im,cmap='gray')
    # print(np.array(im))
    im = im.resize((28, 28), Image.Resampling.LANCZOS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    # 图像归一化，保持和数据集的数据范围一致
    im = 1 - im / 255 
    return im

# 加载训练好的模型参数
model = LeNet()
model.load_dict(paddle.load('./model/mnist_model.pdparams'))

# 设置模型为评估模式
model.eval()

# 准备一个MNIST样例图像
example_image = load_image("d:/8.png")

# 转换为Tensor并进行推理
with paddle.no_grad():
    example_tensor = paddle.to_tensor(example_image)
    prediction = model(example_tensor)
    print(prediction)

# 获取预测类别
predicted_class = np.argmax(prediction.numpy(), axis=1)[0]
print(f"Predicted class: {predicted_class}")

说明：先通过执行train.py训练数据集，将模型保存在model文件夹中，
然后运行predicted.py加载训练出来的数据集，推理出d:/8.png图片的结果。
结果图片如下：