• 第85步 时间序列建模实战：CNN回归建模

    基于WIN10的64位系统演示

    一、写在前面

    这一期，我们介绍CNN回归。

    同样，这里使用这个数据：

    《PLoS One》2015年一篇题目为《Comparison of Two Hybrid Models for Forecasting the Incidence of Hemorrhagic Fever with Renal Syndrome in Jiangsu Province, China》文章的公开数据做演示。数据为江苏省2004年1月至2012年12月肾综合症出血热月发病率。运用2004年1月至2011年12月的数据预测2012年12个月的发病率数据。

    二、CNN回归

    （1）原理

    卷积神经网络（CNN）最初是为图像识别和处理而设计的，但它们已经被证明对于各种类型的序列数据，包括时间序列，也是有效的。以下是一些关于CNN在时间序列预测中应用的原理：

    （a）局部感受野:

    -CNN的关键特点是它的局部感受野，这意味着每个卷积核只查看输入数据的一个小部分。

    -对于时间序列，这意味着CNN可以捕获和学习模式中的短期依赖关系或周期性。

    -这类似于在时间序列分析中使用滑动窗口来捕获短期模式。

    （b）参数共享:

    -在CNN中，卷积核的权重在输入的所有部分上都是共享的。

    -这意味着网络可以在时间序列的任何位置都识别出相同的模式，增加了其泛化能力。

    （c）多尺度特征捕获:

    -通过使用多个卷积层和池化层，CNN能够在不同的时间尺度上捕获模式。

    -这使得它们能够捕获长期和短期的时间序列依赖关系。

    （d）堆叠结构:

    多层的CNN结构使得网络可以学习时间序列中的复杂和抽象的模式。例如，第一层可能会捕获简单的趋势或周期性，而更深层的网络可能会捕获更复杂的季节性模式或其他非线性关系。

    （e）自动特征学习:

    -传统的时间序列分析方法通常需要手动选择和构造特征。

    -使用CNN，网络可以自动从原始数据中学习和提取相关特征，这通常导致更好的性能和更少的手工工作。

    （f）时间序列的结构化特征:

    -和图像数据一样，时间序列数据也具有结构性。例如，过去的观察结果通常影响未来的观察结果。

    -CNN利用这种结构性，通过卷积操作从数据中提取局部和全局的时间模式。

    总之，虽然CNN最初是为图像设计的，但它们在处理序列数据，特别是时间序列数据时，已经显示出了很强的潜力。这是因为它们可以自动从数据中学习重要的特征，捕获多种尺度的模式，并适应时间序列中的短期和长期依赖关系。

    （2）单步滚动预测

    1. import pandas as pd
    2. import numpy as np
    3. from sklearn.metrics import mean_absolute_error, mean_squared_error
    4. from tensorflow.python.keras.models import Sequential
    5. from tensorflow.python.keras.layers import Dense, Conv1D, Flatten, MaxPooling1D
    6. from tensorflow.python.keras.optimizers import adam_v2
    7.  
    8. # 读取数据
    9. data = pd.read_csv('data.csv')
    10.  
    11. # 将时间列转换为日期格式
    12. data['time'] = pd.to_datetime(data['time'], format='%b-%y')
    13.  
    14. # 创建滞后期特征
    15. lag_period = 6
    16. for i in range(lag_period, 0, -1):
    17.     data[f'lag_{i}'] = data['incidence'].shift(lag_period - i + 1)
    18.  
    19. # 删除包含 NaN 的行
    20. data = data.dropna().reset_index(drop=True)
    21.  
    22. # 划分训练集和验证集
    23. train_data = data[(data['time'] >= '2004-01-01') & (data['time'] <= '2011-12-31')]
    24. validation_data = data[(data['time'] >= '2012-01-01') & (data['time'] <= '2012-12-31')]
    25.  
    26. # 定义特征和目标变量
    27. X_train = train_data[['lag_1', 'lag_2', 'lag_3', 'lag_4', 'lag_5', 'lag_6']].values
    28. y_train = train_data['incidence'].values
    29. X_validation = validation_data[['lag_1', 'lag_2', 'lag_3', 'lag_4', 'lag_5', 'lag_6']].values
    30. y_validation = validation_data['incidence'].values
    31.  
    32. # 对于CNN，我们需要将输入数据重塑为3D格式 [samples, timesteps, features]
    33. X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
    34. X_validation = X_validation.reshape(X_validation.shape[0], X_validation.shape[1], 1)
    35.  
    36. # 构建CNN模型
    37. model = Sequential()
    38. model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train.shape[1], 1)))
    39. model.add(MaxPooling1D(pool_size=2))
    40. model.add(Flatten())
    41. model.add(Dense(50, activation='relu'))
    42. model.add(Dense(1))
    43.  
    44. model.compile(optimizer=adam_v2.Adam(learning_rate=0.001), loss='mse')
    45.  
    46. # 训练模型
    47. history = model.fit(X_train, y_train, epochs=200, batch_size=32, validation_data=(X_validation, y_validation), verbose=0)
    48.  
    49. # 单步滚动预测函数
    50. def rolling_forecast(model, initial_features, n_forecasts):
    51.     forecasts = []
    52.     current_features = initial_features.copy()
    53.     
    54.     for i in range(n_forecasts):
    55.         # 使用当前的特征进行预测
    56.         forecast = model.predict(current_features.reshape(1, len(current_features), 1)).flatten()[0]
    57.         forecasts.append(forecast)
    58.         
    59.         # 更新特征，用新的预测值替换最旧的特征
    60.         current_features = np.roll(current_features, shift=-1)
    61.         current_features[-1] = forecast
    62.     
    63.     return np.array(forecasts)
    64.  
    65. # 使用训练集的最后6个数据点作为初始特征
    66. initial_features = X_train[-1].flatten()
    67.  
    68. # 使用单步滚动预测方法预测验证集
    69. y_validation_pred = rolling_forecast(model, initial_features, len(X_validation))
    70.  
    71. # 计算训练集上的MAE, MAPE, MSE 和 RMSE
    72. mae_train = mean_absolute_error(y_train, model.predict(X_train).flatten())
    73. mape_train = np.mean(np.abs((y_train - model.predict(X_train).flatten()) / y_train))
    74. mse_train = mean_squared_error(y_train, model.predict(X_train).flatten())
    75. rmse_train = np.sqrt(mse_train)
    76.  
    77. # 计算验证集上的MAE, MAPE, MSE 和 RMSE
    78. mae_validation = mean_absolute_error(y_validation, y_validation_pred)
    79. mape_validation = np.mean(np.abs((y_validation - y_validation_pred) / y_validation))
    80. mse_validation = mean_squared_error(y_validation, y_validation_pred)
    81. rmse_validation = np.sqrt(mse_validation)
    82.  
    83. print("验证集：", mae_validation, mape_validation, mse_validation, rmse_validation)
    84. print("训练集：", mae_train, mape_train, mse_train, rmse_train)

    看结果：

    （3）多步滚动预测-vol. 1

    1. import pandas as pd
    2. import numpy as np
    3. from sklearn.metrics import mean_absolute_error, mean_squared_error
    4. from tensorflow.python.keras.models import Sequential
    5. from tensorflow.python.keras.layers import Dense, Conv1D, Flatten, MaxPooling1D
    6. from tensorflow.python.keras.optimizers import adam_v2
    7.  
    8. # 读取数据
    9. data = pd.read_csv('data.csv')
    10. data['time'] = pd.to_datetime(data['time'], format='%b-%y')
    11.  
    12. n = 6
    13. m = 2
    14.  
    15. # 创建滞后期特征
    16. for i in range(n, 0, -1):
    17.     data[f'lag_{i}'] = data['incidence'].shift(n - i + 1)
    18.  
    19. data = data.dropna().reset_index(drop=True)
    20.  
    21. train_data = data[(data['time'] >= '2004-01-01') & (data['time'] <= '2011-12-31')]
    22. validation_data = data[(data['time'] >= '2012-01-01') & (data['time'] <= '2012-12-31')]
    23.  
    24. # 准备训练数据
    25. X_train = []
    26. y_train = []
    27.  
    28. for i in range(len(train_data) - n - m + 1):
    29.     X_train.append(train_data.iloc[i+n-1][[f'lag_{j}' for j in range(1, n+1)]].values)
    30.     y_train.append(train_data.iloc[i+n:i+n+m]['incidence'].values)
    31.  
    32. X_train = np.array(X_train)
    33. y_train = np.array(y_train)
    34. X_train = X_train.astype(np.float32)
    35. y_train = y_train.astype(np.float32)
    36.  
    37.  
    38. # 为CNN准备数据
    39. X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
    40.  
    41. # 构建CNN模型
    42. model = Sequential()
    43. model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train.shape[1], 1)))
    44. model.add(MaxPooling1D(pool_size=2))
    45. model.add(Flatten())
    46. model.add(Dense(50, activation='relu'))
    47. model.add(Dense(m))
    48.  
    49. model.compile(optimizer=adam_v2.Adam(learning_rate=0.001), loss='mse')
    50.  
    51. # 训练模型
    52. model.fit(X_train, y_train, epochs=200, batch_size=32, verbose=0)
    53.  
    54. def cnn_rolling_forecast(data, model, n, m):
    55.     y_pred = []
    56.  
    57.     for i in range(len(data) - n):
    58.         input_data = data.iloc[i+n-1][[f'lag_{j}' for j in range(1, n+1)]].values.astype(np.float32).reshape(1, n, 1)
    59.         pred = model.predict(input_data)
    60.         y_pred.extend(pred[0])
    61.  
    62.     # Handle overlapping predictions by averaging
    63.     for i in range(1, m):
    64.         for j in range(len(y_pred) - i):
    65.             y_pred[j+i] = (y_pred[j+i] + y_pred[j]) / 2
    66.  
    67.     return np.array(y_pred)
    68.  
    69. # Predict for train_data and validation_data
    70. y_train_pred_cnn = cnn_rolling_forecast(train_data, model, n, m)[:len(y_train)]
    71. y_validation_pred_cnn = cnn_rolling_forecast(validation_data, model, n, m)[:len(validation_data) - n]
    72.  
    73. # Calculate performance metrics for train_data
    74. mae_train = mean_absolute_error(train_data['incidence'].values[n:len(y_train_pred_cnn)+n], y_train_pred_cnn)
    75. mape_train = np.mean(np.abs((train_data['incidence'].values[n:len(y_train_pred_cnn)+n] - y_train_pred_cnn) / train_data['incidence'].values[n:len(y_train_pred_cnn)+n]))
    76. mse_train = mean_squared_error(train_data['incidence'].values[n:len(y_train_pred_cnn)+n], y_train_pred_cnn)
    77. rmse_train = np.sqrt(mse_train)
    78.  
    79. # Calculate performance metrics for validation_data
    80. mae_validation = mean_absolute_error(validation_data['incidence'].values[n:len(y_validation_pred_cnn)+n], y_validation_pred_cnn)
    81. mape_validation = np.mean(np.abs((validation_data['incidence'].values[n:len(y_validation_pred_cnn)+n] - y_validation_pred_cnn) / validation_data['incidence'].values[n:len(y_validation_pred_cnn)+n]))
    82. mse_validation = mean_squared_error(validation_data['incidence'].values[n:len(y_validation_pred_cnn)+n], y_validation_pred_cnn)
    83. rmse_validation = np.sqrt(mse_validation)
    84.  
    85.  
    86. print("训练集：", mae_train, mape_train, mse_train, rmse_train)
    87. print("验证集：", mae_validation, mape_validation, mse_validation, rmse_validation)

    结果：

    （4）多步滚动预测-vol. 2

    1. import pandas as pd
    2. import numpy as np
    3. from sklearn.model_selection import train_test_split
    4. from sklearn.metrics import mean_absolute_error, mean_squared_error
    5. from tensorflow.python.keras.models import Sequential
    6. from tensorflow.python.keras.layers import Dense, Conv1D, Flatten, MaxPooling1D
    7. from tensorflow.python.keras.optimizers import adam_v2
    8.  
    9. # Loading and preprocessing the data
    10. data = pd.read_csv('data.csv')
    11. data['time'] = pd.to_datetime(data['time'], format='%b-%y')
    12.  
    13. n = 6  # 使用前6个数据点
    14. m = 2  # 预测接下来的2个数据点
    15.  
    16. # 创建滞后期特征
    17. for i in range(n, 0, -1):
    18.     data[f'lag_{i}'] = data['incidence'].shift(n - i + 1)
    19.  
    20. data = data.dropna().reset_index(drop=True)
    21.  
    22. train_data = data[(data['time'] >= '2004-01-01') & (data['time'] <= '2011-12-31')]
    23. validation_data = data[(data['time'] >= '2012-01-01') & (data['time'] <= '2012-12-31')]
    24.  
    25. # 只对X_train、y_train、X_validation取奇数行
    26. X_train = train_data[[f'lag_{i}' for i in range(1, n+1)]].iloc[::2].reset_index(drop=True).values
    27. X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)  # Reshape for CNN
    28.  
    29. # 创建m个目标变量
    30. y_train_list = [train_data['incidence'].shift(-i) for i in range(m)]
    31. y_train = pd.concat(y_train_list, axis=1)
    32. y_train.columns = [f'target_{i+1}' for i in range(m)]
    33. y_train = y_train.iloc[::2].reset_index(drop=True).dropna().values[:, 0]  # Only take the first column for simplicity
    34.  
    35. X_validation = validation_data[[f'lag_{i}' for i in range(1, n+1)]].iloc[::2].reset_index(drop=True).values
    36. X_validation = X_validation.reshape(X_validation.shape[0], X_validation.shape[1], 1)  # Reshape for CNN
    37.  
    38. y_validation = validation_data['incidence'].values
    39.  
    40. # Building the CNN model
    41. model = Sequential()
    42. model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train.shape[1], 1)))
    43. model.add(MaxPooling1D(pool_size=2))
    44. model.add(Flatten())
    45. model.add(Dense(50, activation='relu'))
    46. model.add(Dense(1))
    47.  
    48. optimizer = adam_v2.Adam(learning_rate=0.001)
    49. model.compile(optimizer=optimizer, loss='mse')
    50.  
    51. # Train the model
    52. model.fit(X_train, y_train, epochs=200, batch_size=32, verbose=0)
    53.  
    54. # Predict on validation set
    55. y_validation_pred = model.predict(X_validation).flatten()
    56.  
    57. # Compute metrics for validation set
    58. mae_validation = mean_absolute_error(y_validation[:len(y_validation_pred)], y_validation_pred)
    59. mape_validation = np.mean(np.abs((y_validation[:len(y_validation_pred)] - y_validation_pred) / y_validation[:len(y_validation_pred)]))
    60. mse_validation = mean_squared_error(y_validation[:len(y_validation_pred)], y_validation_pred)
    61. rmse_validation = np.sqrt(mse_validation)
    62.  
    63. # Predict on training set
    64. y_train_pred = model.predict(X_train).flatten()
    65.  
    66. # Compute metrics for training set
    67. mae_train = mean_absolute_error(y_train, y_train_pred)
    68. mape_train = np.mean(np.abs((y_train - y_train_pred) / y_train))
    69. mse_train = mean_squared_error(y_train, y_train_pred)
    70. rmse_train = np.sqrt(mse_train)
    71.  
    72. print("验证集：", mae_validation, mape_validation, mse_validation, rmse_validation)
    73. print("训练集：", mae_train, mape_train, mse_train, rmse_train)

    结果：

    （5）多步滚动预测-vol. 3

    1. import pandas as pd
    2. import numpy as np
    3. from sklearn.metrics import mean_absolute_error, mean_squared_error
    4. from tensorflow.python.keras.models import Sequential
    5. from tensorflow.python.keras.layers import Dense, Conv1D, Flatten, MaxPooling1D
    6. from tensorflow.python.keras.optimizers import adam_v2
    7.  
    8. # 数据读取和预处理
    9. data = pd.read_csv('data.csv')
    10. data_y = pd.read_csv('data.csv')
    11. data['time'] = pd.to_datetime(data['time'], format='%b-%y')
    12. data_y['time'] = pd.to_datetime(data_y['time'], format='%b-%y')
    13.  
    14. n = 6
    15.  
    16. for i in range(n, 0, -1):
    17.     data[f'lag_{i}'] = data['incidence'].shift(n - i + 1)
    18.  
    19. data = data.dropna().reset_index(drop=True)
    20. train_data = data[(data['time'] >= '2004-01-01') & (data['time'] <= '2011-12-31')]
    21. X_train = train_data[[f'lag_{i}' for i in range(1, n+1)]]
    22. m = 3
    23.  
    24. X_train_list = []
    25. y_train_list = []
    26.  
    27. for i in range(m):
    28.     X_temp = X_train
    29.     y_temp = data_y['incidence'].iloc[n + i:len(data_y) - m + 1 + i]
    30.     
    31.     X_train_list.append(X_temp)
    32.     y_train_list.append(y_temp)
    33.  
    34. for i in range(m):
    35.     X_train_list[i] = X_train_list[i].iloc[:-(m-1)].values
    36.     X_train_list[i] = X_train_list[i].reshape(X_train_list[i].shape[0], X_train_list[i].shape[1], 1)  # Reshape for CNN
    37.     y_train_list[i] = y_train_list[i].iloc[:len(X_train_list[i])].values
    38.  
    39. # 模型训练
    40. models = []
    41. for i in range(m):
    42.     # Build CNN model
    43.     model = Sequential()
    44.     model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train_list[i].shape[1], 1)))
    45.     model.add(MaxPooling1D(pool_size=2))
    46.     model.add(Flatten())
    47.     model.add(Dense(50, activation='relu'))
    48.     model.add(Dense(1))
    49.  
    50.     optimizer = adam_v2.Adam(learning_rate=0.001)
    51.     model.compile(optimizer=optimizer, loss='mse')
    52.     model.fit(X_train_list[i], y_train_list[i], epochs=200, batch_size=32, verbose=0)
    53.     models.append(model)
    54.  
    55. validation_start_time = train_data['time'].iloc[-1] + pd.DateOffset(months=1)
    56. validation_data = data[data['time'] >= validation_start_time]
    57. X_validation = validation_data[[f'lag_{i}' for i in range(1, n+1)]].values
    58. X_validation = X_validation.reshape(X_validation.shape[0], X_validation.shape[1], 1)  # Reshape for CNN
    59.  
    60. y_validation_pred_list = [model.predict(X_validation) for model in models]
    61. y_train_pred_list = [model.predict(X_train_list[i]) for i, model in enumerate(models)]
    62.  
    63. def concatenate_predictions(pred_list):
    64.     concatenated = []
    65.     for j in range(len(pred_list[0])):
    66.         for i in range(m):
    67.             concatenated.append(pred_list[i][j])
    68.     return concatenated
    69.  
    70. y_validation_pred = np.array(concatenate_predictions(y_validation_pred_list))[:len(validation_data['incidence'])]
    71. y_train_pred = np.array(concatenate_predictions(y_train_pred_list))[:len(train_data['incidence']) - m + 1]
    72. y_validation_pred = y_validation_pred.flatten()
    73. y_train_pred = y_train_pred.flatten()
    74.  
    75. mae_validation = mean_absolute_error(validation_data['incidence'], y_validation_pred)
    76. mape_validation = np.mean(np.abs((validation_data['incidence'] - y_validation_pred) / validation_data['incidence']))
    77. mse_validation = mean_squared_error(validation_data['incidence'], y_validation_pred)
    78. rmse_validation = np.sqrt(mse_validation)
    79.  
    80. mae_train = mean_absolute_error(train_data['incidence'][:-(m-1)], y_train_pred)
    81. mape_train = np.mean(np.abs((train_data['incidence'][:-(m-1)] - y_train_pred) / train_data['incidence'][:-(m-1)]))
    82. mse_train = mean_squared_error(train_data['incidence'][:-(m-1)], y_train_pred)
    83. rmse_train = np.sqrt(mse_train)
    84.  
    85. print("验证集：", mae_validation, mape_validation, mse_validation, rmse_validation)
    86. print("训练集：", mae_train, mape_train, mse_train, rmse_train)

    结果：

    三、写在后面

    本例中，我们只搭建了一个简单的CNN网络。具体实践中，大家可以换成其他的CNN网络结构，甚至是之前介绍的各种预训练模型，VGG19和各种Net系列，可能有惊喜或者惊吓哦。

    四、数据

    链接：https://pan.baidu.com/s/1EFaWfHoG14h15KCEhn1STg?pwd=q41n

    提取码：q41n

  • 相关阅读:
    docker安装mysql exporter并使用grafana+prometheus监控mysql
    【内存管理】从程序进入内存开始说起
    python——运行方式
    【STM32开发笔记】搭建VSCode+PyOCD的STM32开发环境
    Multi Scale Supervised 3D U-Net for Kidney and Tumor Segmentation
    C++ bool类型变量赋值true，输出结果却是false？是因为cin输入的true会被当成字符串，所以bool变量原值不变吗？
    05_Docker-Compose
    STM32 定时器配置不当导致误差(精度)偏大的问题发现与解决
    net-java-php-python-会议管理系统计算机毕业设计程序
    Redis常用命令
  • 原文地址：https://blog.csdn.net/qq_30452897/article/details/133636168