基于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

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()

案例实现思路：

• 模块导入

• 加载数据集、预处理

• 特征工程

• 构建模型

• 模型编译、训练、验证

• 模型测试

• 结果可视化

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

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()