神经网络回归任务_np.mean(batch_loss)

上一节我们介绍的是利用网络完成分类任务，即将输入的数据分为十个类别。那么今天，我们来介绍回归任务，即根据输入数据得到一个结果。

数据处理

今天我们要完成的任务就是根据以往的气温数据对当下以及之后的气温进行估计的任务。我们先来引用库，然后再来看看我们的数据长什么样子：

import numpy as np
import pandas as pd 
import matplotlib.pyplot as plt
import torch
import torch.optim as optim
import warnings
warnings.filterwarnings("ignore") # 屏蔽警告

features = pd.read_csv('temps.csv')
print(features.head())
1
2
3
4
5
6
7
8
9
10

不难发现，我们要根据temp_2和temp_1等中的数据去预测真实值。在测试集中，预测的数据会与对应的真实值对比，得到损失值。最后一列的数据我们现在用不到。另外，时间数据我们也需要具体处理一下：

import datetime # 转换成标准的时间格式

# 分别得到年，月，日
years = features['year']
months = features['month']
days = features['day']

# datetime格式
# 打包数据，转换成例如2016-1-1的形式
dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year, month, day in zip(years, months, days)]
# 转换格式
dates = [datetime.datetime.strptime(date, '%Y-%m-%d') for date in dates]
1
2
3
4
5
6
7
8
9
10
11
12

大家可以打印一下查看我们的日期数据变成了什么样子。
接下来我们来绘图看看关键数据的折线图：

# 指定默认风格
plt.style.use('fivethirtyeight')

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2, figsize = (10,10)) # 行、列、图像尺度
fig.autofmt_xdate(rotation = 45)

ax1.plot(dates, features['actual'])
ax1.set_xlabel(''); ax1.set_ylabel('Temperature'); ax1.set_title('Max Temp')

ax2.plot(dates, features['temp_1'])
ax2.set_xlabel(''); ax2.set_ylabel('Temperature'); ax2.set_title('Previous Max Temp')

ax3.plot(dates, features['temp_2'])
ax3.set_xlabel('Date'); ax3.set_ylabel('Temperature'); ax3.set_title('Two Days Prior Max Temp')

ax4.plot(dates, features['friend'])
ax4.set_xlabel('Date'); ax4.set_ylabel('Temperature'); ax4.set_title('Friend Estimate')

plt.tight_layout(pad=2)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

另外，还有一个问题表格中的week列都是字符串类型，我们需要把它变换一下。变换的方法就是独热编码。所谓独热编码，就是根据这一列数据的不同种类（这里是七个种类）进行编码，比如Fri就会被编码成1000000：

# 独热编码
features = pd.get_dummies(features) # 字符串列的展开

pd.set_option('display.max_columns',None)
pd.set_option('display.max_rows',None)

print(features.head())
1
2
3
4
5
6
7

之前的week列被拆成了七列，每一列都是一个二进制数。
前面讲过actual列在测试集中需要用于检验的，所以不能作为输入，因此我们要进行以下调整：

# 将actual列数据存储，并转换成ndarray格式
labels = np.array(features['actual'])
# 在特征中去掉actual列
features= features.drop('actual', axis = 1) 
print(features.head())
# 列标签单独存储一下，防止去掉之后我们无法查看某列数据的含义
feature_list = list(features.columns)
print(features.columns)
# 转换成合适的格式
features = np.array(features)
1
2
3
4
5
6
7
8
9
10

这样一来，我们就得到了学习所需要的所有数据了。但是由于计算机会把数值大理解为特征明显，因此我们还需要把数据进行标准化，让所有的值都分布在0点附近，这样才能得到较好的学习效果。这一处理方法与正态分布标准化方法类似：

from sklearn import preprocessing 
# 标准化处理，避免神经网络运行时认为数值大的数据更重要
input_features = preprocessing.StandardScaler().fit_transform(features)
# 让数据特征基本集中在原点附近
print(type(input_features))
print(input_features[0:5])
1
2
3
4
5
6

网络模型构建

至此，我们已经把数据处理成方便计算机学习的格式了，下面就来编写网络结构了（以下代码与前文独立）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.optim as optim
import warnings
import datetime
from sklearn import preprocessing
warnings.filterwarnings("ignore")
features = pd.read_csv('temps.csv')

years = features['year']
months = features['month']
days = features['day']

dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year, month, day in zip(years, months, days)]
dates = [datetime.datetime.strptime(date, '%Y-%m-%d') for date in dates]
# 独热编码
features = pd.get_dummies(features) # 字符串列的展开
pd.set_option('display.max_columns',None)
pd.set_option('display.max_rows',None)

labels = np.array(features['actual']) # 选取actual一列作为标签
features= features.drop('actual', axis = 1) # 删除标签列
feature_list = list(features.columns) # 存储列索引
features = np.array(features) # 转换格式
# 标准化处理，避免神经网络运行时认为数值大的数据更重要
input_features = preprocessing.StandardScaler().fit_transform(features)

'''断点'''
x = torch.tensor(input_features, dtype=float)  # 转换输入数据格式
y = torch.tensor(labels, dtype=float)

# 权重参数初始化
weights = torch.randn((14, 128), dtype=float, requires_grad=True)  # 输入14个特征，转换成128个神经元
biases = torch.randn(128, dtype=float, requires_grad=True)
weights2 = torch.randn((128, 1), dtype=float, requires_grad=True) # 由128个神经元参与预测得到结果
biases2 = torch.randn(1, dtype=float, requires_grad=True)
# W1：14*128矩阵 b1:128*1
# w2：128*1矩阵 b2:1*1

learning_rate = 0.001  # 设置学习率，不要太大
losses = []  # 先设置，准备存储损失

for i in range(1000):  # 更新一千次
    # 计算隐层
    hidden = x.mm(weights) + biases # mm是矩阵乘法
    # 加入激活函数
    hidden = torch.relu(hidden)  # 非线性映射，relu函数是{y=0(x<0);y=x(x≥0)}函数
    # 预测结果
    predictions = hidden.mm(weights2) + biases2
    # 通计算损失
    loss = torch.mean((predictions - y) ** 2)  # 预测值与真实值之间的均方差
    losses.append(loss.data.numpy())  # 保存loss方便后期画图

    # 打印损失值 每隔100次打印一下损失
    if i % 100 == 0:
        print('loss:', loss)
    # 返向传播计算
    loss.backward()

    # 更新参数
    # 沿着梯度的反方向去更新（找到损失值最小点）
    # 每次更新内容由学习率和梯度的乘积决定
    weights.data.add_(- learning_rate * weights.grad.data)
    biases.data.add_(- learning_rate * biases.grad.data)
    weights2.data.add_(- learning_rate * weights2.grad.data)
    biases2.data.add_(- learning_rate * biases2.grad.data)
    # 更新参数部分后面可以用调库的方式处理

    # 每次迭代前清空之前储存的梯度，防止梯度累加
    weights.grad.data.zero_()
    biases.grad.data.zero_()
    weights2.grad.data.zero_()
    biases2.grad.data.zero_()
# 通常网络的层数增多会让损失函数下降的速度变快
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

让我们来看看结果：

网络模型简化

上一个完整的代码，我们是自己构建的网络，对于网络的参数更新、反向传播等都可以调包实现，而且我们的回归任务大部分也都需要使用batch来分解学习任务，这些都是可以通过调用轻松实现的：

# 这段代码替换掉上段代码断点后的内容
input_size = input_features.shape[1] # 输入的特征个数，即input_features列数

# 这里我们使用两层的网络，提升网络的预测效果
hidden_size = 128
hidden_size2=256
output_size = 1
batch_size = 16 # batch可以通过打包部分样本来减少计算平均损失的运算量

# 调包环节
my_nn = torch.nn.Sequential( # 调用序列模块，按顺序执行代码
    torch.nn.Linear(input_size, hidden_size), # 全连接层，可以自动初始化w和b。这里的input_size=14，hidden_size=128
    torch.nn.Sigmoid(),     # 激活函数也可以用nn.ReLu
# 如果希望做一层的网络，可以删掉这两行代码
    torch.nn.Linear(hidden_size,hidden_size2),
    torch.nn.Sigmoid(),

    torch.nn.Linear(hidden_size2, output_size), # 输出结果
)
cost = torch.nn.MSELoss(reduction='mean') # 计算损失
optimizer = torch.optim.Adam(my_nn.parameters(), lr = 0.001) # 优化器，my_nn.parameters()代表所有初始化的权重参数都需要做更新

# 训练网络
losses = []
for i in range(1000):
    batch_loss = []
    # MINI-Batch方法来进行训练
    for start in range(0, len(input_features), batch_size):  # 每batch_size个数据打包称一次学习的内容
        # 计算每个学习包的最后一个元素所在位置
        end = start + batch_size if start + batch_size < len(input_features) else len(input_features)

        # 取数据，记得转换格式
        xx = torch.tensor(input_features[start:end], dtype=torch.float, requires_grad=True)
        yy = torch.tensor(labels[start:end], dtype=torch.float, requires_grad=True)

        prediction = my_nn(xx)  # 输出值
        loss = cost(prediction, yy)  # 得到损失值

        # 优化
        optimizer.zero_grad()  # 梯度清零
        loss.backward(retain_graph=True)  # 反向传播
        optimizer.step()  # 参数更新

        # 损失值储存
        batch_loss.append(loss.data.numpy())

    # # 打印损失
    # if i % 100 == 0:
    #     losses.append(np.mean(batch_loss))
    #     print(i, np.mean(batch_loss))

# 训练好后得到最终的预测结果
x = torch.tensor(input_features, dtype = torch.float)
predict = my_nn(x).data.numpy() # 得到每一天的预测值
# 创建一个表格来存日期和其对应的标签数值
true_data = pd.DataFrame(data = {'date': dates, 'actual': labels})
# 同理，再创建一个来存日期和其对应的模型预测值
predictions_data = pd.DataFrame(data = {'date': dates, 'prediction': predict.reshape(-1)})

# 绘图
# 真实值
plt.plot(true_data['date'], true_data['actual'], 'b-', label = 'actual')
# 预测值
plt.plot(predictions_data['date'], predictions_data['prediction'], 'ro', label = 'prediction')
plt.xticks(rotation = '60');
plt.legend()
# 图名
plt.xlabel('Date'); plt.ylabel('Maximum Temperature (F)'); plt.title('Actual and Predicted Values');
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
58
59
60
61
62
63
64
65
66
67
68
69

我们就可以查看预测值和真实值的对比图了：

可以看到，学习的效果与真实的数据之间差距已经属于我们能够接受的范围之内了。当然，由于这里的数据量很小，我们再去增加迭代次数或者再增加网络的层数就可能引起过拟合。当然，作为一个练习，我们并不用太过在意这些。
今天给大家介绍了利用深度学习完成简单的回归任务，代码很多但并不复杂，小伙伴们要多多练习~