PyTorch深度学习入门 || 系列（四）——非线性回归

0 写在前面

• 这个系列之前学习是线性回归，但是生活中需要解决问题大多数都是非线性的。
• 本文要讨论的重点就是非线性的问题！

1 激活函数

• 目的：激活函数实际上是一个非常简单的非线性函数，它作用在线性层的输出，只要让多个带有激活函数的神经元组合在一起，就具有拟合复杂非线性函数的强大能力！

• 常用的激活函数有：sigmoid、tanh、ReLU、Maxout等！

• 这里采用的是ReLU函数
  

	torch.nn.functional.relu()

2 人工神经网络

• 人工神经网络由多层人工神经元组成。
• 可以通过机器学习训练调整各结点之间连接的权重关系，从而模拟出复杂的非线性函数！
• 人工神经网络可以按照：输入层、隐含层、输出层，分为三层。
• 凡是隐含层的层数大于等于2的神经网络，都可以称为深度神经网络。

3 数据处理

1. x代表输入，是[-3,3)区间内的划分的10000个数
2. y代表真实输出，是$x^3$m，为了更贴合真实数据，加了一点扰动： 0.3*torch.rand(x.size())

import torch
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-3, 3, 10000), dim=1)
y = x.pow(3) + 0.3*torch.rand(x.size())

plt.scatter(x.numpy(), y.numpy(), s=0.01)
plt.show()

• 输入情况：
  

4 定义模型

• Net需要继承nn.Module，里面构造一个隐含层self.hidden 和一个输出增 self.out，经过隐含层的数据需要经过ReLU激活函数进行非线性处理，最后经过输出层。

from torch import nn, optim
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self, input_feature, num_hidden, outputs):
        super(Net, self).__init__()
        self.hidden = nn.Linear(input_feature, num_hidden)
        self.out = nn.Linear(num_hidden, outputs)

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

• 初始化net，设置输入为1维，隐含层节点数为20，输出为1维：

net = Net(input_feature=1, num_hidden=20, outputs=1).cuda()
inputs = x.cuda()
target = y.cuda()

5 完整代码

• 可以直接运行！
  - 如果你觉得本篇文章对你有帮助的话，感谢收藏点赞关注我哟！

import torch
import matplotlib.pyplot as plt
from torch import nn, optim
import torch.nn.functional as F


x = torch.unsqueeze(torch.linspace(-3, 3, 10000), dim=1)
y = x.pow(3) + 0.3*torch.rand(x.size())

# plt.scatter(x.numpy(), y.numpy(), s=0.01)
# plt.show()


class Net(nn.Module):
    def __init__(self, input_feature, num_hidden, outputs):
        super(Net, self).__init__()
        self.hidden = nn.Linear(input_feature, num_hidden)
        self.out = nn.Linear(num_hidden, outputs)

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


def train(model, criterion, optimizer, epochs):
    for epoch in range(epochs):
        output = model(inputs)
        loss = criterion(output, target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # if epoch % 80 == 0:
        #     draw(output, loss)
    return model, loss


def draw(output, loss):
    output = output.cpu()
    plt.cla()
    plt.scatter(x.numpy(), y.numpy())
    plt.plot(x.numpy(), output.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'loss=%s' % (loss.item()), fontdict={'size':20, 'color':'red'})

    plt.show()
    plt.pause(0.005)


net = Net(input_feature=1, num_hidden=20, outputs=1).cuda()
inputs = x.cuda()
target = y.cuda()

optimizer = optim.SGD(net.parameters(), lr=0.01)
criterion = nn.MSELoss()

net, loss = train(net, criterion, optimizer, 10000)
print("final loss:", loss.item())

• 最后的输出结果
  

• 中间的图（已经失去耐心）