PyTorch学习笔记（四）——回归问题

这次来见证神经网络是如何通过简单的形式将一群数据用一条线条来表示。或者说，是如何在数据当中找到他们的关系， 然后用神经网络模型来建立一个可以代表他们关系的线条。注：本节程序上下是连贯的，分开只为方便解说。

一、建立伪数据：

# coding=gbk
import torch
import matplotlib.pyplot as plt
#建立伪数据集
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
#torch.unsqueeze将数据变为二维数据，满足神经网络的条件
y = x.pow(2) + 0.2*torch.rand(x.size())    #给y加一点噪声，data (tensor), shape=(100, 1)

#画图，注意只有Numpy格式的数据能画出来。
plt.scatter(x.data.numpy(), y.data.numpy())
plt.show()

伪数据可视化：

二、建立神经网络：

建立一个神经网络可以直接运用 torch 中的体系。先定义所有的层属性(__init__()), 然后再一层层搭建(forward(x))层于层的关系链接。建立关系的时候， 会用到上一期介绍的激励函数。

#建立神经网络
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 = torch.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
        x = self.predict(x)             # 输出值
        return x

net = Net(n_feature=1, n_hidden=10, n_output=1)
print(net)  # net的结构
"""
输出网络结构：
Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)
"""

三、训练神经网络：

注意参数、优化器的选择。

#训练神经网络
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)  
# 传入net的所有参数, 学习率，优化器使用随机梯度下降。
loss_func = torch.nn.MSELoss()      # 预测值和真实值的误差计算公式 (均方差)

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

    loss = loss_func(prediction, y)     #计算两者的误差，注意顺序不要反了

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

四、可视化训练过程：

在运行代码时，将第三段的训练神经网络覆盖，因为此处包含第三个步骤。

#可视化训练过程
for t in range(2000):
    prediction = net(x)     # 喂给net训练数据x,输出预测值
    loss = loss_func(prediction, y)     # 计算两者的误差，注意顺序不要反了
    optimizer.zero_grad()   # 清空上一步的残余更新参数值  
    loss.backward()
    optimizer.step()
    # 接着上面来
    if t % 5 == 0:#训练5次打印一次
        # plot and show learning process
        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'})
        plt.pause(0.1)
plt.ion()   #画图
plt.show()

完整代码：

# coding=gbk
import torch
import matplotlib.pyplot as plt
#建立伪数据集
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
#torch.unsqueeze将数据变为二维数据，满足神经网络的条件
y = x.pow(2) + 0.2*torch.rand(x.size())    #给y加一点噪声，data (tensor), shape=(100, 1)

#画图，注意只有Numpy格式的数据能画出来。
#plt.scatter(x.data.numpy(), y.data.numpy())
#plt.show()

#建立神经网络
import torch
import torch.nn.functional as F     # 激励函数都在这

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 = torch.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
        x = self.predict(x)             # 输出值
        return x

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

print(net)  # net 的结构
"""
输出网络结构：
Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)
"""
#训练神经网络
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)  
# 传入net的所有参数, 学习率，优化器使用随机梯度下降。
loss_func = torch.nn.MSELoss()      # 预测值和真实值的误差计算公式 (均方差)

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

    #loss = loss_func(prediction, y)     #计算两者的误差，注意顺序不要反了

    #optimizer.zero_grad()   # 清空上一步的残余更新参数值
    #loss.backward()         # 误差反向传播, 计算参数更新值
    #optimizer.step()        # 将参数更新值施加到 net 的 parameters 上
    
#可视化训练过程
for t in range(2000):
    prediction = net(x)     # 喂给net训练数据x,输出预测值
    loss = loss_func(prediction, y)     # 计算两者的误差，注意顺序不要反了
    optimizer.zero_grad()   # 清空上一步的残余更新参数值  
    loss.backward()
    optimizer.step()
    # 接着上面来
    if t % 5 == 0:#训练5次打印一次
        # plot and show learning process
        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'})
        plt.pause(0.1)
plt.ion()   #画图
plt.show()