Numpy 将 3D 可变大小卷列表转换为 4D 数组

Question

我正在研究一个神经网络，我通过旋转和改变每个输入量的大小来增加数据。

让我备份一下，网络的输入是一个 3D 体积。我生成可变大小的 3D 体积，然后用零填充每个体积，使输入体积保持不变。检查我遇到的填充问题（现已解决）。

我生成一个可变大小的 3D 体积，将其附加到一个列表，然后将该列表转换为一个 numpy 数组。此时，填充尚未发生，因此将其转换为 4D 元组没有任何意义...

input_augmented_matrix = []
label_augmented_matrix = []
for i in range(n_volumes):
    if i % 50 == 0:
        print ("Augmenting step #" + str(i))
    slice_index = randint(0,n_input)
    z_max = randint(5,n_input)
    z_rand = randint(3,5)
    z_min = z_max - z_rand
    x_max = randint(75, n_input_x)
    x_rand = randint(60, 75)
    x_min = x_max - x_rand
    y_max = randint(75, n_input_y)
    y_rand = randint(60, 75)
    y_min = y_max - y_rand
    random_rotation = randint(1,4) * 90
    for j in range(2):
        temp_volume = np.empty((z_rand, x_rand, y_rand))
        k = 0
        for z in range(z_min, z_max):
            l = 0
            for x in range(x_min, x_max):
                m = 0
                for y in range(y_min, y_max):
                    if j == 0:
                        #input volume
                        try:
                            temp_volume[k][l][m] = input_matrix[z][x][y]
                        except:
                            pdb.set_trace()
                    else:
                        #ground truth volume
                        temp_volume[k][l][m] = label_matrix[z][x][y]
                    m = m + 1
                l = l + 1
            k = k + 1
        temp_volume = np.asarray(temp_volume)
        temp_volume = np.rot90(temp_volume,random_rotation)
        if j == 0:
            input_augmented_matrix.append(temp_volume)
        else:
            label_augmented_matrix.append(temp_volume)

input_augmented_matrix = np.asarray(input_augmented_matrix)
label_augmented_matrix = np.asarray(label_augmented_matrix)

此时input_augmented_matrix的维度是(N,)

然后我用下面的代码填充...

for i in range(n_volumes):
    print("Padding volume #" + str(i))
    input_augmented_matrix[i] = np.lib.pad(input_augmented_matrix[i], ((0,n_input_z - int(input_augmented_matrix[i][:,0,0].shape[0])),
                                                (0,n_input_x - int(input_augmented_matrix[i][0,:,0].shape[0])),
                                                (0,n_input_y - int(input_augmented_matrix[i][0,0,:].shape[0]))),
                                'constant', constant_values=0)
    label_augmented_matrix[i] = np.lib.pad(label_augmented_matrix[i], ((0,n_input_z - int(label_augmented_matrix[i][:,0,0].shape[0])),
                                                (0,n_input_x - int(label_augmented_matrix[i][0,:,0].shape[0])),
                                                (0,n_input_y - int(label_augmented_matrix[i][0,0,:].shape[0]))),
                                'constant', constant_values=0)

此时，维度仍然是 (N,)，即使列表中的每个元素都是常量。例如input_augmented_matrix[0] = input_augmented_matrix[1]

目前我只是遍历并创建一个新数组，但它花费的时间太长，我更喜欢某种自动执行此操作的方法。我用下面的代码来做...

input_4d = np.empty((n_volumes, n_input_z, n_input_x, n_input_y))
label_4d = np.empty((n_volumes, n_input_z, n_input_x, n_input_y))
for i in range(n_volumes):
    print("Converting to 4D tuple #" + str(i))
    for j in range(n_input_z):
        for k in range(n_input_x):
            for l in range(n_input_y):
                input_4d[i][j][k][l] = input_augmented_matrix[i][j][k][l]
                label_4d[i][j][k][l] = label_augmented_matrix[i][j][k][l]

有没有更干净、更快速的方法来做到这一点？

Answer 1

据我了解这部分

k = 0
for z in range(z_min, z_max):
    l = 0
    for x in range(x_min, x_max):
        m = 0
        for y in range(y_min, y_max):
            if j == 0:
                #input volume
                try:
                    temp_volume[k][l][m] = input_matrix[z][x][y]
                except:
                    pdb.set_trace()
            else:
                #ground truth volume
                temp_volume[k][l][m] = label_matrix[z][x][y]
            m = m + 1
        l = l + 1
    k = k + 1

你只想这样做

temp_input = input_matrix[z_min:z_max, x_min:x_max, y_min:y_max]
temp_label = label_matrix[z_min:z_max, x_min:x_max, y_min:y_max]

然后

temp_input = np.rot90(temp_input, random_rotation)
temp_label = np.rot90(temp_label, random_rotation)

input_augmented_matrix.append(temp_input)
label_augmented_matrix.append(temp_label)

这里

input_augmented_matrix[i] = np.lib.pad(
    input_augmented_matrix[i],
    ((0,n_input_z - int(input_augmented_matrix[i][:,0,0].shape[0])),
     (0,n_input_x - int(input_augmented_matrix[i][0,:,0].shape[0])),
     (0,n_input_y - int(input_augmented_matrix[i][0,0,:].shape[0]))),
    'constant', constant_values=0)

最好这样做，因为 shape 属性给出所有维度的数组大小

ia_shape = input_augmented_matrix[i].shape
input_augmented_matrix[i] = np.lib.pad(
    input_augmented_matrix[i],
    ((0, n_input_z - ia_shape[0]),
     (0, n_input_x - ia_shape[1])),
     (0, n_input_y - ia_shape[2]))),
    'constant',
    constant_values=0)

我想您现在已经准备好使用魔术索引 NumPy.

重构代码的最后一部分

我的共同建议：

对代码的重复部分使用函数以避免像级联循环中那样的缩进；
如果你需要那么多嵌套循环，考虑一下递归，如果你没有它们就不行；
在官方documentation: they're really exciting ;) For example, indexing中探索NumPy的能力对这个任务有帮助；
使用 PyLint 和 Flake8 包来检查代码的质量。

你是想自己写神经网络，还是只想解决一些模式识别任务？ SciPy 库可能包含您需要的内容，它基于 NumPy。

Numpy 将 3D 可变大小卷列表转换为 4D 数组

Numpy convert list of 3D variable size volumes to 4D array

python

arrays

numpy

3d

4d