pytorch深度学习：神经网络拟合方程(回归问题)

神经网络入门的应用就是拟合方程，这篇文章就针对这个问题来熟悉pytorch怎么搭建神经网络模型。

1. 问题提出

我们要拟合的是y = x^2这个最简单的一元二次方程，首先要创建我们的x,y数据,它们都是100*1维的数据，对y加了一个噪声，让它具有一些离散性。

# 建立数据:拟合y = x^2曲线
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)

用散点图显示出来：

2. 神经网络框架建立

pytorch中我们需要写一个类来表示神经网络的框架，它需要继承pytorch框架中的nn.Module这个类。

由于这个回归问题比较简单，我们只建立两层全连接网络结构，全连接层在nn.Module这个类中已经实现，我们只需要进行调用就好。

构造函数__init__ 是确定我们的网络架构，需要给出输入、输出层的个数和隐藏层神经单元数。

自定义的forward函数 则是我们需要自己实现的神经网络前向传播功能，在第一层隐藏层后加了激活函数relu()。

# 建立神经网络框架
class Net(nn.Module):
    def __init__(self,n_feature,n_hidden,n_output):    # 构造函数
        super(Net,self).__init__()                     # 继承nn.Module
        # 定义每层用什么样的形式
        self.hidden = nn.Linear(n_feature,n_hidden)    # 建立隐藏层
        self.predict = nn.Linear(n_hidden,n_output)    # 建立输出层
        
    # 实现前向传播功能
    def forward(self,x):
        x = self.hidden(x)
        x = F.relu(x)    # 激活函数
        x = self.predict(x)
        return x

3. 神经网络训练模型的建立

在网络框架搭建完成后，要进行神经网络训练模型的建立，其主要包含3个部分：

• 神经网络模型建立： 就是用我们搭建的框架生成一个模型。给定各个网络层的神经单元数。

input_dim  = 1       # 输入层单元数
hidden_dim = 10      # 隐藏单元数
out_dim = 1          # 输出层单元数

net = Net(input_dim,hidden_dim,out_dim)  # 建立神经网络模型net
print(net)

可以通过打印网络模型查看其结构，输出为：

Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)

• 优化器的建立： 选用优化器的种类，传入网络参数，设置学习率。直接用pytorch框架中封装好的优化器。

optimizer = torch.optim.SGD(net.parameters(),lr = 0.2)     
# 优化器种类：SGD
# 传入参数：net.parameters()
# 学习率：lr = 0.2

• 损失函数的定义： 也是直接使用pytorch框架中封装好的损失函数，这里选用了均方误差MSE。

loss_func = torch.nn.MSELoss()                           

4. 模型的训练

由于数据简单，我们只训练100次，网络的训练模式很固定，直接看代码：

# 训练
for i in range(100):
    prediction = net(x)  # 喂给net训练数据 x, 输出预测值
    
    loss = loss_func(prediction,y)  # 计算预测值和y两者的误差
    # 训练网络三个最主要步骤
    optimizer.zero_grad()   # 梯度清0
    loss.backward()         # 误差反向传播
    optimizer.step()        # 神经网络参数更新

要注意的是每次训练的梯度要手动进行清0，因此训练代码中的最后3行是一定要有的，否则不能完成训练。

5. 结果展示

到这里，神经网络拟合方程就结束了，下面就是展示的部分了，我们可以选择输出训练过程的loss值图像。发现损失值是在不断减小的，也就意味着模型拟合的越来越好。

让我们再看下拟合的方程，红线代表拟合过程中的方程：

6. 结语

这只是最简单的神经网络应用，代码参考了莫烦大神的教程，完整代码放在这里：

# 神经网络的搭建--回归任务 #
import torch
import torch.nn.functional as F     # 激励函数都在这
import torch
import matplotlib.pyplot as plt

# 建立数据
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)

# 建立神经网络
class Net(torch.nn.Module):  # 继承 torch 的 Module
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     # 继承 __init__ 功能
        # 定义每层用什么样的形式
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
        self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层线性输出

    def forward(self, x):   # 这同时也是 Module 中的 forward 功能
        # 正向传播输入值, 神经网络分析出输出值
        x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
        x = self.predict(x)             # 输出值
        return x

net = Net(n_feature=1, n_hidden=10, n_output=1)

print(net)  # net 的结构


# 训练网络
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)  # 传入 net 的所有参数, 学习率
loss_func = torch.nn.MSELoss()      # 预测值和真实值的误差计算公式 (均方差)

plt.ion()   # 画图
plt.show()

for t in range(100):
    prediction = net(x)     # 喂给 net 训练数据 x, 输出预测值

    loss = loss_func(prediction, y)     # 计算两者的误差

    optimizer.zero_grad()   # 清空上一步的残余更新参数值
    loss.backward()         # 误差反向传播, 计算参数更新值
    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

    # 可视化训练过程
    if t % 5 == 0:
        plt.cla()
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
        if t<90:
            plt.pause(0.1)
        else:
            plt.pause(1)