將 2D arrays 堆疊成 3D 數組

Question

我有一個非常簡單的問題，但我無法弄清楚。 我想將一堆 2D numpy arrays 沿着第三維（深度）一個一個地堆疊成一個 3D 數組。

我知道我可以像這樣使用np.stack() ：

d1 = np.arange(9).reshape(3,3)
d2 = np.arange(9,18).reshape(3,3)

foo = np.stack((d1,d2))

我得到

print(foo.shape)
>>> (2, 3, 3)
print(foo)
>>> [[[ 0  1  2]
      [ 3  4  5]
      [ 6  7  8]]

     [[ 9 10 11]
      [12 13 14]
      [15 16 17]]]

到目前為止，這幾乎是我想要的。 不過，我在這里有點困惑，深度維度在這里被索引為第一個維度。 但是，我現在想沿着第一維添加新的 3x3 數組（？） （這讓我很困惑），就像這樣。

d3 = np.arange(18,27).reshape(3,3)
foo = np.stack((foo,d3))

這是行不通的。 我知道現在 arrays 的尺寸有問題，但這里沒有vstack, hstack, dstack工作。 在這一點上我想要的就是這個。

print(foo)
>>> [[[ 0  1  2]
      [ 3  4  5]
      [ 6  7  8]]

     [[ 9 10 11]
      [12 13 14]
      [15 16 17]]

     [[18 19 20]
      [21 22 23]
      [24 25 26]]]

然后就可以像這樣添加更多 arrays。

當然，我看了一些關於這個主題的問題，但我仍然無法理解 3D arrays（尤其是 np.dstack()）並且不知道如何解決我的問題。

Answer 1

為什么不在單個堆棧中直接添加 d1、d2、d3 ( np.stack((d1, d2, d3)) )？ 重復連接 arrays 通常是不好的做法。

在任何情況下，您都可以使用：

np.stack((*foo, d3))

或者：

np.vstack((foo, d3[None]))

output：

array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],

       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]],

       [[18, 19, 20],
        [21, 22, 23],
        [24, 25, 26]]])

Answer 2

您正在尋找np.vstack ：

np.vstack((d1,d2,d3)).reshape(3,3,3)

或迭代地

foo = np.vstack((d1, d2))
foo = np.vstack((foo, d3))

Answer 3

制作 2 arrays 具有獨特的形狀（所以很清楚 2,3 和 4 來自哪里）：

In [123]: d1 = np.arange(12).reshape(3,4)
     ...: d2 = np.arange(12,24).reshape(3,4)

將它們組合成一個新數組 - 結果是 (2,3,4)。 請注意[]是如何嵌套的，就好像您有一個包含 2 個列表的列表，每個列表都有 3 個長度為 4 的列表。

In [124]: np.array((d1,d2))
Out[124]: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

stack with the default axis does the same thing - join the (3,4) arrays 沿新的主要維度：

In [125]: np.stack((d1,d2))
Out[125]: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

制作一個 (3,2,4) 數組：

In [126]: np.stack((d1,d2), axis=1)
Out[126]: 
array([[[ 0,  1,  2,  3],
        [12, 13, 14, 15]],

       [[ 4,  5,  6,  7],
        [16, 17, 18, 19]],

       [[ 8,  9, 10, 11],
        [20, 21, 22, 23]]])

和一個（3,4,2）：

In [127]: np.stack((d1,d2), axis=2)
Out[127]: 
array([[[ 0, 12],
        [ 1, 13],
        [ 2, 14],
        [ 3, 15]],

       [[ 4, 16],
        [ 5, 17],
        [ 6, 18],
        [ 7, 19]],

       [[ 8, 20],
        [ 9, 21],
        [10, 22],
        [11, 23]]])

通常depth是最后一個維度。 np.dstack中的d暗示了這一點。

vstack在現有的第一個維度上加入它們，形成一個 (2*3, 4) 數組：

In [128]: np.vstack((d1,d2))
Out[128]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

所有這些*stack函數都會調整尺寸，然后使用np.concatenate 。 默認stack添加了一個新的前導維度，如：

In [129]: np.concatenate((d1[None,:,:], d2[None,:,:])).shape
Out[129]: (2, 3, 4)

雖然vstack可以在循環中重復使用，但前提是您從適當的數組開始，它很慢。 最好收集 arrays 的整個列表，並且只做一個組合。

循環中stack的一個額外問題是它每次都會增加一個維度，並且需要匹配形狀。

np.stack((foo,d3))  # a (2,3,3) with a (3,3); dimensions don't match
np.stack((foo,foo)) # produces (2,2,3,3)

要向foo添加更多 arrays，您必須將它們擴展為 (1,3,3) 形狀

np.concatenate((foo, d3[None,:,:], d4[None,:,:]), axis=0)

然后將 (2,3,3) 與 (1,3,3) 和另一個 (1,3,3) 等連接起來； 除第一個之外的匹配維度。

將arrays與這些功能中的任何一個連接起來時，尺寸都不能隨便。 np.concatenate有關於它可以組合的非常具體的規則。