MindSpore储存与载入实体模型

文中关键从工程项目完成的视角检测了一下MindSpore的深度学习实体模型储存与载入的作用，根据这一作用，我们可以将自身训炼好的深度学习实体模型公布出来 供大量的人应用，大家还可以立即应用他人在更强的硬件配置管理体系上训炼好的实体模型，或是运用于迁移学习。

技术性情况

近些年在深度学习和传统式优化算法的融合中，慢慢发展趋势出了一种Search To Optimization的逻辑思维，致力于根据结构一个特殊的深度学习实体模型，来取代传统式优化算法中的检索全过程，从而加快經典图论等难题的求得。那麼这里边就牵涉到一个十分重要的工程项目流程：把深度学习中训炼出去的实体模型储存成一个文档或是数据库查询，促使别人能够 反复的应用这一早已训炼出去的实体模型。乃至是能够 公布云端，根据API插口开展启用。那麼文中的內容便是详细介绍给与MindSpore的实体模型储存与载入，官方网文本文档能够 参照这一连接。

储存实体模型

这儿大家应用的实体模型来自于这篇blog，是一个十分基本的线形神经元网络实体模型，用以线性拟合一个给出的涵数。由于这儿我们都是根据线形的实体模型，因而在我们必须去线性拟合一个更为高级的涵数得话，必须手动式的解决，例如这儿大家应用的平方米涵数。汇总起來该实体模型能够 抽象性为：

\[f(x)=ax^2 b
\]

而这儿造成训练集时，我们都是加了一个任意的噪音，也就是：

\[D(x)=ax^2 b noise
\]

详细的编码以下所显示：

# save_model.py

from mindspore import context
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
import numpy as np
from mindspore import dataset as ds
from mindspore import nn, Tensor, Model
import time
from mindspore.train.callback import Callback, LossMonitor, ModelCheckpoint

def get_data(num, a=2.0, b=3.0):
    for _ in range(num):
        x = np.random.uniform(-1.0, 1.0)
        noise = np.random.normal(0, 0.03)
        z = a * x ** 2   b   noise
        # 回到数据信息的情况下就回到数据信息的平方米
        yield np.array([x**2]).astype(np.float32), np.array([z]).astype(np.float32)

def create_dataset(num_data, batch_size=16, repeat_size=1):
    input_data = ds.GeneratorDataset(list(get_data(num_data)), column_names=['x','z'])
    input_data = input_data.batch(batch_size)
    input_data = input_data.repeat(repeat_size)
    return input_data

data_number = 1600 # 一共造成1600组数据信息
batch_number = 16 # 分成16组各自开展提升
repeat_number = 2 # 反复2次，能够 得到更低的损失函数值

ds_train = create_dataset(data_number, batch_size=batch_number, repeat_size=repeat_number)

class LinearNet(nn.Cell):
    def __init__(self):
        super(LinearNet, self).__init__()
        self.fc = nn.Dense(1, 1, 0.02, 0.02)

    def construct(self, x):
        x = self.fc(x)
        return x

net = LinearNet()
model_params = net.trainable_params()
print ('Param Shape is: {}'.format(len(model_params)))
for net_param in net.trainable_params():
    print(net_param, net_param.asnumpy())
net_loss = nn.loss.MSELoss()

# 设置蚁群算法，常见的是Momentum和ADAM
optim = nn.Momentum(net.trainable_params(), learning_rate=0.005, momentum=0.9)
model = Model(net, net_loss, optim)
ckpt_cb = ModelCheckpoint()

epoch = 1
# 设置每八个batch训炼进行后就广播一次，这儿一共广播25次
model.train(epoch, ds_train, callbacks=[LossMonitor(16), ckpt_cb], dataset_sink_mode=False)

for net_param in net.trainable_params():
    print(net_param, net_param.asnumpy())

最终是根据ModelCheckpoint这一方式 将训炼出去的实体模型储存成.ckpt的checkpoint格式文件。以上代码执行的結果以下：

dechin@ubuntu2004:~/projects/gitlab/dechin/src/mindspore$ sudo docker run --rm -v /dev/shm:/dev/shm -v /home/dechin/projects/gitlab/dechin/src/mindspore/:/home/ --runtime=nvidia --privileged=true swr.cn-south-1.myhuaweicloud.com/mindspore/mindspore-gpu:1.2.0 /bin/bash -c "cd /home && python save_model.py"
Param Shape is: 2
Parameter (name=fc.weight, shape=(1, 1), dtype=Float32, requires_grad=True) [[0.02]]
Parameter (name=fc.bias, shape=(1,), dtype=Float32, requires_grad=True) [0.02]
epoch: 1 step: 16, loss is 0.9980968
epoch: 1 step: 32, loss is 0.3894167
epoch: 1 step: 48, loss is 0.090543285
epoch: 1 step: 64, loss is 0.060300454
epoch: 1 step: 80, loss is 0.014248277
epoch: 1 step: 96, loss is 0.015697923
epoch: 1 step: 112, loss is 0.014582128
epoch: 1 step: 128, loss is 0.008066677
epoch: 1 step: 144, loss is 0.007225203
epoch: 1 step: 160, loss is 0.0046849623
epoch: 1 step: 176, loss is 0.006007362
epoch: 1 step: 192, loss is 0.004276552
Parameter (name=fc.weight, shape=(1, 1), dtype=Float32, requires_grad=True) [[1.8259585]]
Parameter (name=fc.bias, shape=(1,), dtype=Float32, requires_grad=True) [3.0577476]

可能是因为数据的难题，可能是因为噪音的难题，促使大家训炼出去的主要参数跟大家最初所界定的主要参数有一丝的差别，可是实际的误差范畴还得根据检测集来认证。运作完毕之后在文件列表下转化成一系列的.ckpt文档和一个.meta的计算图文档：

dechin@ubuntu2004:~/projects/gitlab/dechin/src/mindspore$ ll
total 148
drwxr-xr-x 2 1000 1000  4096 May 16 13:25 ./
drwxr-xr-x 1 root root  4096 May 15 01:55 ../
-r-------- 1 root root   211 May 16 13:25 CKP-1_196.ckpt
-r-------- 1 root root   211 May 16 13:25 CKP-1_197.ckpt
-r-------- 1 root root   211 May 16 13:25 CKP-1_198.ckpt
-r-------- 1 root root   211 May 16 13:25 CKP-1_199.ckpt
-r-------- 1 root root   211 May 16 13:25 CKP-1_200.ckpt
-r-------- 1 root root  3705 May 16 13:25 CKP-graph.meta
-rw-r--r-- 1 1000 1000  2087 May 16 13:25 save_model.py

下面就可以逐渐载入这种文档中所得出的实体模型，用以检测集的认证。

载入实体模型

在实体模型的加载中，大家仍然或是必须初始的神经元网络目标LinearNet，

# load_model.py

from mindspore import context
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
import mindspore.dataset as ds
from mindspore import load_checkpoint, load_param_into_net
from mindspore import nn, Tensor, Model
import numpy as np

class LinearNet(nn.Cell):
    def __init__(self):
        super(LinearNet, self).__init__()
        self.fc = nn.Dense(1,1,0.02,0.02)

    def construct(self, x):
        print ('x:', x)
        x = self.fc(x)
        print ('z:', x)
        return x

net = LinearNet()
param_dict = load_checkpoint("CKP-1_200.ckpt")
load_param_into_net(net, param_dict)

net_loss = nn.loss.MSELoss()
model = Model(net, net_loss, metrics={"accuracy"})

data = {'x':np.array([[0.01],[0.25],[1],[4],[9]]).astype(np.float32),
        'z':np.array([3.02,3.5,5,11,21]).astype(np.float32)}
dataset = ds.NumpySlicesDataset(data=data)
dataset = dataset.batch(1)

acc = model.eval(dataset, dataset_sink_mode=False)

这儿大家仅仅界定了一个比较简单的检测集，在具体情景中通常检测集也是十分很多的数据信息。这儿为了更好地简单化当地自然环境，应用的是Docker的程序编写自然环境，而且在Docker器皿的拉上中应用了--rm选择项，在运作完毕后会删掉这一器皿，保证自然环境的干净整洁。有关在Docker器皿自然环境下安裝和布署MindSpore的计划方案，能够 参照这篇CPU布署blog，及其这篇GPU布署blog。以上编码的实行結果以下：

dechin@ubuntu2004:~/projects/gitlab/dechin/src/mindspore$ sudo docker run --rm -v /dev/shm:/dev/shm -v /home/dechin/projects/gitlab/dechin/src/mindspore/:/home/ --runtime=nvidia --privileged=true swr.cn-south-1.myhuaweicloud.com/mindspore/mindspore-gpu:1.2.0 /bin/bash -c "cd /home && python load_model.py"
x:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 9.00000000e 00]])
z:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 1.94898682e 01]])
x:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 2.50000000e-01]])
z:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 3.52294850e 00]])
x:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 9.99999978e-03]])
z:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 3.08499861e 00]])
x:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 1.00000000e 00]])
z:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 4.89154148e 00]])
x:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 4.00000000e 00]])
z:
Tensor(shape=[1, 1], dtype=Float32, value=
[[ 1.03659143e 01]])

从这一結果中我们可以见到，因为在训炼集中化大家应用的数据信息集中化在较为小的范畴，因而在检测这一范畴外的数据信息时，误差相比于这一地区内的数据信息点会更高一些，这也是归属于一切正常的状况。

汇总概述

文中关键从工程项目完成的视角检测了一下MindSpore的深度学习实体模型储存与载入的作用，根据这一作用，我们可以将自身训炼好的深度学习实体模型公布出来 供大量的人应用，大家还可以立即应用他人在更强的硬件配置管理体系上训炼好的实体模型，或是运用于迁移学习。

版权声明

文中先发连接为：https://www.cnblogs.com/dechinphy/p/sl.html
创作者ID：DechinPhy
大量原著小说文章内容请参照：https://www.cnblogs.com/dechinphy/