分为四步：

构建数据集，定义神经网络模型，定义超参、损失函数及优化器，输入数据集训练评估

1.构建数据集

从数据集 Dataset加载代码，构建数据集

import mindspore

from mindspore import nn

from mindspore.dataset import vision,transforms

from mindspore.dataset impot MnistDataset

from download import download

url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip"

path = download(url, "./", kind="zip", replace=True)

def datapipe(path, batch_size):

    image_transforms = [

        vision.Rescale(1.0/255.0, 0),

        vision.Normalize(mean=(0.1307,), std=(0.3081,)),

        vision.HWC2CHW()

    ]

    label_transform = transforms.TypeCast(mindspore.int32)

    dataset = MnistDataset(path)

    dataset = dataset.map(image_transforms,'image')

    dataset = dataset.map(label_transform,'label')

    dataset = dataset.batch(batch_size)

    return dataset

train_dataset = datapipe('MNIST_Data/train', batch_size=64)

test_dataset = datapipe('MNIST_Data/test', batch_size=64)

2.定义网络模型

从网络构建https://wwww.mindspore.cn/tutorials/zh-CN/r2.3.0rc2/beginner/model.html中加载代码以构建神经网络模型

class Network(nn.Cell):

    def __init__(self):

        super().__init__()

        self.flatten=nn.Flatten()

        self.dense_relu_sequential = nn.SequentialCell(

            nn.Dense(28 * 28, 512)

            nn.ReLU()

            nn.Dense(512, 512)

            nn.ReLU()

            nn.Dense(512, 10)

         )

    def construct(self, x):

        x = self.flatten(x)

        logits = self.dense_relu_sequential(x)

        return logits

model = Network()

3.定义超参、损失函数、优化器

1)超参

指可调整的参数，控制模型训练优化的过程，对模型训练和收敛速度有直接影响.

当前深度学习模型多采用批量随机梯度下降算法优化，其原理为

$w_{t+1} = w_{t} - \eta \frac{1}{n}\sum\limits_{x \in B}\abla l(x, w_{t})$

n为批量大小，$\eta$为学习率,w为各轮训练的权重参数，$\abla l$为损失函数导数。它们对模型训练的影响有：

批次过小，花费时间多，梯度震荡严重，不利于收敛；批次过大，不同批次梯度方向没有变化，容易陷入局部极小值。合适的批次大小可以提高模型精度全局收敛。

学习率偏小则收敛速度慢，过大则导致不收敛等不可预测的结果。

梯度学习法可多次迭代，每一步中最小化损失函数来预估模型参数。学习率在迭代过程中控制模型的学习速度。

epochs = 3

batch_size = 64

learning_rate = 1e-2

2）损失函数

用于评估模型预测值(logits)与目标值(targets)之间的误差。训练模型时，随机初始化的神经网络模型开始时会预测出错误结果。损失函数会评估预测结果与目标值相异程度，模型训练目标即为降低损失函数求得的误差。

常见的有回归任务nn.MSELoss(均方误差),分类nn.NLLLoss(负对数似然).nn.CrossEntropyLoss结合了nn.LogSoftmax与nn.NLLLoss对logits进行归一化并计算预测误差。

loss_fn = nn.CrossEntropyLoss()

3）优化器

模型优化是在每个训练步骤中调整模型参数减小模型误差的过程。Mindspore提供多种优化算法的实现，称之为优化器。内部定义模型参数优化过程(梯度如何更新到模型参数),所有优化逻辑封装在优化器中。此处使用SGD优化器(Stochastic Gradient Desent)

可通过model.trainable_params()获得模型可训练参数，并传入学习率超参初始化优化器。

optimizer  = nn.SGD(model.trainable_params(), learning_rate = learning_rate)

在训练中如下使用:

grads = grad_fn(inputs)

optimizer(grads)

4.训练与评估

可以循环输入数据训练模型，一次数据集的完整迭代称为一轮.每轮包括训练与验证两个步骤，训练时迭代训练数据集并尝试收敛到最佳参数，验证时则迭代测试数据集，检查模型性能是否提升.

def forward_fn(data, label):

    logits = model(data)

    loss = loss_fn(logits, label)

    return loss, logits

grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters(), has_aux = True)

def train_step(data, label):

    (loss, _), grads = grad_fn(data, label)

    optimizer(grads)

    return loss

def train_loop(model, dataset):

    size = dataset.get_dataset_size()

    model.set_train()

    for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):

       loss = train_step(data, label)

       if batch % 100 == 0:

            loss, current = loss.asnumpy(), batch

            print(f"loss:{loss:>7f} [{current:>3d}/{size:>3d}]")

def test_loop(model, dataset, loss_fn):

    num_batches = dataset.get_dataset_size()

    model.set_train(False)

    total, test_loss, correct = 0, 0, 0

    for data, label in dataset.create_tuple_iterator():

        pred = model(data)

        total += len(data)

        test_loss += loss_fn(pred, label).asnumpy()

        correct += (pred.argmax(1) == label).asnumpy().sum()

    test_loss /= num_batches

    correct /= total

    print(f"Test::\n Accuracy:{(100 * correct ):>0.1f}%, Avg loss:{test_loss >:8f} \n")

 loss_fn = nn.CrossEntropyLoss()

optimizer = nn.SGD(model.trainable_params(), learning_rate = learning_rate)

for t in range(epochs):

    print(f"Epoch {t + 1}\n------------------------------------")

    train_loop(model, train_dataset)

    test_loop(model, test_dataset, loss_fn)

print("Done!")