如何將時間序列轉換為 Python 中的監督學習問題 · Machine Learning Mastery 博客文章翻譯

# 如何將時間序列轉換為 Python 中的監督學習問題 > 原文： [https://machinelearningmastery.com/convert-time-series-supervised-learning-problem-python/](https://machinelearningmastery.com/convert-time-series-supervised-learning-problem-python/) 深度學習等機器學習方法可用于時間序列預測。在可以使用機器學習之前，必須將時間序列預測問題重新定義為監督學習問題。從序列到輸入和輸出序列對。在本教程中，您將了解如何將單變量和多變量時間序列預測問題轉換為監督學習問題，以便與機器學習算法一起使用。完成本教程后，您將了解： * 如何開發將時間序列數據集轉換為監督學習數據集的函數。 * 如何轉換用于機器學習的單變量時間序列數據。 * 如何轉換多變量時間序列數據用于機器學習。讓我們開始吧。 ![How to Convert a Time Series to a Supervised Learning Problem in Python](https://img.kancloud.cn/fa/98/fa98ea8da3f29c38077ac73e142764c3_640x361.jpg) 如何將時間序列轉換為 Python 中的監督學習問題照片由 [Quim Gil](https://www.flickr.com/photos/quimgil/8490510169/) ，保留一些權利。 ## 時間序列與監督學習在我們開始之前，讓我們花一點時間來更好地理解時間序列和監督學習數據的形式。時間序列是按時間索引排序的數字序列。這可以被認為是有序值的列表或列。例如： ```py 0 1 2 3 4 5 6 7 8 9 ``` 監督學習問題由輸入模式（ _X_ ）和輸出模式（ _y_ ）組成，使得算法可以學習如何從輸入模式預測輸出模式。例如： ```py X, y 1 2 2, 3 3, 4 4, 5 5, 6 6, 7 7, 8 8, 9 ``` 有關此主題的更多信息，請參閱帖子： * [時間序列預測作為監督學習](http://machinelearningmastery.com/time-series-forecasting-supervised-learning/) ## Pandas shift（）函數幫助將時間序列數據轉換為監督學習問題的關鍵功能是 Pandas [shift（）](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.shift.html)功能。給定一個 DataFrame， _shift（）_ 函數可用于創建向前推送的列的副本（添加到前面的 NaN 值行）或拉回（添加到末尾的 NaN 值行）。這是在監督學習格式中創建滯后觀察列以及時間序列數據集的預測觀察列所需的行為。讓我們看一下移位函數的一些例子。我們可以將模擬時間序列數據集定義為 10 個數字的序列，在本例中是 DataFrame 中的單個列，如下所示： ```py from pandas import DataFrame df = DataFrame() df['t'] = [x for x in range(10)] print(df) ``` 運行該示例使用每個觀察的行索引打印時間序列數據。 ```py t 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 ``` 我們可以通過在頂部插入一個新行將所有觀察結果向下移動一步。因為新行沒有數據，我們可以使用 NaN 來表示“無數據”。 shift 函數可以為我們執行此操作，我們可以在原始系列旁邊插入此移位列。 ```py from pandas import DataFrame df = DataFrame() df['t'] = [x for x in range(10)] df['t-1'] = df['t'].shift(1) print(df) ``` 運行該示例為我們提供了數據集中的兩列。第一個是原始觀察和一個新的移動列。我們可以看到，將系列向前移動一個步驟給了我們一個原始的監督學習問題，盡管 _X_ 和 _y_ 的順序錯誤。忽略行標簽列。由于 NaN 值，必須丟棄第一行。第二行顯示第二列中的輸入值 0.0（輸入或 _X_ ）和第一列中的值 1（輸出或 _y_ ）。 ```py t t-1 0 0 NaN 1 1 0.0 2 2 1.0 3 3 2.0 4 4 3.0 5 5 4.0 6 6 5.0 7 7 6.0 8 8 7.0 9 9 8.0 ``` 我們可以看到，如果我們可以用 2,3 和更多的移位重復這個過程，我們如何創建可用于預測輸出值的長輸入序列（ _X_ ）（ _y_ ）。移位運算符也可以接受負整數值。這具有通過在末尾插入新行來提升觀察結果的效果。以下是一個例子： ```py from pandas import DataFrame df = DataFrame() df['t'] = [x for x in range(10)] df['t+1'] = df['t'].shift(-1) print(df) ``` 運行該示例顯示一個新列，其中 NaN 值為最后一個值。我們可以看到預測列可以作為輸入（ _X_ ），第二個作為輸出值（ _y_ ）。即 0 的輸入值可用于預測輸出值 1。 ```py t t+1 0 0 1.0 1 1 2.0 2 2 3.0 3 3 4.0 4 4 5.0 5 5 6.0 6 6 7.0 7 7 8.0 8 8 9.0 9 9 NaN ``` 從技術上講，在時間序列預測術語中，當前時間（ _t_ ）和未來時間（ _t + 1_ ， _t + n_ ）是預測時間和過去的觀察結果（ _t-1_ ， _tn_ ）用于進行預測。我們可以看到正向和負向移位如何用于從具有監督學習問題的輸入和輸出模式序列的時間序列創建新的 DataFrame。這不僅允許經典 _X - >_ 預測， _X - > Y_ 其中輸入和輸出都可以是序列。此外，移位功能也適用于所謂的多變量時間序列問題。在這里，我們有多個（例如溫度和壓力），而不是對時間序列進行一組觀察。時間序列中的所有變量都可以向前或向后移動以創建多變量輸入和輸出序列。我們將在本教程的后面部分詳細探討。 ## series_to_supervised（）函數我們可以使用 Pandas 中的 _shift（）_ 函數在給定所需的輸入和輸出序列長度的情況下自動創建新的時間序列問題框架。這將是一個有用的工具，因為它將允許我們使用機器學習算法探索時間序列問題的不同框架，以查看哪些可能導致更好的模型。在本節中，我們將定義一個名為 _series_to_supervised（）_ 的新 Python 函數，該函數采用單變量或多變量時間序列并將其構建為監督學習數據集。該函數有四個參數： * **數據**：作為列表或 2D NumPy 數組的觀察序列。需要。 * **n_in** ：作為輸入的滯后觀察數（ _X_ ）。值可以在[1..len（數據）]之間可選。默認為 1。 * **n_out** ：作為輸出的觀測數（ _y_ ）。值可以在[0..len（數據）-1]之間。可選的。默認為 1。 * **dropnan** ：布爾值是否刪除具有 NaN 值的行。可選的。默認為 True。該函數返回一個值： * **返回**：系列的 Pandas DataFrame 用于監督學習。新數據集構造為 DataFrame，每列適當地由變量編號和時間步驟命名。這允許您根據給定的單變量或多變量時間序列設計各種不同的時間步長序列類型預測問題。返回 DataFrame 后，您可以決定如何將返回的 DataFrame 的行拆分為 _X_ 和 _y_ 組件，以便以任何方式進行監督學習。該函數是使用默認參數定義的，因此如果僅使用您的數據調用它，它將構建一個 DataFrame，其中 _t-1_ 為 _X_ 和 _t_ 為 _y_ 。該函數被確認與 Python 2 和 Python 3 兼容。下面列出了完整的功能，包括功能注釋。 ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg ``` 你能看到明顯的方法來使功能更強大或更具可讀性嗎？請在下面的評論中告訴我。現在我們已經擁有了整個功能，我們可以探索如何使用它。 ## 一步式單變量預測時間序列預測的標準做法是使用滯后觀測值（例如 t-1）作為輸入變量來預測當前時間步長（t）。這稱為一步預測。下面的示例演示了預測當前時間步長（t）的一個滯后時間步長（t-1）。 ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg values = [x for x in range(10)] data = series_to_supervised(values) print(data) ``` 運行該示例將打印重新構建的時間序列的輸出。 ```py var1(t-1) var1(t) 1 0.0 1 2 1.0 2 3 2.0 3 4 3.0 4 5 4.0 5 6 5.0 6 7 6.0 7 8 7.0 8 9 8.0 9 ``` 我們可以看到觀察結果被命名為“ _var1_ ”并且輸入觀察被恰當地命名為（t-1）并且輸出時間步長被命名為（t）。我們還可以看到具有 NaN 值的行已自動從 DataFrame 中刪除。我們可以用任意數字長度的輸入序列重復這個例子，例如 3.這可以通過將輸入序列的長度指定為參數來完成。例如： ```py data = series_to_supervised(values, 3) ``` 下面列出了完整的示例。 ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg values = [x for x in range(10)] data = series_to_supervised(values, 3) print(data) ``` 再次，運行該示例打印重構系列。我們可以看到輸入序列是從正確的從左到右的順序，輸出變量在最右邊預測。 ```py var1(t-3) var1(t-2) var1(t-1) var1(t) 3 0.0 1.0 2.0 3 4 1.0 2.0 3.0 4 5 2.0 3.0 4.0 5 6 3.0 4.0 5.0 6 7 4.0 5.0 6.0 7 8 5.0 6.0 7.0 8 9 6.0 7.0 8.0 9 ``` ## 多步或序列預測不同類型的預測問題是使用過去的觀測來預測未來觀測的序列。這可稱為序列預測或多步預測。我們可以通過指定另一個參數來構建序列預測的時間序列。例如，我們可以使用 2 個過去觀測的輸入序列構建預測問題，以預測 2 個未來觀測如下： ```py data = series_to_supervised(values, 2, 2) ``` 完整示例如下： ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg values = [x for x in range(10)] data = series_to_supervised(values, 2, 2) print(data) ``` 運行該示例顯示輸入（t-n）和輸出（t + n）變量的區別，其中當前觀察值（t）被視為輸出。 ```py var1(t-2) var1(t-1) var1(t) var1(t+1) 2 0.0 1.0 2 3.0 3 1.0 2.0 3 4.0 4 2.0 3.0 4 5.0 5 3.0 4.0 5 6.0 6 4.0 5.0 6 7.0 7 5.0 6.0 7 8.0 8 6.0 7.0 8 9.0 ``` ## 多變量預測另一種重要的時間序列稱為多變量時間序列。在這里，我們可能會觀察到多種不同的測量方法，并且有興趣預測其中的一種或多種。例如，我們可能有兩組時間序列觀測值 obs1 和 obs2，我們希望預測其中一個或兩個。我們可以用完全相同的方式調用 _series_to_supervised（）_。例如： ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg raw = DataFrame() raw['ob1'] = [x for x in range(10)] raw['ob2'] = [x for x in range(50, 60)] values = raw.values data = series_to_supervised(values) print(data) ``` 運行該示例將打印數據的新框架，顯示兩個變量的一個時間步長的輸入模式和兩個變量的一個時間步的輸出模式。同樣，根據問題的具體情況，可以任意選擇列分為 _X_ 和 _Y_ 成分，例如，如果 _var1_ 的當前觀察也提供了作為輸入，并且僅預測 _var2_ 。 ```py var1(t-1) var2(t-1) var1(t) var2(t) 1 0.0 50.0 1 51 2 1.0 51.0 2 52 3 2.0 52.0 3 53 4 3.0 53.0 4 54 5 4.0 54.0 5 55 6 5.0 55.0 6 56 7 6.0 56.0 7 57 8 7.0 57.0 8 58 9 8.0 58.0 9 59 ``` 通過指定輸入和輸出序列的長度，您可以看到如何通過多變量時間序列輕松地將其用于序列預測。例如，下面是一個重構的示例，其中 1 個時間步長作為輸入，2 個時間步長作為預測序列。 ```py from pandas import DataFrame from pandas import concat def series_to_supervised(data, n_in=1, n_out=1, dropnan=True): """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ n_vars = 1 if type(data) is list else data.shape[1] df = DataFrame(data) cols, names = list(), list() # input sequence (t-n, ... t-1) for i in range(n_in, 0, -1): cols.append(df.shift(i)) names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)] # forecast sequence (t, t+1, ... t+n) for i in range(0, n_out): cols.append(df.shift(-i)) if i == 0: names += [('var%d(t)' % (j+1)) for j in range(n_vars)] else: names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)] # put it all together agg = concat(cols, axis=1) agg.columns = names # drop rows with NaN values if dropnan: agg.dropna(inplace=True) return agg raw = DataFrame() raw['ob1'] = [x for x in range(10)] raw['ob2'] = [x for x in range(50, 60)] values = raw.values data = series_to_supervised(values, 1, 2) print(data) ``` 運行該示例顯示了大型重構的 DataFrame。 ```py var1(t-1) var2(t-1) var1(t) var2(t) var1(t+1) var2(t+1) 1 0.0 50.0 1 51 2.0 52.0 2 1.0 51.0 2 52 3.0 53.0 3 2.0 52.0 3 53 4.0 54.0 4 3.0 53.0 4 54 5.0 55.0 5 4.0 54.0 5 55 6.0 56.0 6 5.0 55.0 6 56 7.0 57.0 7 6.0 56.0 7 57 8.0 58.0 8 7.0 57.0 8 58 9.0 59.0 ``` 試驗您自己的數據集并嘗試多種不同的框架，看看哪種方法效果最好。 ## 摘要在本教程中，您了解了如何將時間序列數據集重新定義為 Python 的監督學習問題。具體來說，你學到了： * 關于 Pandas _shift（）_ 功能以及它如何用于從時間序列數據中自動定義監督學習數據集。 * 如何將單變量時間序列重新組合成一步和多步監督學習問題。 * 如何將多變量時間序列重構為一步和多步監督學習問題。你有任何問題嗎？在下面的評論中提出您的問題，我會盡力回答。