基于mindspore平台，利用MNIST数据集，实现经典的Lenet-5模型，同时加以改变构建自己的卷积模型，以分类的准确度和混淆矩阵为衡量指标，分析两个模型的分类精度。

好的，你的问题是如何基于mindspore平台，利用MNIST数据集，实现经典的Lenet-5模型，并分析两个模型的分类精度和混淆矩阵。我可以为你提供一些指导。

首先，你可以使用MindSpore框架编写代码实现经典的Lenet-5模型。Lenet-5模型是一个由卷积层、池化层和全连接层组成的神经网络。你可以根据下面的代码来实现Lenet-5模型：

import mindspore.nn as nn
import mindspore.ops.operations as P

class LeNet5(nn.Cell):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, pad_mode='valid')
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1, pad_mode='valid')
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Dense(in_channels=16 * 5 * 5, out_channels=120)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Dense(in_channels=120, out_channels=84)
        self.relu4 = nn.ReLU()
        self.fc3 = nn.Dense(in_channels=84, out_channels=10)

    def construct(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = P.Reshape()(x, (x.shape[0], -1))
        x = self.relu3(self.fc1(x))
        x = self.relu4(self.fc2(x))
        x = self.fc3(x)
        return x

接下来，你可以使用MNIST数据集来训练和测试上面的Lenet-5模型。你可以使用MindSpore框架提供的MNIST数据集接口来加载MNIST数据集。下面是一个使用MNIST数据集进行训练和测试的示例代码：

import mindspore.dataset as ds
import mindspore.dataset.vision.c_transforms as C
import mindspore.dataset.vision.py_transforms as T
from mindspore import Model
from mindspore import load_checkpoint, save_checkpoint
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
from mindspore import nn, context

# 定义数据集路径
mnist_path = "./MNIST_Data"

# 数据集预处理
mnist_ds = ds.MnistDataset(mnist_path, shuffle=False)
mnist_ds = mnist_ds.map(input_columns="image", operations=C.Resize((32, 32)))
mnist_ds = mnist_ds.map(input_columns="image", operations=T.Normalize(mean=(0.1307,), std=(0.3081,)))
mnist_ds = mnist_ds.map(input_columns="image", operations=T.ToTensor())
mnist_ds = mnist_ds.batch(batch_size=32, drop_remainder=True)

# 创建模型
network = LeNet5()

# 定义损失函数
criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')

# 定义优化器
optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)

# 定义模型
model = Model(network, loss_fn=criterion, optimizer=optimizer)

# 训练模型
model.train(epoch=10, train_dataset=mnist_ds, callbacks=[LossMonitor(100)])

# 保存模型
save_checkpoint(network, "lenet-5.ckpt")

# 加载模型
network = LeNet5()
load_checkpoint("lenet-5.ckpt", net=network)

# 测试模型
mnist_ds_test = ds.MnistDataset(mnist_path, shuffle=False)
mnist_ds_test = mnist_ds_test.map(input_columns="image", operations=C.Resize((32, 32)))
mnist_ds_test = mnist_ds_test.map(input_columns="image", operations=T.Normalize(mean=(0.1307,), std=(0.3081,)))
mnist_ds_test = mnist_ds_test.map(input_columns="image", operations=T.ToTensor())
mnist_ds_test = mnist_ds_test.batch(batch_size=32, drop_remainder=True)
acc = model.eval(mnist_ds_test, dataset_sink_mode=False)

最后，你可以尝试构建自己的卷积模型，并使用MNIST数据集来训练和测试。你可以根据自己的需求设计卷积层、池化层和全连接层等。在训练和测试过程中，你可以使用分类的准确度和混淆矩阵来衡量模型的性能。你可以使用MindSpore框架提供的相关API来计算分类的准确度和混淆矩阵。