差分时间序列并创建平稳时间序列 - Pandas

Question

我想对时间序列进行差分以使其静止。然而，并不能保证通过采用第一滞后将使时间序列变得平稳。生成一个示例 Pandas 数据框，如下所示

test = {'A':[10,15,19,24,23]}
test_df = pd.DataFrame(test)  

通过使用

diff()

方法，我们可以按预期采取第一个滞后，但如果我尝试

diff(2)

，即如果我想使用 2 的滞后期，我不会得到预期的结果。

预期输出

+----+-------+-------+
| A  | Lag 1 | Lag 2 |
+----+-------+-------+
| 10 | NA    | NA    |
| 15 | 5     | NA    |
| 19 | 4     |-1     |
| 24 | 5     | 1     |
| 23 |-1     |-6     |
+----+-------+-------+

结果输出

+----------------+
|  A  lag1  lag2 |
+----------------+
| 10   NaN   NaN |
| 15   5.0   NaN |
| 19   4.0   9.0 |
| 24   5.0   9.0 |
| 23  -1.0   4.0 |
+----------------+

以上输出是使用

test_df['lag2'] = test_df['A'].diff(2)

生成的。 如何仅使用

Lag 2

时间序列来获得预期输出并重新生成实际时间序列？

编辑1 此问题与任何数据类型转换或 NaN 无关，并且被错误地标记为重复。明确提到了预期的输出，问题的范围与here中提到的完全不同。

编辑2 要处理更多数量的样本，可以使用以下虚拟数据框。

test = np.random.randint(100, size=500)
test_df = pd.DataFrame(test, columns = ['A'])

编辑3 为了更多地解释预期输出，请考虑下面的预期输出。

+----+-------+-------+
| A  | Lag 1 | Lag 2 |
+----+-------+-------+
| 10 | NA    | NA    |
| 15 | 5     | NA    |
| 19 | 4     | -1    |
| 24 | 5     | 1     |
| 23 | -1    | -6    |
| 50 | 27    | 28    |
| 34 | -16   | -43   |
| 56 | 22    | 38    |
| 33 | -23   | -45   |
| 26 | -7    | 16    |
| 45 | 19    | 26    |
+----+-------+-------+

test = {'A': [10,15,19,24,23,50,34,56,33,26,45]}
test_df = pd.DataFrame(test)

该列的

Lag 1

可以使用以下命令创建

test_df['lag1'] = test_df['A'].diff()

。但要创建

lag 2

，我需要做

test_df['lag2'] = test_df['A'].diff().diff()

。如果我必须采取 365 滞后，则此解决方案将不起作用。因此，我需要一个解决方案，采用原始序列

A

的滞后，然后递归地采用

lag1

的滞后来生成

lag2

等等。

一旦我们创建了滞后项

lag2

我们如何从中检索原始序列？

Answer 1

diff(2)

将为您提供 a_n 和 a_n-2 之间的差异。您想要的是差异列的项目之间的差异。简单的数学表明它将是 an _{+ a}n-2 _{- 2 * a}n-1_{。这足以解释为什么你没有得到预期的结果。}

你想要的是

迭代diff()

：

df['Lag 1'] = df['A'].diff()
df['Lag 2'] = df['A'].diff().diff()

使用

df = pd.DataFrame({'A': [10,15,19,24,23,50,34,56,33,26,45]}

，它会按预期给出：

     A  Lag 1  Lag 2
0   10    NaN    NaN
1   15    5.0    NaN
2   19    4.0   -1.0
3   24    5.0    1.0
4   23   -1.0   -6.0
5   50   27.0   28.0
6   34  -16.0  -43.0
7   56   22.0   38.0
8   33  -23.0  -45.0
9   26   -7.0   16.0
10  45   19.0   26.0

---

上面的小数学表明，Lag 365 将使用 365 个先前值以及二项式系数 C

365i^{。所以恕我直言，这样做更简单：}

s = df['A']
for i in range(365): s = s.diff()
df['Lag 365'] = s

如果您不想保留中间 Lag i 列。

---

您可以从 diff 列中检索初始值，前提是您还具有带有 cumsum 的第一个值：

df['Lag 1'].fillna(df.iloc[0,0]).cumsum()

 返回 

df['A']

。因此，为了能够从 n-diff-ed 列恢复初始值，我将使用 

diff

 的轻微变化来保留初始值而不是初始 NaN：

def difx(s):
    return s.diff().combine_first(s)

然后要处理第四个差异，我会使用

s = df['A']
for i in range(4): s = difx(s)
s['Lag 4'] = s

它给出：

0      10.0
1     -25.0
2      19.0
3      -2.0
4      -9.0
5      41.0
6    -105.0
7     152.0
8    -164.0
9     144.0
10    -51.0

我们现在可以使用

检索初始值

s = df['Lag 4']
for i in range(4): s = s.cumsum()

我们按预期返回初始值：

0     10.0
1     15.0
2     19.0
3     24.0
4     23.0
5     50.0
6     34.0
7     56.0
8     33.0
9     26.0
10    45.0

如果您的系列足够长，您可以对 Lag 365 执行相同的操作，只需将我的示例中的

4

 替换为 365...

Answer 2

您可以尝试使用 while 循环来根据需要多次运行代码吗

test_df['lag_1'] = test_df['A'].diff()
i = 2
while i<=365:
     test_df[f'lag_{i}'] = test_df[f'lag_{i-1}'].diff()
     i = i + 1