作者|Christophe Pere
編譯|VK
來源|Towards Datas Science
介紹
長期以來，我聽說時間序列問題只能用統計方法(AR[1]，AM[2]，ARMA[3]，ARIMA[4])，這些技術通常被數學家使用，他們試圖不斷改進這些技術來約束平穩和非平穩的時間序列，
幾個月前，我的一個朋友(數學家、統計學教授、非平穩時間序列專家)提出讓我研究如何驗證和改進重建恒星光照曲線的技術，事實上，開普勒衛星[11]和其他許多衛星一樣，無法連續測量附近恒星的光通量強度，開普勒衛星在2009年至2016年間致力于尋找太陽系外的行星，稱為太陽系外行星或系外行星，
正如你們所理解的，我們將比我們的行星地球走得更遠一點，并利用機器學習進入銀河之旅，天體物理學一直是我的摯愛，
這個notebook可以在Github上找到：https://github.com/Christophe-pere/Time_series_RNN，
RNN，LSTM，GRU，雙向，CNN-x
那么我們將在哪個模型上進行這項研究？我們將使用回圈神經網路(RNN[5])，LSTM[6]、GRU[7]、Stacked LSTM、Stacked GRU、雙向LSTM[8]、雙向GRU以及CNN-LSTM[9]，
對于那些熱衷于樹的人，你可以在這里找到一篇關于XGBoost和時間序列的文章，作者是jasonbrownley，github上提供了一個關于時間序列的很好的存盤庫：https://github.com/Jenniferz28/Time-Series-ARIMA-XGBOOST-RNN
對于那些不熟悉RNN家族的人，把它們看作是具有記憶效應和遺忘能力的學習方法，雙向來自體系結構，它是指兩個RNN，它將在一個方向(從左到右)和另一個方向(從右到左)“讀取”資料，以便能夠最好地表示長期依賴關系，
資料
如前文所述，這些資料對應于幾顆恒星的通量測量值，實際上，在每一個時間增量(小時)，衛星都會測量來自附近恒星的通量，這個通量，或者說是光強度，隨時間而變化，這有幾個原因，衛星的正確移動、旋轉、視角等都會有所不同，因此，測量到的光子數會發生變化，恒星是一個熔化的物質球(氫和氦聚變)，它有自己的運動，因此光子的發射取決于它的運動，這對應于光強度的波動，
但是，也可能有行星，系外行星，它們干擾恒星，甚至從恒星之間穿過衛星的視線(凌日方法[12])，這條通道遮住了恒星，衛星接收到的光子較少，因為它們被前面經過的行星擋住了(一個具體的例子是月球引起的日食)，
通量測量的集合被稱為光曲線，光曲線是什么樣子的？以下是一些示例：
不同恒星之間的通量非常不同，有的噪音很大，有的則很穩定，通量仍然呈現例外，在光照曲線中可以看到孔或缺少測量，我們的目標是看是否有可能在沒有測量的情況下預測光曲線的行為，
資料縮減
為了能夠使用模型中的資料，有必要進行資料簡化，這里將介紹兩種方法，移動平均法和視窗法，
移動平均線：
移動平均包括取X個連續點并計算它們的平均值，這種方法可以減少變異性，消除噪聲，這也減少了點的數量，這是一種下采樣方法，
下面的函式允許我們從點串列中計算移動平均值，方法計算點的平均值和標準差的數字，
def moving_mean(time, flux, lag=5):
'''
該函式通過設定平均值，使資料去噪，減少資料量，
@param time: (list) 時間值串列
@param flux: (list) 浮點串列->恒星通量
@param lag: (int) 平均值個數，默認值5
@return X: (list) 時間調整
@return y: (list) 通量按平均值重新標定
@return y_std: (list) 標準差串列
'''
# 讓我們做一些簡單的代碼
# 空串列
X = []
y = []
y_std = []
j = 0 # 增量
for i in range(int(len(flux)/lag)):
X.append(np.mean(time[(i+j):(i+j+lag)]))
y.append(np.mean(flux[(i+j):(i+j+lag)]))
y_std.append(np.std(flux[(i+j):(i+j+lag)]))
j+= lag
return X, y, y_stdn
可以看到函式在輸入中接受3個引數，時間和通量是時間序列的x和y，lag 是控制計算時間和通量平均值以及通量標準差時所考慮的資料個數，
現在，我們可以看看如何使用這個函式以及通過轉換得到的結果，
# #匯入所需的包
matplotlib inline
import scipy
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sklearn
import tensorflow as tf
# 讓我們看看進度條
from tqdm import tqdm
tqdm().pandas()
現在我們需要匯入資料，檔案kep_lightcurves.csv包含著資料，每顆恒星有4列，原始磁通量(“…orig”)，重新縮放的通量是原始磁通量減去平均磁通量(“…rscl’”)、差值(“…diff”)和殘差(“…_res”)，總共52列，
# 20個資料點
x, y, y_err = moving_mean(df.index,df["001724719_rscl"], 20)
df.index表示時間序列的時間
df[" 001724719_rscl "] 重新縮放的通量(" 001724719 ")
lag=20是計算平均值和std的資料點的個數
前面3條光照曲線的結果：
視窗方法
第二種方法是視窗方法，它是如何作業的？
你需要取很多點，在前一個例子中是20，然后計算平均值(與前面的方法沒有區別)，這個點是新時間序列的開始，它在位置20(偏移19個點)，但是，視窗不是移動到下20個點，而是移動一個點，用之前的20個點計算平均值，然后通過向后移動一步，以此類推，
這不是一種下采樣方法，而是一種清理方法，因為其效果是平滑資料點，
讓我們看看代碼：
def mean_sliding_windows(time, flux, lag=5):
'''
該函式通過設定平均值，使資料去噪，
@param time: (list) 時間值串列
@param flux: (list) 浮點串列->恒星通量
@param lag: (int) 平均值個數，默認值5
@return X: (list) 時間調整
@return y: (list) 通量按平均值重新標定
@return y_std: (list) 標準差串列
'''
# 讓我們做一些簡單的代碼
# 空串列
X = []
y = []
y_std = []
j = 0 # 增量
for i in range(int(len(flux)-lag)):
_flux = flux[i:(i+lag)]
_time = time[i:(i+lag)]
X.append(np.mean(_time))
y.append(np.mean(_flux))
y_std.append(np.std(_flux))
j+= 1 # 我們只移動一步
return X, y, y_std
你可以很容易地這樣使用它：
# 使用20個點
x, y, y_err = mean_sliding_windows(df.index,df["001724719_rscl"], 40)
df.index表示時間序列的時間
df[" 001724719_rscl "] 重新縮放的通量(" 001724719 ")
lag=40是計算平均值和std的資料點的個數
現在，看看結果：
嗯，還不錯，將lag設定為40允許“預測”或在小孔中擴展新的時間序列，但是，如果你仔細看，你會發現在紅線的開始和結束部分有一個分歧，可以改進函式以避免這些偽影，
在接下來的研究中，我們將使用移動平均法獲得的時間序列，
將x軸從值更改為日期：
如果需要日期，可以更改軸，開普勒任務開始于2009年3月7日，結束于2017年，Pandas有一個叫做pd.data_range()的函式，此函式允許你從不斷遞增的串列中創建日期，
df.index = pd.date_range(‘2009–03–07’, periods=len(df.index), freq=’h’)
這行代碼將創建一個頻率為小時的新索引，列印結果如下所示，
$ df.index
DatetimeIndex(['2009-03-07 00:00:00', '2009-03-07 01:00:00',
'2009-03-07 02:00:00', '2009-03-07 03:00:00',
'2009-03-07 04:00:00', '2009-03-07 05:00:00',
'2009-03-07 06:00:00', '2009-03-07 07:00:00',
'2009-03-07 08:00:00', '2009-03-07 09:00:00',
...
'2017-04-29 17:00:00', '2017-04-29 18:00:00',
'2017-04-29 19:00:00', '2017-04-29 20:00:00',
'2017-04-29 21:00:00', '2017-04-29 22:00:00',
'2017-04-29 23:00:00', '2017-04-30 00:00:00',
'2017-04-30 01:00:00', '2017-04-30 02:00:00'],
dtype='datetime64[ns]', length=71427, freq='H')
現在，對于原始時間序列，你有了一個很好的時間刻度，
生成資料集
因此，既然已經創建了資料簡化函式，我們可以將它們組合到另一個函式中(如下所示)，該函式將考慮初始資料集和資料集中的恒星名稱(這部分可以在函式中完成)，
def reduced_data(df,stars):
'''
Function to automatically reduced a dataset
@param df: (pandas dataframe) 包含所有資料的dataframe
@param stars: (list) 包含我們想要簡化資料的每個恒星的名稱的串列
@return df_mean: 包含由減少平均值的資料的dataframe
@return df_slide: 包含通過滑動視窗方法減少的資料
'''
df_mean = pd.DataFrame()
df_slide = pd.DataFrame()
for i in tqdm(stars):
x , y, y_std = moving_average(df.index, df[i+"_rscl"], lag=25)
df_mean[i+"_rscl_x"] = x
df_mean[i+"_rscl_y"] = y
df_mean[i+"_rscl_y_std"] = y_std
x , y, y_std = mean_sliding_windows(df.index, df[i+"_rscl"], lag=40)
df_slide[i+"_rscl_x"]= x
df_slide[i+"_rscl_y"]= y
df_slide[i+"_rscl_y_std"]= y_std
return df_mean, df_slide
要生成新的資料幀，請執行以下操作：
stars = df.columns
stars = list(set([i.split("_")[0] for i in stars]))
print(f"The number of stars available is: {len(stars)}")
> The number of stars available is: 13
我們有13顆恒星，有4種資料型別，對應52列，
df_mean, df_slide = reduced_data(df,stars)
很好，在這一點上，你有兩個新的資料集，其中包含移動平均和視窗方法減少的資料，
方法
準備資料：
為了使用機器學習演算法來預測時間序列，必須相應地準備資料，資料不能僅僅設定在(x，y)個資料點，資料必須采用序列[x1，x2，x3，…，xn]和預測值y的形式，
下面的函式演示如何設定資料集：
def create_dataset(values, look_back=1):
'''
函式準備一列(x, y)資料指向用于時間序列學習的資料
@param values: (list) 值串列
@param look_back: (int) x串列的值[x1, x2, x3，…默認值1
@return _x: x時間序列的值
@return _y: y時間序列的值
'''
# 空串列
_x, _y = [], []
for i in range(len(values)-look_back-1):
a = values[i:(i+look_back)]
_x.append(a) # 集合x
_y.append(values[i + look_back]) # 集合y
return np.array(_x), np.array(_y)
開始之前有兩件重要的事，
1.需要重新縮放資料
當資料在[0,1]范圍內時，深度學習演算法對時間序列的預測效果更好，為此，scikit learn提供了MinMaxScaler()函式，你可以配置feature_range引數，但默認值為(0，1)，并清除nan值的資料(如果不洗掉nan值，則損失函式將輸出nan)，
# 縮放資料
num = 2 # 選擇資料集中的第三顆星
values = df_model[stars[num]+"_rscl_y"].values # 提取值
scaler = MinMaxScaler(feature_range=(0, 1)) # 創建MinMaxScaler的實體
dataset = scaler.fit_transform(values[~np.isnan(values)].reshape(-1, 1)) # 資料將清除nan值，重新縮放并改變形狀
2.需要將資料轉換為x list和y
現在，我們將使用create_values()函式為模型生成資料，但是，以前，我更喜歡通過以下方式保存原始資料：
df_model = df_mean.save()
# 分成訓練和測驗集sets
train_size = int(len(dataset) * 0.8) # 生成80%的訓練資料
train = dataset[:train_size] # 設定訓練資料
test = dataset[train_size:] # 設定測驗資料
#重塑為X=t和Y=t+1
look_back = 20
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# 將輸入重塑為[示例、時間點、特征]
trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))
看看結果吧
trainX[0]
> array([[0.7414906],
[0.76628096],
[0.79901113],
[0.62779976],
[0.64012722],
[0.64934765],
[0.68549234],
[0.64054092],
[0.68075644],
[0.73782449],
[0.68319294],
[0.64330245],
[0.61339268],
[0.62758265],
[0.61779702],
[0.69994317],
[0.64737128],
[0.64122564],
[0.62016833],
[0.47867125]]) # x資料的第一個有20個值
trainY[0]
> array([0.46174275]) # 對應的y值
度量
我們用什么指標來預測時間序列？我們可以使用平均絕對誤差和均方誤差，它們由函式給出：
def metrics_time_series(y_true, y_pred):
'''
從sklearn.metrics計算MAE和MSE度量
@param y_true: (list) 真實值串列
@param y_pred: (list) 預測值串列
@return mae, mse: (float), (float) mae和mse的度量值
'''
mae = round(mean_absolute_error(y_true, y_pred), 2)
mse = round(mean_squared_error(y_true, y_pred), 2)
print(f"The mean absolute error is: {mae}")
print(f"The mean squared error is: {mse}")
return mae, mse
首先需要匯入函式：
from sklearn.metrics import mean_absolute_error, mean_squared_error
RNNs：
你可以用幾行代碼輕松地用Keras實作RNN家族，在這里你可以使用這個功能來配置你的RNN，你需要首先從Keras匯入不同的模型，如：
# 匯入一些包
import tensorflow as tf
from keras.layers import SimpleRNN, LSTM, GRU, Bidirectional, Conv1D, MaxPooling1D, Dropout
現在，我們有從Keras匯入的模型，下面的函式可以生成一個簡單的模型(SimpleRNN，LSTM，GRU)，或者，兩個模型(相同的)可以堆疊，或者用于雙向或兩個雙向模型的堆疊中，你還可以添加帶有MaxPooling1D和dropout的CNN部分(Conv1D)，
def time_series_deep_learning(x_train, y_train, x_test, y_test, model_dl=LSTM , unit=4, look_back=20, cnn=False, bidirection=False, stacked=False):
'''
生成不同組合的RNN模型，可以是簡單的、堆疊的或雙向的，模型也可以與CNN部分一起使用，
x是(樣本、時間步長、特征)的訓練資料
@param x_train: (matrix) 訓練資料，維度為 (samples, time steps, features)
@param y_train: (list) 預測
@param x_test: (matrix) 測驗資料，維度為 (samples, time steps, features)
@param y_test: (list) 預測
@param model_dl: (model) RNN型別
@param unit: (int) RNN單元數量
@param look_back: (int) x串列中值的數量，配置RNN的形狀
@param cnn: (bool) 添加cnn部分模型，默認為false
@param bidirection: (bool) 為RNN添加雙向模型，默認為false
@param stacked: (bool) 堆疊的兩層RNN模型，默認為假
@return train_predict: (list) x_train的預測值
@return train_y: (list) 真實y值
@return test_predict: (list) x_test的預測值
@return test_y: (list) 真實y值
@return (dataframe) 包含模型和度量的名稱
'''
#配置提前停止的回呼，以避免過擬合
es = tf.keras.callbacks.EarlyStopping(
monitor='loss', patience=5, verbose=0, mode='auto',
)
# 序列模型的實體
model = Sequential()
if cnn: # 如果cnn部分是需要的
print("CNN")
model.add(Conv1D(128, 5, activation='relu'))
model.add(MaxPooling1D(pool_size=4))
model.add(Dropout(0.2))
if not bidirection and not stacked: # 如果需要簡單的模型
print("Simple Model")
name = model_dl.__name__
model.add(model_dl(unit, input_shape=(look_back, 1)))
elif not bidirection: # 測驗是否需要雙向模型
print("Stacked Model")
name = "Stacked_"+model_dl.__name__
model.add(model_dl(unit, input_shape=(look_back, 1), return_sequences=True))
model.add(model_dl(unit, input_shape=(look_back, 1)))
elif not stacked: # 測驗是否需要堆疊模型
print("Bidirectional Model")
name = "Bi_"+model_dl.__name__
model.add(Bidirectional(model_dl(unit, input_shape=(look_back, 1))))
else: # 測驗是否需要雙向和堆疊模型
print("Stacked Bidirectional Model")
name = "Stacked_Bi_"+model_dl.__name__
model.add(Bidirectional(model_dl(unit, input_shape=(look_back, 1), return_sequences=True)))
model.add(Bidirectional(model_dl(unit, input_shape=(look_back, 1))))
if cnn: # 更新名稱與cnn部分
name = "CNN_"+name
# 添加單層稠密層和激活函式線性來預測連續值
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam') # MSE loss可以被'mean_absolute_error'替代
model.fit(trainX, trainY, epochs=1000, batch_size=100, callbacks=[es], verbose=0)
# 做出預測
train_predict = model.predict(x_train)
test_predict = model.predict(x_test)
# 反預測
train_predict = scaler.inverse_transform(train_predict)
train_y = scaler.inverse_transform(y_train)
test_predict = scaler.inverse_transform(test_predict)
test_y = scaler.inverse_transform(y_test)
# 計算度量
print("Train")
mae_train, mse_train = metrics_time_series( train_y, train_predict)
print("Test")
mae_test, mse_test = metrics_time_series( test_y, test_predict)
return train_predict, train_y, test_predict, test_y, pd.DataFrame([name, mae_train, mse_train, mae_test, mse_test], index=["Name", "mae_train", "mse_train", "mae_test", "mse_test"]).T
此函式計算訓練部分和測驗部分的度量，并以資料幀的形式回傳結果，舉五個例子，
LSTM
# 訓練模型并計算度量
> x_train_predict_lstm, y_train_lstm,x_test_predict_lstm, y_test_lstm, res= time_series_deep_learning(train_x, train_y, test_x, test_y, model_dl=LSTM , unit=12, look_back=20)
# 畫出預測的結果
> plotting_predictions(dataset, look_back, x_train_predict_lstm, x_test_predict_lstm)
# 將每個模型的指標保存在資料框df_results中
> df_results = df_results.append(res)
GRU
# 訓練模型并計算度量
> x_train_predict_lstm, y_train_lstm,x_test_predict_lstm, y_test_lstm, res= time_series_deep_learning(train_x, train_y, test_x, test_y, model_dl=GRU, unit=12, look_back=20)
堆疊LSTM：
# 訓練模型并計算度量
> x_train_predict_lstm, y_train_lstm,x_test_predict_lstm, y_test_lstm, res= time_series_deep_learning(train_x, train_y, test_x, test_y, model_dl=LSTM , unit=12, look_back=20, stacked=True)
雙向LSTM：
# 訓練模型并計算度量
> x_train_predict_lstm, y_train_lstm,x_test_predict_lstm, y_test_lstm, res= time_series_deep_learning(train_x, train_y, test_x, test_y, model_dl=LSTM , unit=12, look_back=20, bidirection=True)
CNN-LSTM:
# 訓練模型并計算度量
> x_train_predict_lstm, y_train_lstm,x_test_predict_lstm, y_test_lstm, res= time_series_deep_learning(train_x, train_y, test_x, test_y, model_dl=LSTM , unit=12, look_back=20, cnn=True)
結果
考慮到這些資料，結果相當不錯，我們可以看出，深度學習RNN可以很好地再現資料的準確性，下圖顯示了LSTM模型的預測結果，
表1：不同RNN模型的結果，顯示了MAE和MSE指標
Name | MAE Train | MSE Train | MAE Test | MSE Test
--------------------------------------------------------------------
GRU | 4.24 | 34.11 | 4.15 | 31.47
LSTM | 4.26 | 34.54 | 4.16 | 31.64
Stack_GRU | 4.19 | 33.89 | 4.17 | 32.01
SimpleRNN | 4.21 | 34.07 | 4.18 | 32.41
LSTM | 4.28 | 35.1 | 4.21 | 31.9
Bi_GRU | 4.21 | 34.34 | 4.22 | 32.54
Stack_Bi_LSTM | 4.45 | 36.83 | 4.24 | 32.22
Bi_LSTM | 4.31 | 35.37 | 4.27 | 32.4
Stack_SimpleRNN | 4.4 | 35.62 | 4.27 | 33.94
SimpleRNN | 4.44 | 35.94 | 4.31 | 34.37
Stack_LSTM | 4.51 | 36.78 | 4.4 | 34.28
Stacked_Bi_GRU | 4.56 | 37.32 | 4.45 | 35.34
CNN_LSTM | 5.01 | 45.85 | 4.55 | 36.29
CNN_GRU | 5.05 | 46.25 | 4.66 | 37.17
CNN_Stack_GRU | 5.07 | 45.92 | 4.7 | 38.64
表1顯示了RNN系列訓練集和測驗集的平均絕對誤差(MAE)和均方誤差(MSE)，GRU在測驗集上顯示了最好的結果，MAE為4.15，MSE為31.47，
討論
結果很好，并且重現了不同恒星的光照曲線(見notebook)，然而，波動并不是完全重現的，峰值的強度也不相同，通量也有輕微的偏移，可以通過注意機制進行校正，另一種方法是調整模型、層數(堆疊)、單元數(單元)、不同RNN演算法的組合、新的損失函式或激活函式等，
結論
本文展示了將所謂的人工智能方法與時間序列相結合的可能性，記憶演算法(RNN、LSTM、GRU)的強大功能使得精確再現事件的偶發波動成為可能，在我們的例子中，恒星通量表現出相當強烈和顯著的波動，這些方法已經能夠捕捉到，
這項研究表明，時間序列不再是統計方法，如ARIMA[4]模型，
參考參考
[1] Autoregressive model, Wikipedia
[2] Moving-average model, Wikipedia
[3] Peter Whittle, 1950. Hypothesis testing in time series analysis. Thesis
[4] Alberto Luce?o & Daniel Pe?a, 2008. Autoregressive Integrated Moving Average (ARIMA) Modeling. Wiley Online Library. https://doi.org/10.1002/9780470061572.eqr276
[5] Rumelhart, David E. et al., 1986. Learning representations by back-propagating errors. Nature. 323 (6088): 533–536. 1986Natur.323..533R.
[6] Hochreiter, Sepp & Schmidhuber, Jürgen, 1997. Long Short-Term Memory. Neural Computation. 9 (8): 1735–1780. doi:10.1162/neco.1997.9.8.1735
[7] Cho, KyungHyun et al., 2014. Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling. arXiv:1412.3555
[8] M. Schuster & K.K. Paliwal, 1997. Bidirectional recurrent neural networks. IEEE Transactions on Signal Processing, Volume: 45 , Issue: 11, pp. 2673–2681. DOI: 10.1109/78.650093
[9] Tara N. Sainath et al., 2014. CONVOLUTIONAL, LONG SHORT-TERM MEMORY,FULLY CONNECTED DEEP NEURAL NETWORKS. https://static.googleusercontent.com/media/research.google.com/fr//pubs/archive/43455.pdf
[10] Ashish Vaswani et al., 2017. Attention is all you need. https://arxiv.org/abs/1706.03762
[11] Kepler mission, Nasa
原文鏈接：https://towardsdatascience.com/how-to-use-deep-learning-for-time-series-forecasting-3f8a399cf205
歡迎關注磐創AI博客站：
http://panchuang.net/
sklearn機器學習中文官方檔案：
http://sklearn123.com/
歡迎關注磐創博客資源匯總站：
http://docs.panchuang.net/
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/160337.html
標籤：其他
上一篇：Object基礎問題