Python 如何在3D卷积阵列上执行最大池操作？

我正在用numpy构建一个卷积神经网络，我不确定我对3D（HxWxD）输入图像的池处理是否正确

例如，我有一个形状为（12x12x3）的图像，我将其卷积为（6x6x3），我希望执行最大池，以便获得一个（3x3x3）图像。为此，我选择过滤器大小（2x2）和步幅2

output_size=int（（conv.shape[0]-F）/S+1）
pool=np.zero（（输出大小，输出卷，3））#池数组
对于范围内的k（conv.shape[-1]）：#循环conv深度
i_步长=0
对于范围内的i（输出大小）：
j_步长=0
对于范围内的j（输出尺寸）：
pool[i，j，k]=np.amax（conv[i_步幅：i_步幅+F，
j_步幅：j_步幅+F，k]，0）
j_步长+=S
i_步长+=S

对于卷积数组的第一个通道

conv[：，：，0]

。 将其与最大池阵列的第一个通道进行比较

池[：，：，0]

。乍一看，我可以看出池操作是不正确的，

conv[0:2,0:2,0]

（大部分为灰色）肯定不是

pool[0,0,0]

（黑色），您可能希望它是灰色的阴影之一。所以，我确信这里肯定出了问题。我的for循环或我正在进行的两个比较都是错误的

---

如果有人能帮助我更好地理解3维阵列上的池操作，那肯定会有帮助。

最大池生成与其输入相同的深度。考虑到这一点，我们可以关注输入conv的单个片段（沿深度）。对于任意索引处的单个片段，您有一个NxN维度的简单图像。您定义了过滤器大小2和步幅2。最大池只不过是在输入图像上迭代，并在当前“子图像”上获得最大值

---

我不清楚为什么对池中的单个元素使用max行转置。

我想我最初的困惑来自卷积运算和池运算的半相似性。对于卷积运算，需要在深度上循环以更新每个颜色通道的内核。这就是我最大的问题所在。谢谢

import numpy as np

F = 2
S = 2
conv = np.array(
    [
        [
            [[.5, .1], [.1, .0], [.2, .7], [.1, .3], [.0, .1], [.3, .8]],
            [[.0, .9], [.5, .7], [.3, .1], [.9, .2], [.8, .7], [.1, .9]],
            [[.1, .8], [.1, .2], [.6, .2], [.0, .3], [.1, .3], [.0, .8]],
            [[.0, .6], [.6, .4], [.2, .8], [.6, .8], [.9, .1], [.3, .1]],
            [[.3, .9], [.7, .6], [.7, .6], [.5, .4], [.7, .2], [.8, .1]],
            [[.1, .8], [.9, .3], [.2, .7], [.8, .4], [.0, .5], [.8, .0]]
        ],
        [
            [[.1, .2], [.1, .0], [.5, .3], [.0, .4], [.0, .5], [.0, .6]],
            [[.3, .6], [.6, .4], [.1, .2], [.6, .2], [.2, .3], [.2, .4]],
            [[.2, .1], [.4, .2], [.0, .4], [.5, .6], [.7, .6], [.7, .2]],
            [[.0, .7], [.5, .3], [.4, .0], [.4, .6], [.2, .2], [.2, .7]],
            [[.0, .5], [.3, .0], [.3, .8], [.3, .2], [.6, .3], [.5, .2]],
            [[.6, .2], [.2, .5], [.5, .4], [.1, .0], [.2, .6], [.1, .8]]
        ]
    ])

number_of_images, image_height, image_width, image_depth = conv.shape
output_height = (image_height - F) // S + 1
output_width = (image_width - F) // S + 1

pool = np.zeros((number_of_images, output_height, output_width, image_depth))
for k in range(number_of_images):
    for i in range(output_height):
        for j in range(output_width):
            pool[k, i, j, :] = np.max(conv[k, i*S:i*S+F, j*S:j*S+F, :])

print(pool[0, :, :, 0])
[[0.9 0.9 0.9]
 [0.8 0.8 0.9]
 [0.9 0.8 0.8]]
print(pool[0, :, :, 1])
[[0.9 0.9 0.9]
 [0.8 0.8 0.9]
 [0.9 0.8 0.8]]
print(pool[1, :, :, 0])
[[0.6 0.6 0.6]
 [0.7 0.6 0.7]
 [0.6 0.8 0.8]]
print(pool[1, :, :, 1])
[[0.6 0.6 0.6]
 [0.7 0.6 0.7]
 [0.6 0.8 0.8]]