关于paddlepaddle新手教程中的线性回归方程解析

人总是喜欢捣鼓的，最近发现paddlepaddle也是一个比较好玩的东西，所以就下手使用了一下。但是当我开始学习的时候发现自己蒙了，本人本身是没有太多深度学习基础的，顶多也就是知道DNN的结构：输入层、隐藏层、输出层，所以我发现这个玩意学习起来还是有一些吃力的。新手教程的例子就把我给干到了。

一、 给出代码

废话不多说呀，先给出原文的例子，然后我在一步一步的进行解释：

#加载库
import paddle.fluid as fluid
import numpy as np
#生成数据
np.random.seed(0)
outputs = np.random.randint(5, size=(10, 4))
res = []
for i in range(10):
        # 假设方程式为 y=4a+6b+7c+2d
        y = 4*outputs[i][0]+6*outputs[i][1]+7*outputs[i][2]+2*outputs[i][3]
        res.append([y])
# 定义数据
train_data=np.array(outputs).astype('float32')
y_true = np.array(res).astype('float32')

#定义网络
x = fluid.layers.data(name="x",shape=[4],dtype='float32')
y = fluid.layers.data(name="y",shape=[1],dtype='float32')
y_predict = fluid.layers.fc(input=x,size=1,act=None)
#定义损失函数
cost = fluid.layers.square_error_cost(input=y_predict,label=y)
avg_cost = fluid.layers.mean(cost)
#定义优化方法
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.05)
sgd_optimizer.minimize(avg_cost)
#参数初始化
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())
##开始训练，迭代500次
for i in range(500):
        outs = exe.run(
                feed={'x':train_data,'y':y_true},
                fetch_list=[y_predict.name,avg_cost.name])
        if i%50==0:
                print ('iter={:.0f},cost={}'.format(i,outs[1][0]))
#存储训练结果
params_dirname = "result"
fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)

# 开始预测
infer_exe = fluid.Executor(cpu)
inference_scope = fluid.Scope()
# 加载训练好的模型
with fluid.scope_guard(inference_scope):
        [inference_program, feed_target_names,
         fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe)

# 生成测试数据
test = np.array([[[9],[5],[2],[10]]]).astype('float32')
# 进行预测
results = infer_exe.run(inference_program,
                                                feed={"x": test},
                                                fetch_list=fetch_targets)
# 给出题目为 【9,5,2,10】 输出y=4*9+6*5+7*2+10*2的值
print ("9a+5b+2c+10d={}".format(results[0][0]))

二、代码解读

首先，这例子要给我们解决的是对方程y=4a+6b+7c+2d值的一个预测。大家可以看到，这只是四元一次方程，我们想要得到y值，只要把对应的(a,b,c,d)的值带入即可。这个问题的解答其实是很简单的，但是我们如何通过学习的方式让计算机掌握改方程对应的映射关系f(a,b,c,d)呢。

1. 第一步进行导包，因为我们是需要使用paddlepaddle来进行代码的编写，理应如此导包
2. numpy的作用在这里就是为了生成数据，采用了随机数的方式但是需要注意的是这里指定了种子np.random.seed(0)默认情况下，随机数的种子使用的是当前时间的时间戳，指定了种子后，生成的随机数将不会改变，for循环是为了生成每一行数据对应的y值并存放在列表res中
3. 对数据进行格式上的转换，全部设置为float32，下面展示一下train_data和y_true的值：

array([[4., 0., 3., 3.],
       [3., 1., 3., 2.],
       [4., 0., 0., 4.],
       [2., 1., 0., 1.],
       [1., 0., 1., 4.],
       [3., 0., 3., 0.],
       [2., 3., 0., 1.],
       [3., 3., 3., 0.],
       [1., 1., 1., 0.],
       [2., 4., 3., 3.]], dtype=float32)

array([[43.],
       [43.],
       [24.],
       [16.],
       [19.],
       [33.],
       [28.],
       [51.],
       [17.],
       [59.]], dtype=float32)

4. 接下来的定义网络就是定义神经网络，使用fluid.layers.data创建的是全局变量，输入层有四个变量，输出层有一个变量。fluid.layers.fc是用来创建网络全连接的，那么什么是全连接呢？第i层的任意一个神经元一定与第i+1层的任意一个神经元相连就叫做全连接，看下图：
   
5. 对于fluid.layers.fcinput的值为x没有疑问，那么size代表什么呢？size 的含义是这一层的输出单元数，act代表的是激活应用于该层的输出
6. 定义损失函数的意义在于测试y_predict这个‘预测层’输出值与实际值之间的误差。
   使用的方法fluid.layers.square_error_cost传入的参数是‘预测层’的值和实际的y值。
7. 既然有了误差自然是需要对误差进行优化，使用的方法是fluid.optimizer.SGD，这就是一个优化器，传入的参数代表的是优化的程度；sgd_optimizer.minimize是为了将avg_cost优化到最小。
8. 初始化操作是对模型进行训练之前的一些基础设置，这里是使用CPU进行计算；fluid.default_startup_program()可以用来定位到全局或默认的开始程序。
9. 进行迭代训练，run方法中传入的第一个参数feed是我们用来训练的数据，第二个参数fetch_list代表的是我们想要获得结果的名称所组成的列表。我们打印第一次的结果：

outs = exe.run(feed={'x':train_data,'y':y_true},
               fetch_list=[y_predict.name,avg_cost.name])
outs

[array([[-4.94541   ],
        [-2.9415631 ],
        [-8.577576  ],
        [-3.3598056 ],
        [-4.498768  ],
        [-0.6619586 ],
        [-3.6408992 ],
        [-1.083599  ],
        [-0.36119962],
        [-3.3578672 ]], dtype=float32), array([1543.4573], dtype=float32)]

我们可以看到，输出结果是两个数组组成的列表，第一个数组代表的就是第一次训练之后预测的y_predict 的值，第二个数组代表的是误差值avg_cost。如此这般训练500次后即可得到模型。

10. 将最终训练出来的模型进行存储fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)，第一个参数是当前模型的名字，第二个参数是输入值的列表，第三个参数是预测结果输出值的列表，第四个参数是训练得到的模型所在的执行器。
11. 进行预测，首先是定义一个执行器；fluid.Scope用来保存训练好的模型，fluid.scope_guard用来找到训练好的模型。fluid.io.load_inference_model用来加载模型，并将模型赋给创建好的执行器。返回值我们进行打印：

print(feed_target_names)
print(fetch_targets)

['x']
[name: "save_infer_model/scale_0.tmp_2"
type {
  type: LOD_TENSOR
  lod_tensor {
    tensor {
      data_type: FP32
      dims: -1
      dims: 1
    }
    lod_level: 0
  }
}
persistable: false
]

fetch_target就是我们想要得到的预测值
12. 通过模型进行预测。

三、结束

本文参考的有：
1、paddlepaddle的官方文档
2、深度神经网络（DNN）模型与前向传播算法
3、欢迎大家订阅我的个人博客哦|•’-’•)و✧