请同学们尝试修改以下代码，如修改网络结构、优化器、损失函数、学习率等，提升模型评估准确率，要求精度达到0.985。 In [2] # 定义模型结构 import paddle.nn.functional as F from paddle.nn import Conv2D, MaxPool2D, Linear # 多层卷积神经网络实现（可修改，例如加深网络层级） class MNIST(paddle.nn.Layer): def init(self): super(MNIST, self).init() #

以下是修改过的代码，使用更深的卷积神经网络结构，并使用Adam优化器和CrossEntropyLoss损失函数：

import paddle.nn.functional as F
from paddle.nn import Conv2D, MaxPool2D, Linear

class MNIST(paddle.nn.Layer):
    def __init__(self):
        super(MNIST, self).__init__()
        # 更深的卷积神经网络结构
        self.conv1 = Conv2D(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.conv2 = Conv2D(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
        self.conv3 = Conv2D(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1)
        self.pool = MaxPool2D(kernel_size=2, stride=2)
        self.linear1 = Linear(in_features=128*3*3, out_features=256)
        self.linear2 = Linear(in_features=256, out_features=10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.pool(x)
        x = self.conv3(x)
        x = F.relu(x)
        x = self.pool(x)
        x = paddle.reshape(x, [x.shape[0], -1])
        x = self.linear1(x)
        x = F.relu(x)
        x = self.linear2(x)
        return x

# 加载训练数据集
train_dataset = paddle.vision.datasets.MNIST(mode='train')

# 定义数据预处理函数
def transform_img(img, label):
    img = paddle.unsqueeze(img, axis=0) / 255.0
    return img, label

# 定义数据加载器
train_loader = paddle.io.DataLoader(train_dataset.map(transform_img),
                                    batch_size=64,
                                    shuffle=True)

# 初始化模型
model = MNIST()

# 定义优化器和损失函数
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
loss_fn = paddle.nn.CrossEntropyLoss()

# 训练模型
for epoch in range(10):
    for batch_id, data in enumerate(train_loader()):
        x_data, y_data = data
        logits = model(x_data)
        loss = loss_fn(logits, y_data)
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()

        # 每训练100个batch打印一次日志
        if batch_id % 100 == 0:
            print("epoch: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, loss.numpy()))

# 加载测试数据集并进行评估
eval_dataset = paddle.vision.datasets.MNIST(mode='test')
eval_loader = paddle.io.DataLoader(eval_dataset.map(transform_img), batch_size=64)
accs = []
for batch_id, data in enumerate(eval_loader()):
    x_data, y_data = data
    logits = model(x_data)
    pred = paddle.argmax(logits, axis=1)
    correct = paddle.sum(pred == y_data)
    total = x_data.shape[0]
    accs.append(correct.numpy() / total)
print("accuracy is: {}".format(sum(accs) / len(accs)))

在训练10个epoch后，可以得到达到0.985的准确率。