pytorch—搭建简单神经网络（回归）

• 用pytorch搭建神经网络，拟合曲线： $$y=x^2$$
• 环境 pytoch1.1.0

1. 生成训练数据

# 准备数据
x_data = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=-1)
y_data = x_data.pow(2)

# 通过matplotlib可视化生成的数据
# plt.scatter(x_data.numpy(), y_data.numpy())
# plt.show()
1
2
3
4
5
6
7

2. 搭建神经网络

class Neuro_net(torch.nn.Module):
    """搭建神经网络"""
    def __init__(self, n_feature, n_hidden_layer, n_output):
        super(Neuro_net, self).__init__()   # 继承__init__功能
        # 隐藏层
        self.hidden_layer = torch.nn.Linear(n_feature, n_hidden_layer) 
        # 输出层
        self.output_layer = torch.nn.Linear(n_hidden_layer, n_output)
	# 前向传播
    def forward(self, x_data):
        # 隐藏层出来后使用激励函数激活，最后返回预测值
        hidden_layer_x = torch.relu(self.hidden_layer(x_data))
        pridect_y = self.output_layer(hidden_layer_x)
        return pridect_y
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 训练神经网络

• 我这边选择训练500步，拟合效果还行，步数在往上增加你会发现loss还会减小，拟合效果还会更好，但也有可能遇到振荡。

num_feature = 1
num_hidden_layer = 10
num_output = 1
epoch = 500
# 实例化神经网络
net = Neuro_net(num_feature, num_hidden_layer, num_output)
# print(net)   # 可查看网络结构

# optimizer 优化  学习率在这里设置
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
# loss funaction
loss_funaction = torch.nn.MSELoss()

# train
for step in range(epoch):
    pridect_y = net(x_data)  # 喂入训练数据 得到预测的y值
    loss = loss_funaction(pridect_y, y_data)  # 计算损失

    optimizer.zero_grad()    # 为下一次训练清除上一步残余更新参数
    loss.backward()          # 误差反向传播，计算梯度
    optimizer.step()         # 将参数更新值施加到 net 的 parameters 上
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4. 为了更好理解训练过程，加入可视化

import matplotlib.pyplot as plt
plt.ion()   # 画图

for step in range(epoch):
    ...
    loss.backward()
    optimizer.step()
    
    if step % 5 == 0:
        print("已训练{}步 | loss：{}。".format(step, loss))
        plt.cla()
        plt.scatter(x_data.numpy(), y_data.numpy())
        plt.plot(x_data.numpy(), pridect_y.data.numpy(), color="green", marker="o", linewidth=6, label="predict_line")
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 15, 'color': 'red'})
        plt.pause(0.1)
        
plt.ioff()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

整体代码：

import torch
import matplotlib.pyplot as plt


class Neuro_net(torch.nn.Module):
    """搭建神经网络"""
    def __init__(self, n_feature, n_hidden_layer, n_output):
        super(Neuro_net, self).__init__()   # 继承__init__功能
        self.hidden_layer = torch.nn.Linear(n_feature, n_hidden_layer)
        self.output_layer = torch.nn.Linear(n_hidden_layer, n_output)

    def forward(self, x_data):
        hidden_layer_x = torch.relu(self.hidden_layer(x_data))
        pridect_y = self.output_layer(hidden_layer_x)
        return pridect_y

# 准备数据
x_data = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=-1)
y_data = x_data.pow(2)

# 通过matplotlib可视化生成的数据
# plt.scatter(x_data.numpy(), y_data.numpy())
# plt.show()

num_feature = 1
num_hidden_layer = 10
num_output = 1
epoch = 500
# 实例化神经网络
net = Neuro_net(num_feature, num_hidden_layer, num_output)
# print(net)

# optimizer 优化
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
# loss funaction
loss_funaction = torch.nn.MSELoss()

plt.ion()
# train
for step in range(epoch):
    pridect_y = net(x_data)  # 喂入训练数据 得到预测的y值
    loss = loss_funaction(pridect_y, y_data)  # 计算损失

    optimizer.zero_grad()    # 为下一次训练清除上一步残余更新参数
    loss.backward()          # 误差反向传播，计算梯度
    optimizer.step()         # 将参数更新值施加到 net 的 parameters 上

    if step % 5 == 0:
        print("已训练{}步 | loss：{}。".format(step, loss))
        plt.cla()
        plt.scatter(x_data.numpy(), y_data.numpy())
        plt.plot(x_data.numpy(), pridect_y.data.numpy(), color="green", marker="o", linewidth=6, label="predict_line")
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 13, 'color': 'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

可视化动态拟合图

• 训练开始
  
• 训练结束