Можно ли расширить "im2col" и "col2im" для изображений ND? - PullRequest
Новая
       40

Можно ли расширить "im2col" и "col2im" для изображений ND?

0 голосов
/ 27 сентября 2019

"Im2col" уже реализован, Реализует im2col 'скользящий' MATLAB в Python , эффективно для двумерных изображений в Python.Мне было интересно, возможно ли распространить это на произвольные изображения ND?Во многих приложениях используются многомерные данные (например, свертки, фильтрация, максимальное объединение и т. Д.).

1 Ответ

0 голосов
/ 27 сентября 2019

Таким образом, целью этого вопроса было просто опубликовать мое решение этой проблемы публично.Я не мог найти такое решение в 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

Проверка того, что это работает

Давайте определим произвольный трехмерный ввод: 

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]]]

Давайте извлечем все патчи с неравномерным окном и равным шагом: 

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]]]

Как видите, конечный результат - это действительно изображение с пониженной частотой, которое мы ожидаем (вы можете легко проверить это, перейдя значение по значению).Размерность и шаги, которые я выбрал, были чисто иллюстративными.Нет причин, по которым размер окна должен быть таким же, как ваш шаг, или что вы не можете подняться выше 3-х измерений.

Приложения

Если вы хотитеиспользуйте это практически, все, что вам нужно сделать, это перехватить вывод im2col, прежде чем превратить его обратно в изображение.Например, если вы хотите выполнить объединение, вы можете взять среднее или максимальное значение по 0-й оси.Если вы хотите сделать свертку, вам просто нужно умножить это на ваш сплющенный сверточный фильтр.

Могут быть более эффективные альтернативы этому, уже реализованные под капотом Tensorflow и т. Д., Которые работают быстрее, чем "im2col".«.Это не является наиболее эффективной реализацией.И, конечно, вы могли бы еще больше оптимизировать мой код, исключив промежуточный этап изменения формы в «im2col», но для меня это было не сразу очевидно, поэтому я просто оставил это на этом.Если у вас есть лучшее решение, дайте мне знать.В любом случае, надеюсь, что это поможет кому-то еще, ищущему тот же ответ!

...