Numpy 为什么输入图像在卷积运算后会翻转？

我试图从头开始创建卷积运算，以便理解引擎盖下的内容。当我看到卷积层后的激活时，图像被翻转。我只是想问问我做的对不对。我用一张附在下面的图片进行了实验。我也连接激活从卷积层跨越3个通道

输入图像的大小=（64,64,3） 卷积层后激活的大小=（33,33,3）

该图像将“5”表示为符号

def zero_pad(self, X, pad):
    """
    Set padding to the image X.

    Pads with zeros all images of the dataset X.
    Zeros are added around the border of an image.

    Parameters:
    X -- Image -- numpy array of shape (m, n_H, n_W, n_C)
    pad -- padding amount -- int

    Returns:
    X_pad -- Image padded with zeros around width and height. -- numpy array of shape (m, n_H + 2*pad, n_W + 2*pad, n_C)

    """
    X_pad = np.pad(X, ((0, 0), (pad, pad), (pad, pad), (0, 0)), 'constant')
    return X_pad

def convolve(self, image_slice, W, b):
    """
    Apply a filter defined by W on a single slice of an image.

    Parameters:
    image_slice -- slice of input data -- numpy array of shape (f, f, n_C_prev)
    W -- Weight parameters contained in a window - numpy array of shape (f, f, n_C_prev)
    b -- Bias parameters contained in a window - numpy array of shape (1, 1, 1)

    Returns:
    Z -- a scalar value, result of convolving the sliding window (W, b) on image_slice

    """
    s = np.multiply(image_slice, W)
    z = np.sum(s)
    Z = z + float(b)
    return Z

def get_corners(self, height, width, filter_size, stride):
    """
    Get corners of the image relative to stride.

    Parameters:
    height -- height of an image -- int
    width -- width of an image -- int
    filter_size -- size of filter -- int
    stride -- amount by which the filter shifts -- int

    Returns:
    vert_start -- a scalar value, upper left corner of the box.
    vert_end -- a scalar value, upper right corner of the box.
    horiz_start -- a scalar value, lower left corner of the box.
    horiz_end -- a scalar value, lower right corner of the box.

    """
    vert_start = height * stride
    vert_end = vert_start + filter_size
    horiz_start = width * stride
    horiz_end = horiz_start + filter_size
    return vert_start, vert_end, horiz_start, horiz_end

def forward(self, A_prev):
    """
    Forward proporgation for convolution.

    This takes activations from previous layer and then convolve it
    with a filter defined by W with bias b.

    Parameters:
    A_prev -- output activations of the previous layer, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)

    Returns:
    Z -- convolution output, numpy array of shape (m, n_H, n_W, n_C)

    """
    np.random.seed(self.seed)
    self.A_prev = A_prev
    filter_size, filter_size, n_C_prev, n_C = self.params[0].shape
    m, n_H_prev, n_W_prev, n_C_prev = self.A_prev.shape
    Z = np.zeros((m, self.n_H, self.n_W, self.n_C))
    A_prev_pad = self.zero_pad(self.A_prev, self.pad)
    for i in range(m):
        a_prev_pad = A_prev_pad[i, :, :, :]
        for h in range(self.n_H):
            for w in range(self.n_W):
                for c in range(n_C):
                    vert_start, vert_end, horiz_start, horiz_end = self.get_corners(
                        h, w, self.filter_size, self.stride)
                    #if horiz_end <= a_prev_pad.shape[1] and vert_end <= a_prev_pad.shape[0]:
                    a_slice_prev = a_prev_pad[
                            vert_start:vert_end, horiz_start:horiz_end, :]
                    Z[i, h, w, c] = self.convolve(
                            a_slice_prev, self.params[0][:, :, :, c], self.params[1][:, :, :, c])
    self.Z_test = Z
    assert (Z.shape == (m, self.n_H, self.n_W, self.n_C))
    return Z

def zero_pad（self，X，pad）：
"""
将填充设置为图像X。
用零填充数据集X的所有图像。
在图像的边框周围添加零。
参数：
X——图像——形状的numpy数组（m，n_H，n_W，n_C）
pad--填充量--int
返回：
X_焊盘——图像在宽度和高度周围用零填充。--形状的numpy数组（m，n_H+2*焊盘，n_W+2*焊盘，n_C）
"""
X_pad=np.pad（X，（（0，0），（pad，pad），（pad，pad），（0，0）），常数）
返回X_焊盘
def卷积（自、图像_切片、W、b）：
"""
在图像的单个切片上应用由W定义的过滤器。
参数：
图像切片——输入数据切片——形状的numpy数组（f，f，n\u C\u prev）
W——形状（f，f，n_C_prev）的窗口numpy数组中包含的权重参数
b——形状（1，1，1）的窗口numpy数组中包含的偏差参数
返回：
Z——一个标量值，是在图像_切片上卷积滑动窗口（W，b）的结果
"""
s=np.乘法（图像×切片，W）
z=np.和
Z=Z+浮动（b）
返回Z
def获取角（自身、高度、宽度、过滤器大小、步幅）：
"""
获取图像相对于步幅的角点。
参数：
高度--图像的高度--int
宽度--图像的宽度--int
过滤器大小--过滤器大小--整数
步长--过滤器移动的量--int
返回：
vert_start——一个标量值，位于框的左上角。
vert_end——一个标量值，位于框的右上角。
horiz_start——一个标量值，位于框的左下角。
horiz_end——一个标量值，位于框的右下角。
"""
垂直起点=高度*步幅
垂直结束=垂直开始+过滤器大小
水平起点=宽度*步幅
水平线结束=水平线开始+过滤器大小
返回垂直开始、垂直结束、水平开始、水平结束
def前进（自，A_上）：
"""
用于卷积的正向比例。
这将从上一层获取激活，然后将其卷积
使用由W定义的滤波器，偏置为b。
参数：
A_prev——前一层的输出激活，形状的numpy数组（m，n_H_prev，n_W_prev，n_C_prev）
返回：
Z——卷积输出，形状（m，n_H，n_W，n_C）的numpy数组
"""
np.random.seed（self.seed）
self.A_prev=A_prev
filter\u size，filter\u size，n\u C\u prev，n\u C=self.params[0]。形状
m、 n_H_prev，n_W_prev，n_C_prev=self.A_prev.shape
Z=np.zero（（m，self.n_H，self.n_W，self.n_C））
A\u prev\u pad=self.zero\u pad（self.A\u prev，self.pad）
对于范围内的i（m）：
a_prev_pad=a_prev_pad[i，：，：，：]
对于范围内的h（自身n_h）：
对于范围内的w（自身n_w）：
对于范围内的c（n_c）：
垂直起点、垂直终点、水平起点、水平终点=自转角(
h、 w，自我过滤（大小，自我步幅）
#如果horiz_end你能提供get_角落的来源。。。我有一种强烈的预感，那就是问题必须解决there@KylePena我对我的问题进行了编辑，添加了额外的代码。图像被转置，而不是“颠倒”，这意味着y轴和x轴已经互换。我不想麻烦你，但是你也可以包括你的渲染代码（你用来生成上面的图像的代码）和你使用的任何其他代码吗？我已经读了好几遍了，我都看不出这个错误。我现在在想matplotlib正在做这件事。好吧，我想出来了，这是一个相当愚蠢的错误。我在做plt.imshow（image，origin='lower'），而不是plt.imshow（image，origin='lower'）。我想我是对的，马普洛利布是罪魁祸首。