本文的代码来自昇思学习平台。
这一个模块主要的部分是构建了一个简单的网络，主要有数据的导入处理，模型的搭建，还有预测测试得出准确率，三个部分。
首先先介绍一下数据集mnist，这里使用的mnist数据集，是由60000张训练图像和10000张测试图像机器标签构成的。数据集的内容主要就是手写的数据。 每一个训练的样本是由1*28*28的像素组成的。
第一块内容，对数据进行预处理，
import mindspore
from mindspore import nn
from mindspore.dataset import vision, transforms
from mindspore.dataset import MnistDataset
# Download data from open datasets
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)
train_dataset = MnistDataset('MNIST_Data/train')
test_dataset = MnistDataset('MNIST_Data/test')
print(train_dataset.get_col_names())这一块主要就是下载数据集然后将数据集存在了train_dataset和test_dataset里面，
最后一行的train_dataset.get_col_names()是用于获取列名称的，嗯如果我们把整个train_dataset看作一个整体，也就是一个dataframe的话，对应的他们的列标签就是
['image', 'label']
def datapipe(dataset, 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 = dataset.map(image_transforms, 'image')
dataset = dataset.map(label_transform, 'label')
dataset = dataset.batch(batch_size)
return dataset
# Map vision transforms and batch dataset
train_dataset = datapipe(train_dataset, 64)
test_dataset = datapipe(test_dataset, 64)这一块的主要就是处理数据，vision.Rescale（）是对整个样本图像的数据都除以255，vison_Normalization()是对其进行归一化处理，均值为0.1307，标准差为0.3081，我们都知道归一化有助于模型更快的收敛。vision.HWC2CHW（）则是对样本的维度的一个转化，原本一个样本的形状是（high*width*channels），这个函数的作用就是将其转化为形状如（channels*high*weigh）的数据,我认为是为了后续进入模型之后更方便展开和运算。
label_transform = transforms.TypeCast(mindspore.int32)
这是一步数据转换的操作，将label转换为int32型的数据，这是用来确保数据类型符合模型的要求的。
接着使用map操作对样本和标签分别进行转化，转化之后再把这些组成批量的形式。对数据进行批处理，有利于提高训练效率，节约训练时间。从后面我们可以看出这里的批的大小是64个样本。
for image, label in test_dataset.create_tuple_iterator():
print(f"Shape of image [N, C, H, W]: {image.shape} {image.dtype}")
print(f"Shape of label: {label.shape} {label.dtype}")
breakShape of image [N, C, H, W]: (64, 1, 28, 28) Float32 Shape of label: (64,) Int32
从这里我们可以看出：image标签下的数据类型是float类型的（64*1*28*28）的数据
for data in test_dataset.create_dict_iterator():
print(f"Shape of image [N, C, H, W]: {data['image'].shape} {data['image'].dtype}")
print(f"Shape of label: {data['label'].shape} {data['label'].dtype}")
breakShape of image [N, C, H, W]: (64, 1, 28, 28) Float32 Shape of label: (64,) Int32
这和上面的一样，只是给出了另一种方法。
接下来就进入到网络构建的部分了。
# Define model
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()
print(model)Network<
(flatten): Flatten<>
(dense_relu_sequential): SequentialCell<
(0): Dense<input_channels=784, output_channels=512, has_bias=True>
(1): ReLU<>
(2): Dense<input_channels=512, output_channels=512, has_bias=True>
(3): ReLU<>
(4): Dense<input_channels=512, output_channels=10, has_bias=True>
>
>
定义了一个类，用于构建网络。这个网络是一个比较基础的全连接网络。主要的结构是：线性层---relu---线性层---relu---线性层。
简单介绍一下线性层，其实这就是对数据进行了一个赋权和增加偏置的操作，y=W*x+b.W是权重矩阵，他的大小是由输入的形状和输出的形状共同决定的，b就是偏置。
relu层则是进行了一种类似于dropout层的操作，都是对网络进行稀疏化处理，丢弃一些数据使得网络更加具有灵活性防止过拟合，relu(x)=max{0,x}.对于防止梯度消失由一定作用。
由于这个网络的第一层就是线性层，线性层对于输入的数据的形状是有要求的，输入时以为的数据，所以在后面的部分还增加了一个flatten函数，是为了展开样本，原本输入的一个样本的形状是1*28*28,转化为1*784.再进入线性层。
# Instantiate loss function and optimizer
loss_fn = nn.CrossEntropyLoss()
optimizer = nn.SGD(model.trainable_params(), 1e-2)
# 1. Define forward function
def forward_fn(data, label):
logits = model(data)
loss = loss_fn(logits, label)
return loss, logits
# 2. Get gradient function
grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
# 3. Define function of one-step training
def train_step(data, label):
(loss, _), grads = grad_fn(data, label)
optimizer(grads)
return loss
def train(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(model, dataset, loss_fn):
num_batches = dataset.get_dataset_size()#获取批次大小
model.set_train(False)#确保这时候处于测试的状态，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#计算平均损失，要/批次数，也就是64这里
correct /= total#正确率，正确个数/批次样本数，很好理解
print(f"Test: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
epochs = 3
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train(model, train_dataset)
test(model, test_dataset, loss_fn)
print("Done!")Epoch 1 ------------------------------- loss: 2.302088 [ 0/938] loss: 2.290692 [100/938] loss: 2.266338 [200/938] loss: 2.205240 [300/938] loss: 1.907198 [400/938] loss: 1.455603 [500/938] loss: 0.861103 [600/938] loss: 0.767219 [700/938] loss: 0.422253 [800/938] loss: 0.513922 [900/938] Test: Accuracy: 83.8%, Avg loss: 0.529534 Epoch 2 ------------------------------- loss: 0.580867 [ 0/938] loss: 0.479347 [100/938] loss: 0.677991 [200/938] loss: 0.550141 [300/938] loss: 0.226565 [400/938] loss: 0.314738 [500/938] loss: 0.298739 [600/938] loss: 0.459540 [700/938] loss: 0.332978 [800/938] loss: 0.406709 [900/938] Test: Accuracy: 90.2%, Avg loss: 0.334828 Epoch 3 ------------------------------- loss: 0.461890 [ 0/938] loss: 0.242303 [100/938] loss: 0.281414 [200/938] loss: 0.207835 [300/938] loss: 0.206000 [400/938] loss: 0.409646 [500/938] loss: 0.193608 [600/938] loss: 0.217575 [700/938] loss: 0.212817 [800/938] loss: 0.202862 [900/938] Test: Accuracy: 91.9%, Avg loss: 0.280962 Done!
这里先介绍一下整个训练过程。一般来说包括了前向传播和反向传播，这是训练模型的部分。
前向传播就是按照网络的结构一层一层的提取特征，最终得出的应该的训练好的特征矩阵。反向传播可以认为是用于优化这个特征矩阵的，反向传播主要利用的就是梯度，这里求梯度的话用到了一个损失函数，损失函数可以认为是计算了最终结果和正确答案的偏差的大小，所以损失函数当然是越小越好。
mindspore.value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False)
非常方便，大模型的好处，一个函数就可以直接实现求梯度！
(loss, _), grads = grad_fn(data, label)
optimizer(grads)
前面的前向传播和求梯度就不介绍了，这里的一步用于根据损失函数求梯度，optimizer（）用于更新梯度，也是非常方便，一行代码。
接着是test部分，测试过程。
测试过程，定义了一个test函数，用于测试。首先
方便起见，我这里直接在代码方便进行了批注。
最后进行三次迭代，三次迭代之后，输出了每一次迭代的结果，观察发现，准确率在上升，损失也在下降。
# Save checkpoint
mindspore.save_checkpoint(model, "model.ckpt")
print("Saved Model to model.ckpt")这只是用来保存模型的,线面的是用来加载模型的，就是将参数加载到实例化的模型里面。
# Instantiate a random initialized model
model = Network()
# Load checkpoint and load parameter to model
param_dict = mindspore.load_checkpoint("model.ckpt")
param_not_load, _ = mindspore.load_param_into_net(model, param_dict)
print(param_not_load)model.set_train(False)
for data, label in test_dataset:
pred = model(data)
predicted = pred.argmax(1)
print(f'Predicted: "{predicted[:10]}", Actual: "{label[:10]}"')
breakPredicted: "Tensor(shape=[10], dtype=Int32, value= [3, 9, 6, 1, 6, 7, 4, 5, 2, 2])", Actual: "Tensor(shape=[10], dtype=Int32, value= [3, 9, 6, 1, 6, 7, 4, 5, 2, 2])"
这一块是测试的部分，在测试集中，用加载好的模型进行测试，最后和标签进行比对，根据最后的结果显示，预测结果和镖旗那是一一对应的，说明在训练集上训练出来的这个模型是比较有效的，在测试集上仍然具有分类的作用。
这篇文章主要就是解释了一下平台的代码和一些自己的理解，都是比较基础浅显的认知（受限于能力），如有错误，欢迎指出哈！
这是第一次课程，我对于软件的使用和写csdn都还比较生疏，这是我的第一篇博客，可能比较粗糙。这次课程给我的感受就是两个字方便，之前我对这方面的学习是根据cs231n课程进行了一些学习，里面主要是手写的（当然也介绍了一些经典的大模型但是我当时没有特别去了解仅仅完成了相关任务），包括前向传播的线性层relu 层计算梯度，反向传播，权重更新，这对于嗯对整个网络的理解是对我有很大帮助的，然后，今天的MindSpore，给我的感觉就是简洁和方便，因为之前嗯接触的很少，所以这一优点对我来说印象很深刻。
扫一扫
649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
