Numpy将三维可变大小的列表转换为4D阵列

Question

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

让我备份，网络的输入是一个3D卷。我生成可变大小的3D卷，然后用零填充每个卷，以使输入音量不变。检查here是否存在填充问题（现已解决）。

我生成一个可变大小的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魔术索引你的代码的最后一部分，为您提供了数组的大小。

我的共同建议：

• 对代码的重复部分，以避免这种缩进就像在你的循环梯级利用功能;
• 如果你需要这么多的嵌套循环，想想递归，如果你不能没有它们处理;
• 在官方探索NumPy的能力documentation：他们真的很令人兴奋;）例如，indexing对此任务有帮助;
• 使用PyLint和Flake8包来检查代码的质量。

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