使用pytorch训练神经网络2-----回归

博主曾经写过一个使用pytorch训练神经网络的博文（使用Pytorch训练神经网络1），在那篇文章里面博主讲解了一个典型的神经网络的训练过程，引用了官方教程中的示例，包括正向传播、损失函数、反向传播和权值更新，都是根据数学公式手动定义的，如果想清晰了解神经网络的结构可以参考一下那篇文章。

本文博主参考了莫烦python的课程，将以一个回归神经网络的例子展示充分利用pytorch中各种函数和功能搭建神经网络的详细过程，这一篇相比上一篇代码会简便许多。
1、首先导入需要的包和模块

import torch
from torch.autograd import Variable
import torch.nn.functional as F

2、定义输入值和目标输出（目标函数）并转化为Variable（可进行自动求导）
输入值和目标输出放在一起组成训练数据集

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
y = x ** 2 + torch.rand(x.size())
x, y = Variable(x), Variable(y)

3、定义神经网络结构

class NN(torch.nn.Module):
	##定义输入、隐藏层和输出的结构
	def __init__(self, n_feature, n_hidden, n_output):
		super(NN, self).__init__()
		self.hidden = torch.nn.Linear(n_feature, n_hidden)
		self.predict = torch.nn.Linear(n_hidden, n_output)
	##定义正向传播函数
	def forward(self, x):
		x = F.relu(self.hidden(x))
		x = self.predict(x)
		return x

4、定义自己的神经网络（相当于一个NN类的实例化对象）

net = NN（1， 10， 1）
##print（net）可用来查看自己的网络结构

5、定义优化器和损失函数
这里直接调用pytorch里现有的SGD优化算法(需要传入神经网络的参数和学习率)和MSE损失函数

optimizer = torch.optim.SGD(net.parameters, lr=0.5)
loss_func = torch.nn.MSEloss()

6、开始训练（迭代100次）

for epoch in range(100):
	prediction = net(x)
	loss = loss_func(prediction, y)

	optimizer.zero_grad()               #清除梯度
	loss.backward()                     #反向传播
	optimizer.step()                    #优化

经过上述步骤我们就完成了一个简单的神经网络的训练，经过训练的网络可以完成回归任务。
如果想将训练成果可视化可以使用python的matplotlab模块，这里展示一下加上可视化的完整代码：

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
##unsqueeze:add a dimension in the first dimension
y = x.pow(2) + 0.2 * torch.rand(x.size())
##add some noise to y

x, y = Variable(x), Variable(y)

# plt.scatter(x, y)

##Linear is full connection network, F.relu is the nonlinear activation functon
class NN(torch.nn.Module):
    def __init__(self, n_featuer, n_hidden, n_output):
        super(NN, self).__init__()
        self.hidden = torch.nn.Linear(n_featuer, n_hidden)
        self.predict = torch.nn.Linear(n_hidden, n_output)


    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x


net = NN(1, 10, 1)      #set your own net structure
print(net)

plt.ion()                #Turn interactive mode on
plt.show()

##define optimizer and loss function type
optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
loss_func = torch.nn.MSELoss()

for epoch in range(100):
    prediction = net(x)

    loss = loss_func(prediction, y)

    optimizer.zero_grad()               ##clear grad
    loss.backward()                     ##backpropagation
    optimizer.step()                    ##optimize


    if epoch % 5 == 0:
        #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.xlim([-1.2, 1.2])
        plt.ylim([-0.2, 1.2])
        plt.text(0.3, 0, 'loss=%.4f' % loss.data, fontdict={'size': 15, 'color': 'red'})
        plt.pause(0.1)

plt.ioff()                  #Turn interactive mode off
plt.show()