Jena Climate时间序列数据集上使用LSTM进行温度的预报¶

%matplotlib inline
# 导入 paddle
import paddle
import paddle.nn.functional as F
print(paddle.__version__)

2.4.0

# 导入其他模块
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
import warnings
warnings.filterwarnings("ignore")

# 输入的指标维度
fea_num = 7
class Encoder(paddle.nn.Layer):
    def __init__(self, window_size, fea_num):
        super().__init__()
        self.window_size = window_size
        self.fea_num = fea_num
        self.conv1 = paddle.nn.Conv2D(in_channels=1, out_channels=64, stride=1, kernel_size=3, padding='same')
        self.relu1 = paddle.nn.ReLU()
        self.pool = paddle.nn.MaxPool2D(kernel_size=2, stride=1, padding='same')
        self.dropout = paddle.nn.Dropout2D(0.3)

        self.lstm1 = paddle.nn.LSTM(input_size=64*fea_num, hidden_size=128, num_layers=1, time_major=False)
        self.fc = paddle.nn.Linear(in_features=128, out_features=64)
        self.relu2 = paddle.nn.ReLU()
        self.head = paddle.nn.Linear(in_features=64, out_features=1)

    def forward(self, x):
        x = x.reshape([x.shape[0], 1, self.window_size, self.fea_num])
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool(x)
        x = self.dropout(x)

        x = x.reshape([x.shape[0], self.window_size, -1])
        x, (h, c) = self.lstm1(x)
        x = x[:,-1,:] # 最后一个LSTM只要窗口中最后一个特征的输出
        x = self.fc(x)
        x = self.relu2(x)
        x = self.head(x)

        return x

# 打印网络结构
model = Encoder(future, fea_num)
paddle.summary(model, (128,72,7))

W1208 01:25:21.663805   170 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
W1208 01:25:21.666718   170 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.


-------------------------------------------------------------------------------------------------------
 Layer (type)       Input Shape                        Output Shape                       Param #    
=======================================================================================================
   Conv2D-1      [[128, 1, 72, 7]]                   [128, 64, 72, 7]                       640      
    ReLU-1       [[128, 64, 72, 7]]                  [128, 64, 72, 7]                        0       
  MaxPool2D-1    [[128, 64, 72, 7]]                  [128, 64, 72, 7]                        0       
  Dropout2D-1    [[128, 64, 72, 7]]                  [128, 64, 72, 7]                        0       
    LSTM-1        [[128, 72, 448]]   [[128, 72, 128], [[1, 128, 128], [1, 128, 128]]]     295,936    
   Linear-1         [[128, 128]]                        [128, 64]                          8,256     
    ReLU-2          [[128, 64]]                         [128, 64]                            0       
   Linear-2         [[128, 64]]                          [128, 1]                           65       
=======================================================================================================
Total params: 304,897
Trainable params: 304,897
Non-trainable params: 0
-------------------------------------------------------------------------------------------------------
Input size (MB): 0.25
Forward/backward pass size (MB): 135.38
Params size (MB): 1.16
Estimated Total Size (MB): 136.79
-------------------------------------------------------------------------------------------------------






{'total_params': 304897, 'trainable_params': 304897}

# 自定义Callback 需要继承基类 Callback
class LossCallback(paddle.callbacks.Callback):

    def __init__(self):
        self.losses = []
        
    def on_train_begin(self, logs={}):
        # 在fit前 初始化losses，用于保存每个batch的loss结果
        self.losses = []
    
    def on_train_batch_end(self, step, logs={}):
        # 每个batch训练完成后调用，把当前loss添加到losses中
        self.losses.append(logs.get('loss'))
loss_log = LossCallback()

from paddle.static import InputSpec
# 参数设置
epoch_num = 30
batch_size = 128
learning_rate = 0.005

inputs = InputSpec([None, 72,7], 'float32', 'x')
labels = InputSpec([None, 72,1], 'float32', 'x')
model = paddle.Model(Encoder(future, fea_num), inputs, labels)

lr_schedual = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=learning_rate, T_max=epoch_num, verbose=False)
# 设置优化器，学习率，并且把模型参数给优化器
opt = paddle.optimizer.Adam(learning_rate=lr_schedual,parameters=model.parameters(), beta1=0.9, beta2=0.999)

model.prepare(
    opt,
    paddle.nn.MSELoss(),
    paddle.metric.Accuracy()
    )
    
model.fit(train_dataset,
        eval_dataset,
        epochs=epoch_num,
        batch_size=batch_size,
        eval_freq=10, 
        save_freq=10,
        save_dir='lstm_checkpoint',
        verbose=1,
        drop_last=True,
        shuffle=False,
        callbacks=[loss_log]
        )

# 可视化 loss
log_loss = [loss_log.losses[i] for i in range(0, len(loss_log.losses), 1000)]
plt.figure()
plt.plot(log_loss)

[<matplotlib.lines.Line2D at 0x7f7af2a3bad0>]

model.load('lstm_checkpoint/final')
# 用 evaluate 在测试集上对模型进行验证
eval_result = model.evaluate(eval_dataset,batch_size=batch_size, verbose=1)
print(eval_result)

Eval begin...
step 928/928 [==============================] - loss: 0.0125 - acc: 0.7291 - 7ms/step          
Eval samples: 118664
{'loss': [0.0124636665], 'acc': 0.7290922267916133}

model.load('lstm_checkpoint/final')
test_result = model.predict(test_dataset)
# 由于模型是单一输出，test_result的形状为[1, N]，N是测试数据集的数据量。这里打印第一个数据的预测结果。
print(len(test_result))
print(test_result[0][0])

Predict begin...
step 720/720 [==============================] - 2ms/step          
Predict samples: 720
1
[[-0.57714456]]

def show_plot(plot_data, delta, title):
    labels = ["History", "True Future", "Model Prediction"]
    marker = [".-", "rx", "go"]
    time_steps = list(range(-(plot_data[0].shape[0]), 0))
    if delta:
        future = delta
    else:
        future = 0

    plt.title(title)
    for i, val in enumerate(plot_data):
        if i:
            plt.plot(future, plot_data[i], marker[i], markersize=10, label=labels[i])
        else:
            plt.plot(time_steps, plot_data[i].flatten(), marker[i], label=labels[i])
    plt.legend()
    plt.xlim([time_steps[0], (future + 5) * 2])
    plt.xlabel("Time-Step")
    plt.show()
    return

# 滑动窗口的长度是72
# 这里要做一个反归一化处理
mean = df[selected_features][:train_split].mean(axis=0)[1]
std = df[selected_features][:train_split].std(axis=0)[1]

show_plot(
    [(x_test[:72,1] * std + mean), (x_test[72,1] * std + mean),( test_result[0][0].flatten()[0] * std + mean)],
    1,
    "Single Step Prediction",
)

show_plot(
    [(x_test[-72:,1] * std + mean), (x_test[-72,1] * std + mean),( test_result[0][-72].flatten()[-1] * std + mean)],
    1,
    "Single Step Prediction",
)