李宏毅《机器学习》飞桨特训营(八)——Paddle2.0教学(基于Paddle实现线性回归和神经网络拟合)

一. Paddle2.0教学

此教程旨在介绍PaddlePaddle(一个易用、高效、灵活、可扩展的深度学习框架)，根据PaddlePaddle 2.0 rc官方手册编写，介绍了PaddlePaddle中比较常用的一些API以及其基本用法。

完整内容请看：Paddle2.0 教学

二. 线性回归问题

2.1 构建训练集

import paddle
import paddle.fluid as fluid
paddle.disable_static()

# make a simple linear dataset with some noise

#50组数据，每组数据为2维
d = 2
n = 50
X = paddle.randn((n,d)) 
#初始化权重大小
true_w = paddle.to_tensor([[-1.0], [2.0]]) 
#输出有50组数据，每组数据为1维，由X乘上权重再加上一个随机数产生
y = fluid.layers.matmul(x=X, y=true_w) + paddle.randn((n,1)) * 0.1 
print('X shape', X.shape)
print('y shape', y.shape)
print('w shape', true_w.shape)

运行后输出如下所示：
X shape [50, 2]
y shape [50, 1]
w shape [2, 1]

2.2 初始化模型组、损失函数、梯度下降方法并开始训练

这里模型组(Function Set)采用的是线性模型：
y = w1*x1 + w2*x2 + b

损失函数采用的是均方差(MSE)。

梯度下降方法采用的是随机梯度下降(SGD)，关于SGD的内容可以参考：李宏毅《机器学习》飞桨特训营(三)——梯度下降。

import paddle
paddle.disable_static() #采用动态图模式

step_size = 0.1 #学习率

linear_module = paddle.nn.Linear(d, 1) #初始化模型组

loss_func = paddle.nn.loss.MSELoss() #初始化损失函数

optim = paddle.optimizer.SGD(learning_rate=step_size, parameters=linear_module.parameters()) #初始化梯度下降方法

print('iter,\tloss,\tw')

#开始训练
for i in range(20):
    y_hat = linear_module(X) #得到模型的输出值
    loss = loss_func(y_hat, y) #将实际值和预测值带入损失函数计算Loss
    loss.backward() #得到损失函数的偏微分(梯度)
    optim.minimize(loss) #最小化loss
    #由于Paddle是默认梯度累加而不是梯度更新。因此需要先清除梯度
    linear_module.clear_gradients()
    optim.step() #更新参数
    print('{},\t{},\t{}'.format(i, loss.numpy(), linear_module.weight.reshape((1,2)).numpy()))

print('\ntrue w\t\t', true_w.reshape((1, 2)).numpy())
print('estimated w\t', linear_module.weight.reshape((1, 2)).numpy())

运行后输出以下内容：
iter,	loss,	w
0,	[8.516477],	[[ 0.10022389 -0.7977885 ]]
1,	[6.2483263],	[[-0.10361427 -0.42921364]]
2,	[4.600916],	[[-0.2678099  -0.10901756]]
3,	[3.3984911],	[[-0.4003571  0.1690417]]
4,	[2.5171614],	[[-0.5075947  0.4104248]]
5,	[1.8688691],	[[-0.5945553  0.6199035]]
6,	[1.3905537],	[[-0.66524    0.8016432]]
7,	[1.0367534],	[[-0.72283417  0.95927685]]
8,	[0.77449936],	[[-0.7698779  1.0959705]]
9,	[0.57976115],	[[-0.8084     1.2144811]]
10,	[0.43494606],	[[-0.8400236  1.317208 ]]
11,	[0.32712573],	[[-0.8660497  1.4062386]]
12,	[0.24676938],	[[-0.8875233  1.4833868]]
13,	[0.18683243],	[[-0.9052851  1.5502294]]
14,	[0.14209586],	[[-0.9200133  1.6081358]]
15,	[0.10868639],	[[-0.93225574  1.658295  ]]
16,	[0.08372474],	[[-0.9424563  1.7017391]]
17,	[0.06506791],	[[-0.95097536  1.7393636 ]]
18,	[0.05111913],	[[-0.95810616  1.7719451 ]]
19,	[0.04068784],	[[-0.96408796  1.8001577 ]]

true w		 [[-1.  2.]]
estimated w	 [[-0.96408796  1.8001577 ]]

三. 神经网络回归问题

3.1 构建训练集

import paddle
import matplotlib.pyplot as plt
import numpy as np

d = 1 #输入为一个数
n = 200
X = paddle.rand(shape=[n,d])
y = 4 * paddle.sin(np.pi * X) * paddle.cos(6*np.pi*X**2)

plt.scatter(X.numpy(), y.numpy())
plt.title('plot of $f(x)$')
plt.xlabel('$x$')
plt.ylabel('$y$')

plt.show()

3.2 初始化模型组、损失函数、梯度下降方法并开始训练

我们使用了一个简单的含有三个隐藏层和Tanh激活函数的神经网络。我们可以通过调节这个神经网络的一些超参数来说明超参数是如何改变模型结果的。

import paddle
paddle.disable_static()

# feel free to play with these parameters

step_size = 0.1 #学习率
n_epochs = 12000 #训练轮数
n_hidden_1 = 32 #隐藏层1输出数量
n_hidden_2 = 32 #隐藏层2输出数量
n_hidden_3 = 32 #隐藏层3输出数量
d_out = 1 #最后输出一个数

neural_network = paddle.nn.Sequential(
                            paddle.nn.Linear(d, n_hidden_1), 
                            paddle.nn.Tanh(),
                            paddle.nn.Linear(n_hidden_1, n_hidden_2),
                            paddle.nn.Tanh(),
                            paddle.nn.Linear(n_hidden_2, n_hidden_3),
                            paddle.nn.Tanh(),                           
                            paddle.nn.Linear(n_hidden_3, d_out)
                            )
                            
loss_func =  paddle.nn.loss.MSELoss() #损失函数为均方差

optim = paddle.optimizer.SGD(learning_rate=step_size, parameters=neural_network.parameters()) #梯度下降方法为SGD
print('iter,\tloss')
for i in range(n_epochs):
    y_hat = neural_network(X)
    loss = loss_func(y_hat, y)
    loss.backward()
    optim.minimize(loss)
    neural_network.clear_gradients()
    optim.step()
    
    if i % (n_epochs // 10) == 0:
        print('{},\t{}'.format(i, loss.numpy()))       
                          
运行后输出以下内容：
iter,	loss
0,	    [3.6202374]
1200,	[1.2893366]
2400,	[0.11215799]
3600,	[0.0829023]
4800,	[0.04699586]
6000,	[0.03366168]
7200,	[0.03049625]
8400,	[0.04074802]
9600,	[0.02516548]
10800,	[0.01975279]                        

3.3 显示拟合曲线

X_grid = paddle.to_tensor(np.linspace(0,1,50), dtype=np.float32).reshape((-1, d))
y_hat = neural_network(X_grid)
plt.scatter(X.numpy(), y.numpy())
plt.plot(X_grid.detach().numpy(), y_hat.detach().numpy(), 'r')
plt.title('plot of $f(x)$ and $\hat{f}(x)$')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.show()