Python中时间序列的延时嵌入

我将时间序列数据作为numpy数组。我想生成如下数据的延时嵌入：

    [[   1.           37.17]
     [   2.           36.99]
     [   3.           36.84]
     [   4.           37.57]
     [   5.           37.49]
     [   6.           37.45]
     [   7.           37.82]
     [   8.           37.95]
     [   9.           37.36]
     [   10.          37.84]
     [   11.           37.85]
     [   12.           37.12]]

时间序列是这样的：

    [[   1.           37.17]
     [   2.           36.99]
     [   3.           36.84]
     [   4.           37.57]
     [   5.           37.49]
     [   6.           37.45]
     [   7.           37.82]
     [   8.           37.95]
     [   9.           37.36]
     [   10.          37.84]
     [   11.           37.85]
     [   12.           37.12]]

假设我的窗口大小（w）=4，间隙（g）=2。我们将每3个点选取一个点，直到得到点=窗口大小，形成一个“w”维点。对于下一个“w”维点，我们将序列移位1，并对移位的序列重复相同的过程。这将为我们提供几个“w”维点，这些点最终将存储在2D numpy数组中。当我们不能形成“w”维点时，即当我们到达系列的末尾时，我们停止

那么这个系列的延时嵌入应该是：

    [[ 37.17  37.57  37.82 37.84]
     [ 37.99  36.49  36.95 37.85]
     [ 37.84  37.45  36.36 37.12]]

我们将在这一点停止，因为对于四维中的下一个点，我们将用完第四个点。我有大约1600点长的时间序列，我希望参数w和g是可变的。该函数将按给定的时间序列提取“w”和“g”，并将吐出时间延迟嵌入。

其思想是生成重新索引矩阵

A=np.array（[37.17,36.99,36.84,37.57,37.49,37.45，
37.82,  37.95,  37.36,  37.84,  37.85,  37.12])
w=4
g=2

带有

w

和

g

A[（np.arange（w）*（g+1））+np.arange（np.max（A.shape[0]-（w-1）*（g+1），0））。重塑（-1,1）]

输出：

数组（[[37.17,37.57,37.82,37.84]，
[ 36.99,  37.49,  37.95,  37.85],
[ 36.84,  37.45,  37.36,  37.12]])

如果

A

是一个矩阵

[索引，值]

，则添加值列索引

A[n..，1]

更新1

#错误的步数计算被a.shape[0]-（w-1）*（g+1）替换

更新2

#添加了max以避免g和w的不可能值出现错误

---

---

查看所用函数、和的文档。

嘿，谢谢！！，但您的解决方案给了我835长度和w=300的系列的索引错误，g=2错误是：索引器错误：索引837超出了轴1的范围，大小为835。这是不可能的值，第一行在最后一项中的索引为897。我可以通过检查%@avani sharma来修复它，我添加了

max

，以避免g和wYeah这两个不可能的值出现错误！！。我检查：）这是不可能的。那么我应该减小我的窗口大小。索引是零基的。因此，第一级台阶上的大小窗口将是

[0，g+1,2*（g+1），…（w-1）*（g+1）

，在运动中它变成了矩阵

[0，…（w-1）*（g+1）]，[1，…，1+（w-1）*（g+1）]，[n，…，n+（w-1）*（g+1）]

其中

n

是行数减去最大窗口移位

行数
rows-1）*（g+1）

我们通过添加向量（列）

[[0,1，…，n]]

将其填充到矩阵中。通过向行添加列，我们调用

numpy

广播机制。它“生成”两个矩阵，分别重复列和行，然后将它们相加