技术背景

在前面的几篇博客中，我们分别介绍了MindSpore的CPU版本在Docker下的安装与配置方案、MindSpore的线性函数拟合以及MindSpore后来新推出的GPU版本的Docker编程环境解决方案。这里我们在线性拟合的基础上，再介绍一下MindSpore中使用线性神经网络来拟合多变量非线性函数的解决方案。

环境配置

在按照这篇博客中的方法进行安装和配置之后，可以在本地的docker镜像仓库中找到一个mindspore的镜像：

  1. [dechin-manjaro gitlab]# docker images
  2. REPOSITORY                                                 TAG                  IMAGE ID
  3. mindspore                                                  latest               3a6951d9b900

由于运行Docker容器的时候最好是可以绑定本地的一个目录，所以可以用pwd先看一下本地的执行目录：

  1. [dechin@dechin-manjaro mindspore]$ pwd
  2. /home/dechin/projects/2021-python/mindspore

然后可以根据上述的名称和路径信息，创建一个新的docker容器环境：

  1. [dechin-manjaro mindspore]# docker run -it --rm -v /home/dechin/projects/2021-python/mindspore:/home mindspore

这里运行的时候加了--rm选项，表示关闭容器后就删除容器，是一个一次性容器的选项。如果不加这个选项的话，会在docker ps -a下看到众多的被保存下来的容器环境，这会浪费不必要的资源。因此如果不对环境进行变更的话，建议还是加上--rm选项。

非线性函数拟合

在前面这篇博客中我们所拟合的是一个简单的线性函数：

\[y=ax+b
\]

那么在这里我们先考虑一个最简单的非线性函数的场景：

\[y=ax^2+b
\]

同样的还是两个参数，需要注意的是，如果要用线性神经网络来拟合非线性的函数，那么在给出参数的时候就要给出非线性的入参，以下是完整的代码（如果需要展示结果更好看的话可以参考上面提到的线性函数拟合的博客，这里我们为了提速，删除了很多非比要的模块）：

  1. # test_nonlinear.py
  3. from mindspore import context
  4. context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
  5. import numpy as np
  6. from mindspore import dataset as ds
  7. from mindspore import nn, Tensor, Model
  8. import time
  9. from mindspore.train.callback import Callback, LossMonitor
  11. def get_data(num, a=2.0, b=3.0):
  12.     for _ in range(num):
  13.         x = np.random.uniform(-1.0, 1.0)
  14.         noise = np.random.normal(0, 0.03)
  15.         z = a * x ** 2 + b + noise
  16.         # 返回数据的时候就返回数据的平方
  17.         yield np.array([x**2]).astype(np.float32), np.array([z]).astype(np.float32)
  19. def create_dataset(num_data, batch_size=16, repeat_size=1):
  20.     input_data = ds.GeneratorDataset(list(get_data(num_data)), column_names=['x','z'])
  21.     input_data = input_data.batch(batch_size)
  22.     input_data = input_data.repeat(repeat_size)
  23.     return input_data
  25. data_number = 1600 # 一共产生1600组数据
  26. batch_number = 16 # 分为16组分别进行优化
  27. repeat_number = 2 # 重复2次，可以取到更低的损失函数值
  29. ds_train = create_dataset(data_number, batch_size=batch_number, repeat_size=repeat_number)
  30. dict_datasets = next(ds_train.create_dict_iterator())
  32. class LinearNet(nn.Cell):
  33.     def __init__(self):
  34.         super(LinearNet, self).__init__()
  35.         self.fc = nn.Dense(1, 1, 0.02, 0.02)
  37.     def construct(self, x):
  38.         x = self.fc(x)
  39.         return x
  41. net = LinearNet()
  42. model_params = net.trainable_params()
  43. print ('Param Shape is: {}'.format(len(model_params)))
  44. for net_param in net.trainable_params():
  45.     print(net_param, net_param.asnumpy())
  46. net_loss = nn.loss.MSELoss()
  48. # 设定优化算法，常用的是Momentum和ADAM
  49. optim = nn.Momentum(net.trainable_params(), learning_rate=0.005, momentum=0.9)
  50. model = Model(net, net_loss, optim)
  52. epoch = 1
  53. # 设定每8个batch训练完成后就播报一次，这里一共播报25次
  54. model.train(epoch, ds_train, callbacks=[LossMonitor(8)], dataset_sink_mode=False)
  56. for net_param in net.trainable_params():
  57.     print(net_param, net_param.asnumpy())

在容器内直接用python来运行这个代码：

  1. root@9f9358769573:/home# python test_nonlinear.py
  2. WARNING: 'ControlDepend' is deprecated from version 1.1 and will be removed in a future version, use 'Depend' instead.
  3. [WARNING] ME(818:140122680680576,MainProcess):2021-05-15-01:59:46.275.616 [mindspore/ops/operations/array_ops.py:2302] WARN_DEPRECATED: The usage of Pack is deprecated. Please use Stack.
  4. Param Shape is: 2
  5. Parameter (name=fc.weight) [[0.02]]
  6. Parameter (name=fc.bias) [0.02]
  7. epoch: 1 step: 8, loss is 7.727301
  8. epoch: 1 step: 16, loss is 0.9204254
  9. epoch: 1 step: 24, loss is 0.051439833
  10. epoch: 1 step: 32, loss is 0.40419307
  11. epoch: 1 step: 40, loss is 0.24850279
  12. epoch: 1 step: 48, loss is 0.0988866
  13. epoch: 1 step: 56, loss is 0.0244435
  14. epoch: 1 step: 64, loss is 0.05162067
  15. epoch: 1 step: 72, loss is 0.043285627
  16. epoch: 1 step: 80, loss is 0.013224524
  17. epoch: 1 step: 88, loss is 0.014601769
  18. epoch: 1 step: 96, loss is 0.0086541185
  19. epoch: 1 step: 104, loss is 0.014336493
  20. epoch: 1 step: 112, loss is 0.007790237
  21. epoch: 1 step: 120, loss is 0.007644728
  22. epoch: 1 step: 128, loss is 0.0090831155
  23. epoch: 1 step: 136, loss is 0.009039238
  24. epoch: 1 step: 144, loss is 0.0061546825
  25. epoch: 1 step: 152, loss is 0.006427808
  26. epoch: 1 step: 160, loss is 0.004290967
  27. epoch: 1 step: 168, loss is 0.003127655
  28. epoch: 1 step: 176, loss is 0.0044714734
  29. epoch: 1 step: 184, loss is 0.003788504
  30. epoch: 1 step: 192, loss is 0.0025329243
  31. epoch: 1 step: 200, loss is 0.0034840193
  32. Parameter (name=fc.weight) [[1.8488435]]
  33. Parameter (name=fc.bias) [3.0522664]

最后优化的结果为\(f(x)=1.8488435x+3.0522664\)，可以看到距离我们所预期的\(f(x)=2x+3\)已经是非常接近的，但是最后具体能训练到多少的精度，其实很大程度上跟训练集有关，这里因为训练集的范围取的比较小，可能会有一定的影响。

多变量函数拟合

不论是前面提到的线性函数拟合的场景，或者是上一个章节中单变量非线性函数的拟合，其实都只有1个输入参数，本章节介绍的场景有2个入参，这里我们要拟合的函数模型是：

\[z(x,y)=ax^2+by^3+c
\]

以下是完整的代码实例：

  1. # test_nonlinear.py
  3. from mindspore import context
  4. context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
  5. import numpy as np
  6. from mindspore import dataset as ds
  7. from mindspore import nn, Tensor, Model
  8. import time
  9. from mindspore.train.callback import Callback, LossMonitor
  11. def get_data(num, a=2.0, b=3.0, c=5.0):
  12.     for _ in range(num):
  13.         x = np.random.uniform(-1.0, 1.0)
  14.         y = np.random.uniform(-1.0, 1.0)
  15.         noise = np.random.normal(0, 0.03)
  16.         z = a * x ** 2 + b * y ** 3 + c + noise
  17.         # 返回参数的时候压缩在一个数组内
  18.         yield np.array([x**2,y**3]).astype(np.float32), np.array([z]).astype(np.float32)
  20. def create_dataset(num_data, batch_size=16, repeat_size=1):
  21.     input_data = ds.GeneratorDataset(list(get_data(num_data)), column_names=['x','z'])
  22.     input_data = input_data.batch(batch_size)
  23.     input_data = input_data.repeat(repeat_size)
  24.     return input_data
  26. data_number = 1600
  27. batch_number = 16
  28. repeat_number = 2
  30. ds_train = create_dataset(data_number, batch_size=batch_number, repeat_size=repeat_number)
  31. dict_datasets = next(ds_train.create_dict_iterator())
  33. class LinearNet(nn.Cell):
  34.     def __init__(self):
  35.         super(LinearNet, self).__init__()
  36.         # 神经网络的input和output维度设置为2,1
  37.         self.fc = nn.Dense(2, 1, 0.02, 0.02)
  39.     def construct(self, x):
  40.         x = self.fc(x)
  41.         return x
  43. net = LinearNet()
  44. model_params = net.trainable_params()
  45. print ('Param Shape is: {}'.format(len(model_params)))
  46. for net_param in net.trainable_params():
  47.     print(net_param, net_param.asnumpy())
  48. net_loss = nn.loss.MSELoss()
  50. optim = nn.Momentum(net.trainable_params(), learning_rate=0.005, momentum=0.9)
  51. model = Model(net, net_loss, optim)
  53. epoch = 1
  54. model.train(epoch, ds_train, callbacks=[LossMonitor(8)], dataset_sink_mode=False)
  56. for net_param in net.trainable_params():
  57.     print(net_param, net_param.asnumpy())

然后用同样的方法来运行：

  1. root@9f9358769573:/home# python test_nonlinear.py
  2. WARNING: 'ControlDepend' is deprecated from version 1.1 and will be removed in a future version, use 'Depend' instead.
  3. [WARNING] ME(1256:140024122265728,MainProcess):2021-05-15-02:03:11.597.713 [mindspore/ops/operations/array_ops.py:2302] WARN_DEPRECATED: The usage of Pack is deprecated. Please use Stack.
  4. Param Shape is: 2
  5. Parameter (name=fc.weight) [[0.02 0.02]]
  6. Parameter (name=fc.bias) [0.02]
  7. epoch: 1 step: 8, loss is 23.713902
  8. epoch: 1 step: 16, loss is 4.097528
  9. epoch: 1 step: 24, loss is 0.6977275
  10. epoch: 1 step: 32, loss is 1.6294805
  11. epoch: 1 step: 40, loss is 1.6045574
  12. epoch: 1 step: 48, loss is 0.33872497
  13. epoch: 1 step: 56, loss is 0.2145875
  14. epoch: 1 step: 64, loss is 0.15970881
  15. epoch: 1 step: 72, loss is 0.18631926
  16. epoch: 1 step: 80, loss is 0.093276486
  17. epoch: 1 step: 88, loss is 0.030935105
  18. epoch: 1 step: 96, loss is 0.065783374
  19. epoch: 1 step: 104, loss is 0.036098357
  20. epoch: 1 step: 112, loss is 0.021177795
  21. epoch: 1 step: 120, loss is 0.022446468
  22. epoch: 1 step: 128, loss is 0.024930779
  23. epoch: 1 step: 136, loss is 0.025752623
  24. epoch: 1 step: 144, loss is 0.019025242
  25. epoch: 1 step: 152, loss is 0.012783089
  26. epoch: 1 step: 160, loss is 0.008119936
  27. epoch: 1 step: 168, loss is 0.010284519
  28. epoch: 1 step: 176, loss is 0.0034211911
  29. epoch: 1 step: 184, loss is 0.003315867
  30. epoch: 1 step: 192, loss is 0.0035076286
  31. epoch: 1 step: 200, loss is 0.0032196175
  32. Parameter (name=fc.weight) [[1.9629341 2.9065483]]
  33. Parameter (name=fc.bias) [5.004186]

这里得到的结果\(z(x,y)=1.9629341x^2+2.9065483y^3+5.004186\)跟我们所预期的结果\(z(x,y)=2x^2+3y^3+5\)也是非常接近的。

其他的函数类型

使用上一章节中所介绍的方法，不仅可以拟合多参数、多幂次的函数，同样的可以拟合一些其他的初等函数，比如：

\[z(x,y)=ax^2+b\ sin(y)+c
\]

完整的代码如下所示：

  1. # test_nonlinear.py
  3. from mindspore import context
  4. context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
  5. import numpy as np
  6. from mindspore import dataset as ds
  7. from mindspore import nn, Tensor, Model
  8. import time
  9. from mindspore.train.callback import Callback, LossMonitor
  11. def get_data(num, a=4.0, b=2.0, c=7.0):
  12.     for _ in range(num):
  13.         x = np.random.uniform(-1.0, 1.0)
  14.         y = np.random.uniform(-1.0, 1.0)
  15.         noise = np.random.normal(0, 0.03)
  16.         z = a * x ** 2 + b * np.sin(y) + c + noise
  17.         yield np.array([x**2,np.sin(y)]).astype(np.float32), np.array([z]).astype(np.float32)
  19. def create_dataset(num_data, batch_size=16, repeat_size=1):
  20.     input_data = ds.GeneratorDataset(list(get_data(num_data)), column_names=['x','z'])
  21.     input_data = input_data.batch(batch_size)
  22.     input_data = input_data.repeat(repeat_size)
  23.     return input_data
  25. data_number = 1600
  26. batch_number = 16
  27. repeat_number = 2
  29. ds_train = create_dataset(data_number, batch_size=batch_number, repeat_size=repeat_number)
  30. dict_datasets = next(ds_train.create_dict_iterator())
  32. class LinearNet(nn.Cell):
  33.     def __init__(self):
  34.         super(LinearNet, self).__init__()
  35.         self.fc = nn.Dense(2, 1, 0.02, 0.02)
  37.     def construct(self, x):
  38.         x = self.fc(x)
  39.         return x
  41. net = LinearNet()
  42. model_params = net.trainable_params()
  43. print ('Param Shape is: {}'.format(len(model_params)))
  44. for net_param in net.trainable_params():
  45.     print(net_param, net_param.asnumpy())
  46. net_loss = nn.loss.MSELoss()
  48. optim = nn.Momentum(net.trainable_params(), learning_rate=0.005, momentum=0.9)
  49. model = Model(net, net_loss, optim)
  51. epoch = 1
  52. model.train(epoch, ds_train, callbacks=[LossMonitor(8)], dataset_sink_mode=False)
  54. for net_param in net.trainable_params():
  55.     print(net_param, net_param.asnumpy())

还是同样的执行方法：

  1. root@9f9358769573:/home# python test_nonlinear.py
  2. WARNING: 'ControlDepend' is deprecated from version 1.1 and will be removed in a future version, use 'Depend' instead.
  3. [WARNING] ME(2132:139783326998656,MainProcess):2021-05-15-02:07:23.220.797 [mindspore/ops/operations/array_ops.py:2302] WARN_DEPRECATED: The usage of Pack is deprecated. Please use Stack.
  4. Param Shape is: 2
  5. Parameter (name=fc.weight) [[0.02 0.02]]
  6. Parameter (name=fc.bias) [0.02]
  7. epoch: 1 step: 8, loss is 33.49754
  8. epoch: 1 step: 16, loss is 5.38931
  9. epoch: 1 step: 24, loss is 0.6019592
  10. epoch: 1 step: 32, loss is 2.3307486
  11. epoch: 1 step: 40, loss is 1.4274476
  12. epoch: 1 step: 48, loss is 0.48646024
  13. epoch: 1 step: 56, loss is 0.15924525
  14. epoch: 1 step: 64, loss is 0.20410316
  15. epoch: 1 step: 72, loss is 0.21361557
  16. epoch: 1 step: 80, loss is 0.09532051
  17. epoch: 1 step: 88, loss is 0.06947755
  18. epoch: 1 step: 96, loss is 0.05294941
  19. epoch: 1 step: 104, loss is 0.04545658
  20. epoch: 1 step: 112, loss is 0.032882713
  21. epoch: 1 step: 120, loss is 0.04866419
  22. epoch: 1 step: 128, loss is 0.033258867
  23. epoch: 1 step: 136, loss is 0.023843747
  24. epoch: 1 step: 144, loss is 0.024475154
  25. epoch: 1 step: 152, loss is 0.015055884
  26. epoch: 1 step: 160, loss is 0.016890783
  27. epoch: 1 step: 168, loss is 0.019164825
  28. epoch: 1 step: 176, loss is 0.014314213
  29. epoch: 1 step: 184, loss is 0.010082506
  30. epoch: 1 step: 192, loss is 0.009690857
  31. epoch: 1 step: 200, loss is 0.008122671
  32. Parameter (name=fc.weight) [[3.6814337 1.9820771]]
  33. Parameter (name=fc.bias) [7.106203]

得到的结果是\(z(x,y)=3.6814337x^2+1.9820771sin(y)+7.106203\)，而我们所预期的结果为：\(z(x,y)=4x^2+2sin(y)+7\)。

总结概要

基于前面所介绍的MindSpore框架使用线性神经网络来拟合线性函数的一个方案，这里我们将其推广到多参数、多幂次的函数，甚至是一些初等的函数。但是对于更加复杂的嵌套函数，可能还要思考一下更加普适的解决方案。

版权声明

本文首发链接为：https://www.cnblogs.com/dechinphy/p/nonlinear.html

作者ID：DechinPhy

更多原著文章请参考：https://www.cnblogs.com/dechinphy/

使用MindSpore的线性神经网络拟合非线性函数的更多相关文章

  1. tensorflow神经网络拟合非线性函数与操作指南

    本实验通过建立一个含有两个隐含层的BP神经网络,拟合具有二次函数非线性关系的方程,并通过可视化展现学习到的拟合曲线,同时随机给定输入值,输出预测值,最后给出一些关键的提示. 源代码如下: # -*- ...

  2. 最小二乘法拟合非线性函数及其Matlab/Excel 实现（转）

    1.最小二乘原理 Matlab直接实现最小二乘法的示例: close x = 1:1:100; a = -1.5; b = -10; y = a*log(x)+b; yrand = y + 0.5*r ...

  3. 最小二乘法拟合非线性函数及其Matlab/Excel 实现

    1.最小二乘原理 Matlab直接实现最小二乘法的示例: close x = 1:1:100; a = -1.5; b = -10; y = a*log(x)+b; yrand = y + 0.5*r ...

  4. BP神经网络拟合给定函数

    近期在准备美赛,因为比赛需要故重新安装了matlab,在里面想尝试一下神将网络工具箱.就找了一个看起来还挺赏心悦目的函数例子练练手: y=1+sin(1+pi*x/4) 针对这个函数,我们首先画出其在 ...

  5. MATLAB神经网络（2） BP神经网络的非线性系统建模——非线性函数拟合

    2.1 案例背景 在工程应用中经常会遇到一些复杂的非线性系统,这些系统状态方程复杂,难以用数学方法准确建模.在这种情况下,可以建立BP神经网络表达这些非线性系统.该方法把未知系统看成是一个黑箱,首先用 ...

  6. MATLAB神经网络（3） 遗传算法优化BP神经网络——非线性函数拟合

    3.1 案例背景 遗传算法(Genetic Algorithms)是一种模拟自然界遗传机制和生物进化论而形成的一种并行随机搜索最优化方法. 其基本要素包括:染色体编码方法.适应度函数.遗传操作和运行参 ...

  7. 『TensorFlow』第二弹_线性拟合&神经网络拟合_恰是故人归

    Step1: 目标: 使用线性模拟器模拟指定的直线:y = 0.1*x + 0.3 代码: import tensorflow as tf import numpy as np import matp ...

  8. 非线性函数的最小二乘拟合及在Jupyter notebook中输入公式 [原创]

    突然有个想法,能否通过学习一阶RC电路的阶跃响应得到RC电路的结构特征——时间常数τ(即R*C).回答无疑是肯定的,但问题是怎样通过最小二乘法.正规方程,以更多的采样点数来降低信号采集噪声对τ估计值的 ...

  9. MATLAB神经网络（7） RBF网络的回归——非线性函数回归的实现

    7.1 案例背景 7.1.1 RBF神经网络概述 径向基函数是多维空间插值的传统技术,RBF神经网络属于前向神经网络类型,网络的结构与多层前向网络类似,是一种三层的前向网络.第一层为输入层,由信号源结 ...

随机推荐

  1. CSS浮动布局带来的高度塌陷以及其解决办法

    1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="U ...

  2. python常见错误和异常

    1．BaseExeception 所有异常的基类 2.SystemEixt 解释器请求退出 3.KeyboardInterrupt 用户中断执行 4.Exception 常规错误的基类 5.StopI ...

  3. python学习8 文件的操作

    本文拷贝了on testing 的<python之文件操作:文件的读写>,只做学习之用 python的文件读写通过 一.用open函数 二.对文件读写操作 三.读取文件位置定位 1. op ...

  4. SetWindowsHookEx 消息钩取进程卡死

    <逆向工程核心原理> windows消息钩取部分的例子在win10下卡死,失败.通过搜索发现,要保证钩取的进程与注入的dll要保持cpu平台相同 SetWindowsHookEx可用于将d ...

  5. 「HTML+CSS」--自定义按钮样式【001】

    前言 Hello!小伙伴! 首先非常感谢您阅读海轰的文章,倘若文中有错误的地方,欢迎您指出- 哈哈 自我介绍一下 昵称:海轰 标签:程序猿一只|C++选手|学生 简介:因C语言结识编程,随后转入计算机 ...

  6. frp穿透内网使用vsftpd服务

    本篇文章将会介绍如何使用frp穿透内网以及如何在centos8环境下安装和使用vsftpd,最后在公网通过frp穿透内网使用ftp. 一.内网穿透神器frp frp 是一个专注于内网穿透的高性能的反向 ...

  7. 巧用 SVG 滤镜还能制作表情包？

    本文将介绍一些使用 SVG feTurbulence 滤镜实现的一些有趣.大胆的的动效. 系列另外两篇: 有意思!强大的 SVG 滤镜 有意思!不规则边框的生成方案 背景 今天在群里面聊天,看到有人发 ...

  8. CVPR2021| 行人搜索中的第一个anchor-free模型：AlignPS

    论文地址:https://arxiv.org/abs/2103.11617 代码地址:https://github.com/daodaofr/AlignPS 前言: 本文针对anchor-free模型 ...

  9. 最小生成树，Prim和Kruskal的原理与实现

    文章首先于微信公众号:小K算法,关注第一时间获取更新信息 1 新农村建设 大清都亡了,我们村还没有通网.为了响应国家的新农村建设的号召,村里也开始了网络工程的建设. 穷乡僻壤,人烟稀少,如何布局网线, ...

  10. springboot基础项目搭建（十五篇）

    springboot系列一.springboot产生背景及介绍 springboot系列二.springboot项目搭建 springboot系列三.springboot 单元测试.配置访问路径.多个 ...