[免费开源]CEEMDAN-CNN-LSTM时间序列预测模型python代码

整理了CEEMDAN-CNN-LSTM的时间序列预测模型，免费分享给大家，记得点赞哦！

# 帅帅的笔者
# coding: utf-8

from keras.models import Sequential
from keras.layers import Conv1D, Add, Activation, Dropout, Dense, LSTM, Flatten, MaxPooling1D
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from PyEMD import CEEMDAN
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import random 
import warnings
from pylab import *
warnings.filterwarnings('ignore')

mpl.rcParams['font.sans-serif'] = ['Times New Roman']
matplotlib.rcParams['axes.unicode_minus']=False

# 调用GPU加速
gpus = tf.config.experimental.list_physical_devices(device_type='GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

LOOK_BACK = 10
SPLIT = 0.8
EPOCHS = 100
BATCH_SIZE = 100



data = pd.read_csv('天气.csv', usecols=[1])
data.columns = ["AQI"]
def get_CEEMD_residue(data: pd.DataFrame):
    data_np = data.to_numpy()
    
    ceemd = CEEMDAN()
    ceemd.extrema_detection="parabol"
    ceemd.ceemdan(data_np)
    IMFs, residue = ceemd.get_imfs_and_residue()

    nIMFs = IMFs.shape[0]
    
    plt.figure(figsize=(18,18),dpi=600)
    plt.subplot(nIMFs + 2, 1, 1)

    plt.plot(data, 'r')
    plt.ylabel("AQI")

    plt.subplot(nIMFs + 2, 1, nIMFs + 2)
    plt.plot(data.index, residue)
    plt.ylabel("Residue")

    for n in range(nIMFs):
        plt.subplot(nIMFs + 2, 1, n + 2)
        plt.plot(data.index, IMFs[n], 'k')
        plt.ylabel("eIMF %i" % (n + 1))
        plt.locator_params(axis='y', nbins=4)
 
    plt.tight_layout()
    plt.show()    
    return IMFs, residue, nIMFs

def plot_IMFs(IMFs: np.ndarray, residue: np.ndarray, num_IMFs: int, data: pd.DataFrame):
    sum_IMFs = sum(IMFs[-num_IMFs:])
    sum_IMFs += residue

    plt.figure(figsize=(12, 10))
    plt.plot(data.index, data, label="Stock Price")
    plt.plot(data.index, sum_IMFs, label=f"Last {num_IMFs} IMFs")
    plt.legend(loc="upper left")
    plt.show()

def create_dataset(dataset):
    dataX, dataY = [], []    
    for i in range(len(dataset) - LOOK_BACK - 1):        
        look_back_data = dataset[i:(i + LOOK_BACK), 0]
        dataX.append(look_back_data)
        dataY.append(dataset[i + LOOK_BACK, 0])        
    return np.array(dataX), np.array(dataY)



def LSTM_CNN_CBAM(dataset, layer = 128):
    
    dataset = dataset.astype('float64')
    dataset = np.reshape(dataset, (-1, 1))

    scaler = MinMaxScaler()
    dataset = scaler.fit_transform(dataset)
  

    train_size = int(len(dataset) * SPLIT)
    test_size = len(dataset) - train_size
    train, test = dataset[:train_size, :], dataset[train_size:, :]
  
    trainX, trainY = create_dataset(train)
    testX, testY = create_dataset(test)

    trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
    testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
  

    model = Sequential()
    model.add(LSTM(layer, input_shape=(1, LOOK_BACK), return_sequences=True))
    model.add(Conv1D(filters = 512, kernel_size = 1, activation='relu', input_shape = (1, LOOK_BACK)))
    model.add(MaxPooling1D(pool_size = 1))
    model.add(Dropout(0.2))
    model.add(Activation('relu'))
    model.add(Flatten())
    model.add(Dense(1))
    model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
    model.fit(trainX, trainY, epochs = EPOCHS, batch_size = BATCH_SIZE, verbose = 1, validation_split = 0.1)


    trainPredict = model.predict(trainX)
    testPredict = model.predict(testX)


    trainPredict = scaler.inverse_transform(trainPredict)
    trainY = scaler.inverse_transform([trainY])
    testPredict = scaler.inverse_transform(testPredict)
    testY = scaler.inverse_transform([testY])
    
    testing_error = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))

    return testPredict, testY, testing_error


def run_model(IMFs):    
    IMF_predict_list = []
    error_list = []
    for i, IMF in enumerate(IMFs):
        print(f"IMF number {i+1}")        
        IMF_predict, IMF_test, testing_error = LSTM_CNN_CBAM(IMF, layer = 128)
        error_list.append(testing_error)
        IMF_predict_list.append(IMF_predict)        
    return IMF_predict_list, error_list


def visualize_results(IMF_predict_list, error_list):       
    for i, v in enumerate(IMF_predict_list):        
        IMF_predict_list[i] = v[:, 0]    
    final_prediction = []
    for i in range(len(IMF_predict_list[0])):
        element = 0         
        for j in range(len(IMF_predict_list)):            
            element += IMF_predict_list[j][i]           
        final_prediction.append(element)
        
    data_plot = data.astype("float64")
    data_plot = np.reshape(data_plot.to_numpy(), (-1, 1))

    train_size = int(len(data_plot) * SPLIT)
    test_size = len(data_plot) - train_size
    data_plot_train, data_plot_test = data_plot[:train_size], data_plot[train_size:]

    data_plot_testX, data_plot_testY = create_dataset(data_plot_test)

    
    print('RMSE %.3f' %(np.sqrt(mean_squared_error(data_plot_testY.tolist(), final_prediction))))
    print('MAE %.3f' %(mean_absolute_error(data_plot_testY.tolist(), final_prediction)))
    print('R2 %.3f' %(r2_score(data_plot_testY.tolist(), final_prediction)))
    
    
    plt.figure(figsize=(18,5),dpi=200)
    # plot lines
    plt.plot(data.index[train_size + LOOK_BACK + 1: ], final_prediction, label = "Predicted Value")
    plt.plot(data.index[train_size + LOOK_BACK + 1: ], data_plot_testY.tolist(), label = "Actual Value")
    plt.legend()
    plt.show()


IMFs, residue, n = get_CEEMD_residue(data["AQI"])

IMF_predict_list, error_list = run_model(IMFs)


visualize_results(IMF_predict_list, error_list)

更多55+时间序列预测python代码领取：时间序列预测算法全集合--深度学习