Глубинная укладка с NumPy

Question

Я использую следующий код и получаю выводное значение размера (2,9), которое затем пытаюсь преобразовать в размер (3,3,2). Я надеялся, что вызов reshape с использованием (3,3,2) в качестве измерений нового массива будет принимать каждую строку массива 2x9, формировать его в массив 3x3 и оборачивать эти два массива 3x3 в другой. массив.

Например, когда я индексирую результат , мне нужно следующее поведение:

input: print(result)
output: [[ 2.  2.  1.  0.  8.  5.  2.  4.  5.]
         [ 4.  7.  5.  6.  4.  3. -3.  2.  1.]]

result = result.reshape((3,3,2))

DESIRED NEW BEHAVIOR
input: print(result[:,:,0])
output: [[2. 2. 1.]
         [0. 8. 5.]
         [2. 4. 5.]]

input: print(result[:,:,1])
output: [[ 4.  7.  5.]
         [ 6.  4.  3.]
         [-3.  2.  1.]]

ACTUAL NEW BEHAVIOR
input: print(result[:,:,0])
output: [[2. 1. 8.]
         [2. 5. 7.]
         [6. 3. 2.]]

input: print(result[:,:,1])
output: [[ 2.  0.  5.]
         [ 4.  4.  5.]
         [ 4. -3.  1.]]

Есть ли способ указать для изменения формы, что я хотел бы идти строка за строкой вдоль измерения глубины? Я очень озадачен тем, почему numpy по умолчанию делает выбор для изменения формы.

Вот код, который я использую для получения матрицы result , этот код может или не может быть необходим для анализа моей проблемы. Я чувствую, как будто это не будет необходимости, но я включаю это для полноты:

import numpy as np

# im2col implementation assuming width/height dimensions of filter and input_vol
# are the same (i.e. input_vol_width is equal to input_vol_height and the same
# for the filter spatial dimensions, although input_vol_width need not equal
# filter_vol_width)

def im2col(input, filters, input_vol_dims, filter_size_dims, stride):
    receptive_field_size = 1
    for dim in filter_size_dims:
        receptive_field_size *= dim

    output_width = output_height = int((input_vol_dims[0]-filter_size_dims[0])/stride + 1)

    X_col = np.zeros((receptive_field_size,output_width*output_height))

    W_row = np.zeros((len(filters),receptive_field_size))

    pos = 0
    for i in range(0,input_vol_dims[0]-1,stride):
        for j in range(0,input_vol_dims[1]-1,stride):
           X_col[:,pos] = input[i:i+stride+1,j:j+stride+1,:].ravel()
           pos += 1

    for i in range(len(filters)):
        W_row[i,:] = filters[i].ravel()

    bias = np.array([[1], [0]])

    result = np.dot(W_row, X_col) + bias

    print(result)


if __name__ == '__main__':
    x = np.zeros((7, 7, 3))

    x[:,:,0] = np.array([[0,0,0,0,0,0,0],
                         [0,1,1,0,0,1,0],
                         [0,2,2,1,1,1,0],
                         [0,2,0,2,1,0,0],
                         [0,2,0,0,1,0,0],
                         [0,0,0,1,1,0,0],
                         [0,0,0,0,0,0,0]])

    x[:,:,1] = np.array([[0,0,0,0,0,0,0],
                         [0,2,0,1,0,2,0],
                         [0,0,1,2,1,0,0],
                         [0,2,0,0,2,0,0],
                         [0,2,1,0,0,0,0],
                         [0,1,2,2,2,0,0],
                         [0,0,0,0,0,0,0]])

    x[:,:,2] = np.array([[0,0,0,0,0,0,0],
                         [0,0,0,2,1,1,0],
                         [0,0,0,2,2,0,0],
                         [0,2,1,0,2,2,0],
                         [0,0,1,2,1,2,0],
                         [0,2,0,0,2,1,0],
                         [0,0,0,0,0,0,0]])

    w0 = np.zeros((3,3,3))

    w0[:,:,0] = np.array([[1,1,0],
                          [1,-1,1],
                          [-1,1,1]])

    w0[:,:,1] = np.array([[-1,-1,0],
                          [1,-1,1],
                          [1,-1,-1]])

    w0[:,:,2] = np.array([[0,0,0],
                          [0,0,1],
                          [1,0,1]]


    w1 = np.zeros((3,3,3))

    w1[:,:,0] = np.array([[0,-1,1],
                         [1,1,0],
                         [1,1,0]])

    w1[:,:,1] = np.array([[-1,-1,1],
                          [1,0,1],
                          [0,1,1]])

    w1[:,:,2] = np.array([[-1,-1,0],
                          [1,-1,0],
                          [1,1,0]])


    filters = np.array([w0,w1])

    im2col(x,np.array([w0,w1]),x.shape,w0.shape,2)

Answer 1

Reshape сохраняет первоначальный порядок элементов

In [215]: x=np.array(x)
In [216]: x.shape
Out[216]: (2, 9)

Преобразование размера 9 в размер 3x3 позволяет сохранить необходимый порядок элементов:

In [217]: x.reshape(2,3,3)
Out[217]: 
array([[[ 2.,  2.,  1.],
        [ 0.,  8.,  5.],
        [ 2.,  4.,  5.]],

       [[ 4.,  7.,  5.],
        [ 6.,  4.,  3.],
        [-3.,  2.,  1.]]])

Но вы должны проиндексировать его с помощью [0,:,:], чтобы увидеть один из этих блоков.

Чтобы увидеть те же блоки с [:,:, 0], вы должны переместить это измерение размера 2 до конца. COLDSPEED's dstack делает это путем итерации первого измерения и объединения двух блоков (каждый 3x3) в новом третьем измерении). Другой способ - использовать transpose для изменения порядка размеров:

In [218]: x.reshape(2,3,3).transpose(1,2,0)
Out[218]: 
array([[[ 2.,  4.],
        [ 2.,  7.],
        [ 1.,  5.]],

       [[ 0.,  6.],
        [ 8.,  4.],
        [ 5.,  3.]],

       [[ 2., -3.],
        [ 4.,  2.],
        [ 5.,  1.]]])
In [219]: y = _
In [220]: y.shape
Out[220]: (3, 3, 2)
In [221]: y[:,:,0]
Out[221]: 
array([[2., 2., 1.],
       [0., 8., 5.],
       [2., 4., 5.]])

Answer 2

Давайте изменим немного по-другому, а затем сделаем глубину dstack:

arr = np.dstack(result.reshape((-1,3,3)))

arr[..., 0]
array([[2., 2., 1.],
       [0., 8., 5.],
       [2., 4., 5.]])