园龄：6年11个月粉丝：2052 关注：178

基于LSTM实现单变量预测（Tensorflow2实现）

这篇文章的内容来自B站UP主唐国梁Tommy老师的视频

TensorFlow 2.0 基于LSTM单变量预测_电力消耗案例: https://www.bilibili.com/video/BV1f5411K7qD

案例实现思路：

模块导入
加载数据集、预处理

特征工程
构建模型
模型编译、训练、验证
模型测试
结果可视化

1、模块导入

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import r2_score

import tensorflow as tf
from tensorflow.keras import Sequential, layers, utils

import warnings
warnings.filterwarnings('ignore')

2、加载数据集、预处理

# 读取数据集
dataset = pd.read_csv('DOM_hourly.csv')

# 显示shape   
dataset.shape

(116189, 2)

# 默认显示前5行
dataset.head()

	Datetime	DOM_MW
0	2005-12-31 01:00:00	9389.0
1	2005-12-31 02:00:00	9070.0
2	2005-12-31 03:00:00	9001.0
3	2005-12-31 04:00:00	9042.0
4	2005-12-31 05:00:00	9132.0

# 显示数据描述
dataset.describe()

	DOM_MW
count	116189.000000
mean	10949.203625
std	2413.946569
min	1253.000000
25%	9322.000000
50%	10501.000000
75%	12378.000000
max	21651.000000

# 将字段Datetime数据类型转换为日期类型
dataset['Datetime'] = pd.to_datetime(dataset['Datetime'], format="%Y-%m-%d %H:%M:%S")
# 将字段Datetime设置为索引列
# 目的：后续基于索引来进行数据集的切分
dataset.index = dataset.Datetime
# 将原始的Datetime字段列删除
dataset.drop(columns=['datetime'], axis=1, inplace=True)
# 显示默认前5行
dataset.head()

Datetime	DOM_MW
2005-12-31 01:00:00	9389.0
2005-12-31 02:00:00	9070.0
2005-12-31 03:00:00	9001.0
2005-12-31 04:00:00	9042.0
2005-12-31 05:00:00	9132.0

# 可视化显示DOM_MW的数据分布情况

dataset['DOM_MW'].plot(figsize=(16,8))
plt.show()

数据分布情况

# 数据进行归一化
# 均值为0，标准差为1
scaler = MinMaxScaler()
# reshape(-1, 1) 第一个-1不管多少行，第二个1只是1列
dataset['DOM_MW'] = scaler.fit_transform(dataset['DOM_MW'].values.reshape(-1, 1))

# 可视化显示归一化后的数据分布情况

dataset['DOM_MW'].plot(figsize=(16,8))
plt.show()

3、特征工程

# 功能函数：构造特征数据集和标签集
def create_new_dataset(dataset, seq_len = 12):
    '''基于原始数据集构造新的序列特征数据集
    Params:
        dataset : 原始数据集
        seq_len : 序列长度（时间跨度） 滑动窗口
    
    Returns:
        X, y
    '''
    X = [] # 初始特征数据集为空列表
    y = [] # 初始标签数据集为空列表
    
    start = 0 # 初始位置
    end = dataset.shape[0] - seq_len # 截止位置
    
    for i in range(start, end): # for循环构造特征数据集
        sample = dataset[i : i+seq_len] # 基于时间跨度seq_len创建样本
        label = dataset[i+seq_len] # 创建sample对应的标签
        X.append(sample) # 保存sample
        y.append(label) # 保存label
    
    # 返回特征数据集和标签集
    return np.array(X), np.array(y)
    
    
# 功能函数：基于新的特征的数据集和标签集，切分：X_train, X_test
# 千万不能打乱数据 要有时序
def split_dataset(X, y, train_ratio=0.8):
    '''基于X和y，切分为train和test
    Params:
        X : 特征数据集
        y : 标签数据集
        train_ratio : 训练集占X的比例
    
    Returns:
        X_train, X_test, y_train, y_test
    '''
    X_len = len(X) # 特征数据集X的样本数量
    train_data_len = int(X_len * train_ratio) # 训练集的样本数量
    
    X_train = X[:train_data_len] # 训练集
    y_train = y[:train_data_len] # 训练标签集
    
    X_test = X[train_data_len:] # 测试集
    y_test = y[train_data_len:] # 测试集标签集
    
    # 返回值
    return X_train, X_test, y_train, y_test

# 功能函数：基于新的X_train, X_test, y_train, y_test创建批数据(batch dataset)
def create_batch_data(X, y, batch_size=32, data_type=1):
    '''基于训练集和测试集，创建批数据
    Params:
        X : 特征数据集
        y : 标签数据集
        batch_size : batch的大小，即一个数据块里面有几个样本
        data_type : 数据集类型（测试集表示1，训练集表示2）
   
    Returns:
        train_batch_data 或 test_batch_data
    '''
    if data_type == 1: # 测试集
        dataset = tf.data.Dataset.from_tensor_slices((tf.constant(X), tf.constant(y))) # 封装X和y，成为tensor类型 
        test_batch_data = dataset.batch(batch_size) # 构造批数据
        # 返回
        return test_batch_data
    else: # 训练集
        dataset = tf.data.Dataset.from_tensor_slices((tf.constant(X), tf.constant(y))) # 封装X和y，一一对应，成为tensor类型
        # 训练集数据量较大，可以加载到内存中去 打乱1000 获得更好地泛化性能
        train_batch_data = dataset.cache().shuffle(1000).batch(batch_size) # 构造批数据
        # 返回
        return train_batch_data

# ① 原始数据集
dataset_original = dataset

# ② 构造特征数据集和标签集，seq_len序列长度为12小时
SEQ_LEN = 12 # 序列长度
X, y = create_new_dataset(dataset_original.values, seq_len = SEQ_LEN)

# ③ 数据集切分
X_train, X_test, y_train, y_test = split_dataset(X, y, train_ratio=0.9)

# 训练集和数据集的形状
# X_train.shape (104559, 12, 1)
# y_train.shape (104559, 1)
# X_test.shape  (11618, 12, 1)
# y_test.shape  (11618, 1)

# ④ 基于新的X_train, X_test, y_train, y_test创建批数据(batch dataset)
# 测试批数据
test_batch_dataset = create_batch_data(X_test, y_test, batch_size=256, data_type=1)

# 训练批数据
train_batch_dataset = create_batch_data(X_train, y_train, batch_size=256, data_type=2)

4、构建模型

model = Sequential([
    # SEQ_LEN = 20 
    layers.LSTM(8, input_shape=(SEQ_LEN, 1)),
    #全连接层只有一个预测值
    layers.Dense(1)
])

# 定义 checkpoint，保存权重文件
file_path = "best_checkpoint.hdf5"
# 最小损失权重
checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(filepath=file_path, 
                                                         monitor='loss', 
                                                         mode='min', 
                                                         save_best_only=True,
                                                         save_weights_only=True)

5、模型编译、训练、验证

# 模型编译
model.compile(optimizer='adam', loss="mae")

# 模型训练
history = model.fit(train_batch_dataset,
          epochs=20,
          validation_data=test_batch_dataset,
          callbacks=[checkpoint_callback])

# 显示 train loss 和 val loss
plt.figure(figsize=(16,8))
plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='val loss')
plt.title("LOSS")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend(loc='best')
plt.show()

# 模型验证
test_pred = model.predict(X_test, verbose=1)

# 计算r2
score = r2_score(y_test, test_pred)
print("r^2 的值： ", score)

r^2 的值： 0.9615476372915489

# 绘制模型验证结果

plt.figure(figsize=(16,8))
plt.plot(y_test, label="True label")
plt.plot(test_pred, label="Pred label")
plt.title("True vs Pred")
plt.legend(loc='best')
plt.show()

# 绘制test中前100个点的真值与预测值

y_true = y_test[:1000]
y_pred = test_pred[:1000]
plt.figure(figsize=(16, 8))
plt.plot(y_true, marker='o', color='red')
plt.plot(y_pred, marker='*', color='blue')
plt.show()

6、模型测试

预测1个样本

# 选择test中的最后一个样本
sample = X_test[-1] # (12, 1)
sample = sample.reshape(1, sample.shape[0], 1) # (1, 12, 1)

# 模型预测
sample_pred = model.predict(sample)

array([[0.7783012]], dtype=float32)

预测后续20个点的值

ture_data = X_test[-1] # 真实test的最后20个数据点 (12, 1)

array([[0.73982743],
[0.72595352],
[0.70825571],
[0.69791156],
[0.70619669],
[0.74360231],
[0.81125601],
[0.83321894],
[0.84150407],
[0.84880871],
[0.83606236],
[0.81189332]])

def predict_next(model, sample, epoch=20):
    temp1 = list(sample[:,0])
    for i in range(epoch):
        sample = sample.reshape(1, SEQ_LEN, 1)
        pred = model.predict(sample)
        value = pred.tolist()[0][0]
        temp1.append(value)
        sample = np.array(temp1[i+1 : i+SEQ_LEN+1])
    return temp1

preds = predict_next(model, ture_data, 20)
plt.figure(figsize=(12,6))
plt.plot(preds, color='yellow', label='Prediction')
plt.plot(ture_data, color='blue', label='Truth')
plt.xlabel("Epochs")
plt.ylabel("Value")
plt.legend(loc='best')
plt.show()