是否可以將“im2col”和“col2im”擴展到 ND 圖像？

Question

“Im2col”已經實現， 在 Python 中實現 MATLAB 的 im2col“滑動” ，有效地用於 Python 中的二維圖像。 我想知道是否可以將其擴展到任意 ND 圖像？ 許多應用涉及高維數據（例如卷積、過濾、最大池化等）。

Answer 1

所以這個問題的目的實際上只是為了公開發布我對這個問題的解決方案。 我似乎無法在 Google 上找到這樣的解決方案，所以我決定自己嘗試一下。 事實證明，從我的問題中引用的帖子中的“方法#2”擴展實現實際上非常簡單！

ND“im2col”的高效實現

def im2col(im, win, strides = 1):
    # Dimensions
    ext_shp = tuple(np.subtract(im.shape, win) + 1)
    shp = tuple(win) + ext_shp
    strd = im.strides*2
    win_len = np.prod(win)
    try:
        len(strides)
    except:
        strides = [strides]*im.ndim
    strides = [min(i, s) for i, s in zip(im.shape, strides)]

    # Stack all possible patches as an N-D array using a strided view followed by reshaping
    col = np.lib.stride_tricks.as_strided(im, shape = shp, strides = strd).reshape(win_len, -1).reshape(-1, *ext_shp)

    # Extract patches with stride and reshape into columns
    slcs = tuple([slice(None, None, None)] + [slice(None, None, s) for s in strides])
    col = col[slcs].reshape(win_len, -1)

    return col

ND“col2im”的高效實現

def col2im(col, im_shp, win, strides = 1):
    # Dimensions
    try:
        len(strides)
    except:
        strides = [strides]*len(im_shp)
    strides = [min(i, s) for i, s in zip(im_shp, strides)]

    # Reshape columns into image
    if col.ndim > 1:
        im = col.reshape((-1, ) + tuple(np.subtract(im_shp, win)//np.array(strides) + 1))[0]
    else:
        im = col.reshape(tuple(np.subtract(im_shp, win)//np.array(strides) + 1))

    return im

驗證它是否有效

讓我們定義一個任意的 3-D 輸入：

x = np.arange(216).reshape(6, 6, 6)
print(x)

[[[  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  27  28  29]
  [ 30  31  32  33  34  35]]

 [[ 36  37  38  39  40  41]
  [ 42  43  44  45  46  47]
  [ 48  49  50  51  52  53]
  [ 54  55  56  57  58  59]
  [ 60  61  62  63  64  65]
  [ 66  67  68  69  70  71]]

 [[ 72  73  74  75  76  77]
  [ 78  79  80  81  82  83]
  [ 84  85  86  87  88  89]
  [ 90  91  92  93  94  95]
  [ 96  97  98  99 100 101]
  [102 103 104 105 106 107]]

 [[108 109 110 111 112 113]
  [114 115 116 117 118 119]
  [120 121 122 123 124 125]
  [126 127 128 129 130 131]
  [132 133 134 135 136 137]
  [138 139 140 141 142 143]]

 [[144 145 146 147 148 149]
  [150 151 152 153 154 155]
  [156 157 158 159 160 161]
  [162 163 164 165 166 167]
  [168 169 170 171 172 173]
  [174 175 176 177 178 179]]

 [[180 181 182 183 184 185]
  [186 187 188 189 190 191]
  [192 193 194 195 196 197]
  [198 199 200 201 202 203]
  [204 205 206 207 208 209]
  [210 211 212 213 214 215]]]

讓我們提取所有具有非均勻 window 和相等步幅的補丁：

y = im2col(x, [1, 3, 2], strides = [1, 3, 2])
print(y.T) # transposed for ease of visualization

[[  0   1   6   7  12  13]
 [  2   3   8   9  14  15]
 [  4   5  10  11  16  17]
 [ 18  19  24  25  30  31]
 [ 20  21  26  27  32  33]
 [ 22  23  28  29  34  35]
 [ 36  37  42  43  48  49]
 [ 38  39  44  45  50  51]
 [ 40  41  46  47  52  53]
 [ 54  55  60  61  66  67]
 [ 56  57  62  63  68  69]
 [ 58  59  64  65  70  71]
 [ 72  73  78  79  84  85]
 [ 74  75  80  81  86  87]
 [ 76  77  82  83  88  89]
 [ 90  91  96  97 102 103]
 [ 92  93  98  99 104 105]
 [ 94  95 100 101 106 107]
 [108 109 114 115 120 121]
 [110 111 116 117 122 123]
 [112 113 118 119 124 125]
 [126 127 132 133 138 139]
 [128 129 134 135 140 141]
 [130 131 136 137 142 143]
 [144 145 150 151 156 157]
 [146 147 152 153 158 159]
 [148 149 154 155 160 161]
 [162 163 168 169 174 175]
 [164 165 170 171 176 177]
 [166 167 172 173 178 179]
 [180 181 186 187 192 193]
 [182 183 188 189 194 195]
 [184 185 190 191 196 197]
 [198 199 204 205 210 211]
 [200 201 206 207 212 213]
 [202 203 208 209 214 215]]

讓我們將其轉換回（下采樣）圖像：

z = col2im(y, x.shape, [1, 3, 2], strides = [1, 3, 2])
print(z)

[[[  0   2   4]
  [ 18  20  22]]

 [[ 36  38  40]
  [ 54  56  58]]

 [[ 72  74  76]
  [ 90  92  94]]

 [[108 110 112]
  [126 128 130]]

 [[144 146 148]
  [162 164 166]]

 [[180 182 184]
  [198 200 202]]]

如您所見，最終的 output 確實是我們期望的下采樣圖像（您可以通過逐個值輕松檢查這一點）。 我選擇的維度和步幅純粹是說明性的。 沒有理由為什么 window 尺寸必須與您的步幅相同，或者您不能 go 高於 3 個維度。

應用

如果你想實際使用它，你所要做的就是在將它轉換回圖像之前攔截im2col的output。 例如，如果要進行池化，則可以在第 0 軸上取平均值或最大值。 如果要進行卷積，只需將其乘以扁平卷積濾波器即可。

可能有比“im2col”更快的 Tensorflow 等已經實現的更有效的替代方案。 這並不意味着是最有效的實現。 當然，您可以通過消除“im2col”中的中間重塑步驟來進一步優化我的代碼，但這對我來說並不是很明顯，所以我就把它留在了那里。 如果您有更好的解決方案，請告訴我。 無論如何，希望這可以幫助其他人尋找相同的答案！