15 构建CNN（二）

这段代码用于测试之前定义的 conv_single_step 函数，执行卷积操作的单步并输出结果。

1. np.random.seed(1): 这行代码设置了随机数生成器的种子为1，以确保在不同运行中生成相同的随机数。

2. a_slice_prev = np.random.randn(4, 4, 3): 这行代码生成了一个随机的3维数组 a_slice_prev，表示输入数据的一部分。它的形状是 (4, 4, 3)，表示一个4x4x3的数据块。

3. W = np.random.randn(4, 4, 3): 这行代码生成了一个随机的3维数组 W，表示卷积核的权重参数。它的形状与 a_slice_prev 相同，即 (4, 4, 3)。

4. b = np.random.randn(1, 1, 1): 这行代码生成了一个随机的偏置参数 b，它是一个标量值。

5. Z = conv_single_step(a_slice_prev, W, b): 这行代码调用了之前定义的 conv_single_step 函数，将输入数据 a_slice_prev、卷积核 W 和偏置参数 b 传递给函数，并计算卷积操作的结果。结果存储在变量 Z 中。

6. print("Z =", Z): 这行代码输出了卷积操作的结果 Z。

总之，这段代码测试了 conv_single_step 函数，通过将随机生成的输入数据 a_slice_prev、卷积核 W 和偏置参数 b 传递给函数，计算了卷积操作的结果 Z。这是卷积神经网络中的基本卷积步骤。

def conv_forward(A_prev, W, b, hparameters):

    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
    
    (f, f, n_C_prev, n_C) = W.shape

    stride = hparameters['stride']
    pad = hparameters['pad']
    
    n_H = int((n_H_prev - f + 2 * pad) / stride) + 1
    n_W = int((n_W_prev - f + 2 * pad) / stride) + 1

    Z = np.zeros((m, n_H, n_W, n_C))
 
    A_prev_pad = zero_pad(A_prev, pad)
    
    for i in range(m):                                 
        a_prev_pad = A_prev_pad[i]                   
        for h in range(n_H):                         
            for w in range(n_W):                    
                for c in range(n_C): 
                    vert_start = h * stride
                    vert_end = vert_start + f
                    horiz_start = w * stride
                    horiz_end = horiz_start + f
                    a_slice_prev = a_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :]
                    Z[i, h, w, c] = conv_single_step(a_slice_prev, W[...,c], b[...,c])
 
    assert(Z.shape == (m, n_H, n_W, n_C))
    cache = (A_prev, W, b, hparameters)
    
    return Z, cache

这段代码定义了一个卷积层的前向传播函数 conv_forward，该函数用于执行卷积操作，并包含了一些计算和循环来处理输入数据、卷积核、偏置等参数。

• def conv_forward(A_prev, W, b, hparameters):: 这是函数的定义，它接受四个参数：

  • A_prev：先前层的激活输出，也就是输入数据，是一个4维数组。
  • W：卷积核的权重参数，是一个4维数组。
  • b：偏置参数，是一个3维数组。
  • hparameters：包含卷积的超参数的字典，其中包括 stride（步幅）和 pad（填充）的信息。

• (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape: 这行代码获取输入数据 A_prev 的形状信息，其中 m 是样本数，n_H_prev 和 n_W_prev 分别是输入图像的高度和宽度，n_C_prev 是通道数。

• (f, f, n_C_prev, n_C) = W.shape: 这行代码获取卷积核 W 的形状信息，其中 f 是卷积核的高度和宽度，n_C_prev 是输入通道数，n_C 是输出通道数。

• stride = hparameters['stride'] 和 pad = hparameters['pad']：这两行代码从超参数字典 hparameters 中提取步幅和填充信息。

• n_H 和 n_W：这两行代码计算输出特征图的高度和宽度，根据输入数据、卷积核和超参数计算而得。

• Z = np.zeros((m, n_H, n_W, n_C))：这行代码创建一个用于存储卷积结果的零数组 Z，其形状与输出特征图的形状相同。

• A_prev_pad = zero_pad(A_prev, pad): 这行代码调用之前定义的 zero_pad 函数，对输入数据进行填充，以处理边界情况。

• 接下来的循环嵌套用于执行卷积操作。它遍历样本 (m)、输出特征图的高度 (n_H)、输出特征图的宽度 (n_W) 和输出通道数 (n_C)。

• 在循环内部，计算 a_slice_prev，这是从输入数据 A_prev_pad 中切片出来的输入数据块，然后调用 conv_single_step 函数来执行单步卷积操作，将结果存储在 Z 中。

• assert(Z.shape == (m, n_H, n_W, n_C))：这行代码用来确保输出的 Z 的形状与预期的形状一致。

• 最后，函数返回卷积的结果 Z 和一个包含输入数据、卷积核、偏置和超参数的缓存 cache。

这个函数执行了卷积层的前向传播操作，将输入数据经过卷积核的滑动与相乘、加上偏置项后，生成了输出特征图 Z。

np.random.seed(1)
A_prev = np.random.randn(10, 4, 4, 3)
W = np.random.randn(2, 2, 3, 8)
b = np.random.randn(1, 1, 1, 8)
hparameters = {"pad" : 2,
               "stride": 1}

Z, cache_conv = conv_forward(A_prev, W, b, hparameters)
print("Z's mean =", np.mean(Z))
print("cache_conv[0][1][2][3] =", cache_conv[0][1][2][3])

这段代码测试了之前定义的 conv_forward 函数，用于执行卷积层的前向传播操作，并输出了卷积结果及缓存。

1. np.random.seed(1): 这行代码设置了随机数生成器的种子为1，以确保在不同运行中生成相同的随机数。

2. A_prev = np.random.randn(10, 4, 4, 3): 这行代码生成了一个随机的输入数据 A_prev，表示先前层的激活输出。它的形状是 (10, 4, 4, 3)，表示有10个样本，每个样本是一个4x4x3的数据块。

3. W = np.random.randn(2, 2, 3, 8): 这行代码生成了一个随机的卷积核 W，其形状为 (2, 2, 3, 8)，表示卷积核的大小为2x2，输入通道数为3，输出通道数为8。

4. b = np.random.randn(1, 1, 1, 8): 这行代码生成了一个随机的偏置参数 b，其形状为 (1, 1, 1, 8)，与卷积核的输出通道数相匹配。

5. hparameters = {"pad" : 2, "stride": 1}: 这行代码定义了超参数字典 hparameters，其中包括填充 (pad) 和步幅 (stride) 的信息。

6. Z, cache_conv = conv_forward(A_prev, W, b, hparameters): 这行代码调用了 conv_forward 函数，传递输入数据 A_prev、卷积核 W、偏置参数 b 和超参数 hparameters 给函数，并计算卷积层的前向传播结果 Z，同时返回了缓存 cache_conv 用于后续的反向传播。

7. print("Z's mean =", np.mean(Z)): 这行代码计算并输出卷积结果 Z 的平均值，以了解卷积操作的整体效果。

8. print("cache_conv[0][1][2][3] =", cache_conv[0][1][2][3]): 这行代码输出了缓存 cache_conv 中的一个元素，用于展示缓存的结构。

总之，这段代码测试了卷积层的前向传播操作，使用随机生成的输入数据、卷积核和偏置参数，计算了卷积结果 Z，并展示了一些相关信息。

np.random.seed(1)
A_prev = np.random.randn(10, 4, 4, 3)
W = np.random.randn(2, 2, 3, 8)
b = np.random.randn(1, 1, 1, 8)
hparameters = {"pad" : 2,
               "stride": 1}

Z, cache_conv = conv_forward(A_prev, W, b, hparameters)
print("Z's mean =", np.mean(Z))
print("cache_conv[0][1][2][3] =", cache_conv[0][1][2][3])

这段代码与之前的代码块相同，测试了卷积层的前向传播操作，使用了相同的输入数据 A_prev、卷积核 W、偏置参数 b 和超参数 hparameters。它执行了卷积操作并输出了卷积结果的平均值以及缓存的某个元素的值。这个示例旨在演示如何使用前向传播函数进行卷积操作。

def pool_forward(A_prev, hparameters, mode = "max"):
    """
    参数:
    A_prev -- 输入矩阵，也就是上一层的输出矩阵。维度是(m, n_H_prev, n_W_prev, n_C_prev)
    hparameters -- 超参数窗口大小f和步长s
    mode -- 池化模式,最大池化就写max，如果想用平均池化，就写average。
    
    返回值:
    A -- 池化层的输出矩阵，维度是(m, n_H, n_W, n_C)
    cache -- 缓存一些数据
    """

    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
    
    f = hparameters["f"] # 窗口大小
    stride = hparameters["stride"] # 步长
    
    # 计算输出矩阵的尺寸大小
    n_H = int(1 + (n_H_prev - f) / stride)
    n_W = int(1 + (n_W_prev - f) / stride)
    n_C = n_C_prev
    
    # 初始化输出矩阵
    A = np.zeros((m, n_H, n_W, n_C))    
    
    for i in range(m):                           # 遍历所有样本
        for h in range(n_H):                     # 纵向遍历输出矩阵
            for w in range(n_W):                 # 横向遍历输出矩阵
                for c in range (n_C):            # 遍历输出矩阵的深度
                    
                    # 计算出输入矩阵中本次应该本池化的区域的索引，也就是本次的池化窗口的索引
                    vert_start = h * stride
                    vert_end = vert_start + f
                    horiz_start = w * stride
                    horiz_end = horiz_start + f
                    
                    # 通过上面的索引取出将被池化的子矩阵窗口
                    a_prev_slice = A_prev[i, vert_start:vert_end, horiz_start:horiz_end, c]
                    
                    # 执行池化
                    if mode == "max":
                        A[i, h, w, c] = np.max(a_prev_slice) # np.max就是numpy库中求最大值的函数
                    elif mode == "average":
                        A[i, h, w, c] = np.mean(a_prev_slice)# 求平均值

    cache = (A_prev, hparameters)

    assert(A.shape == (m, n_H, n_W, n_C))
    
    return A, cache

这段代码定义了一个池化层的前向传播函数 pool_forward，用于执行池化操作（最大池化或平均池化），并返回池化层的输出和缓存。

• def pool_forward(A_prev, hparameters, mode = "max"):: 这是函数的定义，它接受三个参数：

  • A_prev：输入矩阵，也就是上一层的输出矩阵，维度是 (m, n_H_prev, n_W_prev, n_C_prev)。
  • hparameters：包含超参数的字典，其中包括窗口大小 f 和步幅 stride 的信息。
  • mode：池化模式，可以是 "max"（最大池化）或 "average"（平均池化），默认为 "max"。

• (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape: 这行代码获取输入矩阵 A_prev 的形状信息，其中 m 是样本数，n_H_prev 和 n_W_prev 分别是输入图像的高度和宽度，n_C_prev 是通道数。

• f = hparameters["f"] 和 stride = hparameters["stride"]: 这两行代码从超参数字典 hparameters 中提取窗口大小 f 和步幅 stride 的信息。

• 计算输出矩阵的尺寸 n_H 和 n_W，以及输出通道数 n_C。这是根据输入矩阵、窗口大小和步幅计算得出的。

• 初始化输出矩阵 A，其形状与输出尺寸相匹配。

• 接下来的嵌套循环用于执行池化操作。它遍历样本 (m)、输出特征图的高度 (n_H)、输出特征图的宽度 (n_W) 和输出通道数 (n_C)。

• 在循环内部，计算出输入矩阵中当前池化窗口的索引，并提取子矩阵窗口 a_prev_slice。

• 执行池化操作，如果 mode 是 "max"，则使用 np.max 函数计算窗口中的最大值，如果 mode 是 "average"，则使用 np.mean 函数计算窗口中的平均值。

• 最后，函数返回池化层的输出 A 和一个包含输入数据和超参数的缓存 cache。

这个函数用于执行池化层的前向传播操作，将输入数据 A_prev 经过池化操作（最大池化或平均池化）生成输出特征图 A。

# 单元测试
np.random.seed(1)
A_prev = np.random.randn(2, 4, 4, 3)
hparameters = {"stride" : 1, "f": 4}

A, cache = pool_forward(A_prev, hparameters)
print("mode = max")
print("A =", A)
print()
A, cache = pool_forward(A_prev, hparameters, mode = "average")
print("mode = average")
print("A =", A)

 

这段代码进行了两个池化层的单元测试，一个使用最大池化模式，另一个使用平均池化模式。

首先，测试最大池化模式（mode = max）：

1. np.random.seed(1): 这行代码设置了随机数生成器的种子为1，以确保在不同运行中生成相同的随机数。

2. A_prev = np.random.randn(2, 4, 4, 3): 这行代码生成了一个随机的输入数据 A_prev，表示上一层的输出矩阵。它的形状是 (2, 4, 4, 3)，表示有2个样本，每个样本是一个4x4x3的数据块。

3. hparameters = {"stride" : 1, "f": 4}: 这行代码定义了超参数字典 hparameters，包括步幅 stride 和窗口大小 f 的信息。在这个测试中，步幅为1，窗口大小为4x4。

4. A, cache = pool_forward(A_prev, hparameters): 这行代码调用了 pool_forward 函数，使用最大池化模式，默认情况下，计算池化层的输出 A 和缓存 cache。

5. print("mode = max"): 这行代码输出了当前测试模式，即最大池化模式。

6. print("A =", A): 这行代码输出了最大池化模式下的池化层输出 A。

接下来，测试平均池化模式（mode = average）：

1. A, cache = pool_forward(A_prev, hparameters, mode = "average"): 这行代码调用了 pool_forward 函数，指定了平均池化模式，计算池化层的输出 A 和缓存 cache。

2. print("mode = average"): 这行代码输出了当前测试模式，即平均池化模式。

3. print("A =", A): 这行代码输出了平均池化模式下的池化层输出 A。

总之，这段代码进行了两个池化层的单元测试，分别使用了最大池化模式和平均池化模式，并输出了池化层的输出结果。

def conv_backward(dZ, cache):
    """    
    参数:
    dZ -- 后一层相关的dZ，维度是(m, n_H, n_W, n_C)
    cache -- 前面的conv_forward()函数保存下来的缓存数据
    
    Returns:
    dA_prev -- 本卷积层输入矩阵的dA，维度是(m, n_H_prev, n_W_prev, n_C_prev)
    dW -- 本卷积层相关的dW,维度是(f, f, n_C_prev, n_C)
    db -- 本卷积层相关的db,维度是(1, 1, 1, n_C)
    """

    (A_prev, W, b, hparameters) = cache
    
    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
    
    (f, f, n_C_prev, n_C) = W.shape
    
    stride = hparameters["stride"] # 步长
    pad = hparameters["pad"] # padding数量
    
    (m, n_H, n_W, n_C) = dZ.shape
    
    dA_prev = np.zeros((m, n_H_prev, n_W_prev, n_C_prev))                           
    dW = np.zeros((f, f, n_C_prev, n_C))
    db = np.zeros((1, 1, 1, n_C))

    A_prev_pad = zero_pad(A_prev, pad)
    dA_prev_pad = zero_pad(dA_prev, pad)
    
    for i in range(m):                       # 遍历每一个样本
        
        a_prev_pad = A_prev_pad[i]
        da_prev_pad = dA_prev_pad[i]
        
        for h in range(n_H):                   # 遍历输出矩阵的高
            for w in range(n_W):               # 遍历输出矩阵的宽
                for c in range(n_C):           # 遍历输出矩阵的深度
                    
                    # 计算输入矩阵中的子矩阵的索引
                    vert_start = h
                    vert_end = vert_start + f
                    horiz_start = w
                    horiz_end = horiz_start + f
                    
                    # 取出当前进行卷积的子矩阵
                    a_slice = a_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :]

                    # 用上面的公式来计算偏导数
                    da_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] += W[:,:,:,c] * dZ[i, h, w, c]
                    dW[:,:,:,c] += a_slice * dZ[i, h, w, c]
                    db[:,:,:,c] += dZ[i, h, w, c]
                    
        dA_prev[i, :, :, :] = da_prev_pad[pad:-pad, pad:-pad, :]

    assert(dA_prev.shape == (m, n_H_prev, n_W_prev, n_C_prev))
    
    return dA_prev, dW, db

这段代码定义了卷积层的反向传播函数 conv_backward，用于计算关于输入数据 A_prev、权重参数 W 和偏置参数 b 的梯度，以及返回关于上一层的梯度 dA_prev。

• def conv_backward(dZ, cache):: 这是函数的定义，它接受两个参数：

  • dZ：后一层相关的梯度，维度是 (m, n_H, n_W, n_C)，其中 m 是样本数，n_H 和 n_W 分别是输出特征图的高度和宽度，n_C 是输出通道数。
  • cache：前向传播函数 conv_forward 保存下来的缓存数据，其中包含了输入数据 A_prev、权重参数 W、偏置参数 b 和超参数的信息。

• (A_prev, W, b, hparameters) = cache: 这行代码从缓存中获取前向传播所需的数据，包括输入数据 A_prev、权重参数 W、偏置参数 b 和超参数 hparameters。

• 获取输入数据的形状信息 (m, n_H_prev, n_W_prev, n_C_prev)。

• 获取权重参数 W 的形状信息 (f, f, n_C_prev, n_C)。

• 从超参数字典 hparameters 中获取步幅 stride 和填充 pad 的信息。

• 计算关于输入数据的梯度 dA_prev，初始化为零数组，形状与输入数据 A_prev 相同。

• 初始化权重参数 W 和偏置参数 b 的梯度 dW 和 db 为零数组，形状分别与 W 和 b 相同。

• 使用 zero_pad 函数对输入数据 A_prev 和 dA_prev 进行填充，以处理边界情况。

• 开始循环遍历每个样本 (m) 和输出特征图的高度和宽度 (n_H, n_W) 以及输出通道数 (n_C)。

• 在循环内部，计算输入矩阵中当前子矩阵的索引，并提取当前进行卷积的子矩阵 a_slice。

• 使用反向传播的链式法则，计算 da_prev_pad、dW 和 db。

• 更新 dA_prev 以将填充的部分去除，得到 dA_prev。

• 最后，函数返回关于输入数据 A_prev、权重参数 W 和偏置参数 b 的梯度，以及关于上一层的梯度 dA_prev。

这个函数用于计算卷积层的反向传播，即计算关于输入数据、权重参数和偏置参数的梯度，以及返回关于上一层的梯度 dA_prev。

def create_mask_from_window(x):

    # x是一个矩阵。np.max(x)会得到最大元素。
    # mask是一个与x维度相同的矩阵，里面其余元素都为0，只有x最大值元素的位置处为1
    mask = x == np.max(x)
    
    return mask

这段代码定义了一个函数 create_mask_from_window(x)，用于创建一个掩码（mask）矩阵，该掩码矩阵与输入矩阵 x 的维度相同，其中除了最大元素的位置为1外，其余位置都为0。

• def create_mask_from_window(x):: 这是函数的定义，它接受一个参数 x，该参数是一个矩阵。

• mask = x == np.max(x): 这行代码创建了一个掩码 mask，通过比较输入矩阵 x 中的每个元素是否等于 np.max(x)，即矩阵中的最大值。这将生成一个与输入矩阵 x 维度相同的布尔值矩阵，其中最大值位置为 True（1），其他位置为 False（0）。

• 最后，函数返回生成的掩码 mask。

这个函数通常用于最大池化的反向传播过程中，帮助确定哪些元素对于反向传播的梯度计算是最重要的，因为只有最大值元素的梯度会传播回原始输入。

np.random.seed(1)
x = np.random.randn(2,3)
mask = create_mask_from_window(x)
print('x = ', x)
print("mask = ", mask)

这段代码测试了 create_mask_from_window 函数，用于创建一个掩码矩阵，以标记输入矩阵 x 中的最大值位置。

1. np.random.seed(1): 这行代码设置了随机数生成器的种子为1，以确保在不同运行中生成相同的随机数。

2. x = np.random.randn(2,3): 这行代码生成了一个随机的输入矩阵 x，其形状是 (2, 3)，包含了随机的浮点数值。

3. mask = create_mask_from_window(x): 这行代码调用了 create_mask_from_window 函数，传递输入矩阵 x 给函数，生成了一个掩码矩阵 mask，其中最大值位置为1，其他位置为0。

4. print('x = ', x): 这行代码输出了输入矩阵 x 的值。

5. print("mask = ", mask): 这行代码输出了生成的掩码矩阵 mask。

根据生成的随机数种子和输入矩阵 x，您将看到 x 的随机值以及与之对应的掩码矩阵 mask，其中最大值位置为1，其他位置为0。

这个函数通常用于最大池化的反向传播中，以确定哪些元素对于反向传播的梯度计算是最重要的。

def distribute_value(dz, shape):
    """    
    参数:
    dz -- 一个数值
    shape -- 输出矩阵的维度
    
    返回值:
    a -- a的维度就是shape，里面的值是又dz平分而来的
    """
    (n_H, n_W) = shape
    
    # 计算平均值
    average = dz / (n_H * n_W)
    
    # 构建输出矩阵
    a = np.ones(shape) * average
    
    return a

这段代码定义了一个函数 distribute_value(dz, shape)，用于将一个数值 dz 平均分配到一个指定维度的矩阵中，并返回这个矩阵。

• def distribute_value(dz, shape):: 这是函数的定义，它接受两个参数：

  • dz：一个数值，要平均分配到输出矩阵中。
  • shape：输出矩阵的维度。

• (n_H, n_W) = shape: 这行代码从参数 shape 中获取输出矩阵的高度 n_H 和宽度 n_W。

• average = dz / (n_H * n_W): 这行代码计算了要平均分配到每个位置的数值，通过将输入数值 dz 除以输出矩阵的总元素个数 (n_H * n_W) 得到平均值。

• 构建输出矩阵 a，其维度与参数 shape 相同，然后将每个位置的值都设置为平均值，即 a = np.ones(shape) * average。

• 最后，函数返回构建的输出矩阵 a。

这个函数通常用于平均池化的反向传播中，以将梯度平均分配回池化窗口中的所有位置。

a = distribute_value(2, (2,2))
print('distributed value =', a)

这段代码测试了 distribute_value 函数，用于将数值 2 平均分配到一个 (2, 2) 维度的矩阵中。

1. a = distribute_value(2, (2, 2)): 这行代码调用了 distribute_value 函数，将数值 2 平均分配到一个 (2, 2) 维度的矩阵中，将结果保存在变量 a 中。

2. print('distributed value =', a): 这行代码输出了生成的矩阵 a，其中每个位置的值都是 2 除以矩阵中总元素个数 (2 * 2) 的结果，即平均值。

3. 这表示数值 2 已经平均分配到了 (2, 2) 维度的矩阵中，每个位置的值都是 0.5。这个函数通常用于池化层的反向传播中，以将梯度平均分配回池化窗口中的所有位置 。

   def pool_backward(dA, cache, mode = "max"):
       """
       参数:
       dA -- 本池化层的输出矩阵对应的偏导数
       cache -- 前向传播时缓存起来的数值
       mode -- 是最大池化还是平均池化，("max" 或 "average")
       
       Returns:
       dA_prev -- 本池化层的输入矩阵对应的偏导数
       """
   
       # A_prev是本池化层的输入矩阵
       (A_prev, hparameters) = cache
       
       stride = hparameters["stride"]
       f = hparameters["f"]
       
       m, n_H_prev, n_W_prev, n_C_prev = A_prev.shape
       m, n_H, n_W, n_C = dA.shape
       
       dA_prev = np.zeros(A_prev.shape)
       
       for i in range(m):                     
           a_prev = A_prev[i]
           for h in range(n_H):                  
               for w in range(n_W):             
                   for c in range(n_C):          
                       vert_start = h
                       vert_end = vert_start + f
                       horiz_start = w
                       horiz_end = horiz_start + f
                       
                       if mode == "max":
                           a_prev_slice = a_prev[vert_start:vert_end, horiz_start:horiz_end, c]
                           mask = create_mask_from_window(a_prev_slice)
                           dA_prev[i, vert_start:vert_end, horiz_start:horiz_end, c] += np.multiply(mask, dA[i, h, w, c])
                           
                       elif mode == "average":
                           da = dA[i, h, w, c]
                           shape = (f, f)
                           dA_prev[i, vert_start:vert_end, horiz_start:horiz_end, c] += distribute_value(da, shape)
                           
       assert(dA_prev.shape == A_prev.shape)
       
       return dA_prev

    

   这段代码定义了池化层的反向传播函数 pool_backward，用于计算关于输入数据 A_prev 的梯度 dA_prev，其中包括最大池化和平均池化两种模式。

   • def pool_backward(dA, cache, mode="max"):: 这是函数的定义，它接受三个参数：

     • dA：池化层的输出矩阵对应的偏导数，维度是 (m, n_H, n_W, n_C)，其中 m 是样本数，n_H 和 n_W 分别是输出特征图的高度和宽度，n_C 是输出通道数。
     • cache：前向传播函数 pool_forward 缓存的信息，其中包含输入数据 A_prev 和超参数的信息。
     • mode：池化模式，可以是 "max"（最大池化）或 "average"（平均池化），默认为 "max"。

   • 从缓存中获取输入数据 A_prev 和超参数 hparameters。

   • 从超参数中获取步幅 stride 和窗口大小 f。

   • 获取输入数据 A_prev 的形状信息 (m, n_H_prev, n_W_prev, n_C_prev)。

   • 获取池化层的输出梯度 dA 的形状信息 (m, n_H, n_W, n_C)。

   • 初始化输出梯度 dA_prev 为与输入数据 A_prev 相同的形状，初始值为零。

   • 开始循环遍历每个样本 (m) 和输出特征图的高度和宽度 (n_H, n_W) 以及输出通道数 (n_C)。

   • 在循环内部，根据池化模式进行不同的计算：

     • 如果 mode 是 "max"，则使用 create_mask_from_window 函数创建一个掩码 mask，将其与池化层的输出梯度 dA 相乘，然后加到 dA_prev 中，以计算最大池化的梯度。
     • 如果 mode 是 "average"，则使用 distribute_value 函数将池化层的输出梯度 dA 平均分配到池化窗口的每个位置上，并加到 dA_prev 中，以计算平均池化的梯度。

   • 最后，函数返回计算得到的输入数据的梯度 dA_prev。

   这个函数用于计算池化层的反向传播，根据池化模式（最大池化或平均池化）计算关于输入数据 A_prev 的梯度 dA_prev。

   np.random.seed(1)
   A_prev = np.random.randn(5, 5, 3, 2)
   hparameters = {"stride" : 1, "f": 2}
   A, cache = pool_forward(A_prev, hparameters)
   dA = np.random.randn(5, 4, 2, 2)
   
   dA_prev = pool_backward(dA, cache, mode = "max")
   print("mode = max")
   print('mean of dA = ', np.mean(dA))
   print('dA_prev[1,1] = ', dA_prev[1,1])  
   print()
   dA_prev = pool_backward(dA, cache, mode = "average")
   print("mode = average")
   print('mean of dA = ', np.mean(dA))
   print('dA_prev[1,1] = ', dA_prev[1,1]) 

   这段代码测试了池化层的反向传播函数 pool_backward，包括最大池化模式和平均池化模式的测试。

   1. np.random.seed(1): 这行代码设置了随机数生成器的种子为1，以确保在不同运行中生成相同的随机数。

   2. A_prev = np.random.randn(5, 5, 3, 2): 这行代码生成了一个随机的输入数据 A_prev，其形状是 (5, 5, 3, 2)，包含了随机的浮点数值。

   3. hparameters = {"stride" : 1, "f": 2}: 这行代码设置了池化层的超参数，包括步幅 stride 和窗口大小 f。

   4. A, cache = pool_forward(A_prev, hparameters): 这行代码调用了池化层的前向传播函数 pool_forward，计算了池化层的输出 A 和缓存信息 cache。

   5. dA = np.random.randn(5, 4, 2, 2): 这行代码生成了一个随机的池化层输出梯度 dA，其形状是 (5, 4, 2, 2)，包含了随机的浮点数值。

   6. dA_prev = pool_backward(dA, cache, mode = "max"): 这行代码调用了池化层的反向传播函数 pool_backward，以最大池化模式计算了输入数据的梯度 dA_prev。

   7. print("mode = max"): 这行代码输出当前测试的模式是最大池化。

   8. print('mean of dA = ', np.mean(dA)): 这行代码输出池化层输出梯度 dA 的均值。

   9. print('dA_prev[1,1] = ', dA_prev[1,1]): 这行代码输出输入数据的梯度 dA_prev 中的一个特定位置 (1, 1) 的值。

   10. dA_prev = pool_backward(dA, cache, mode = "average"): 这行代码再次调用了池化层的反向传播函数 pool_backward，以平均池化模式计算了输入数据的梯度 dA_prev。

   11. print("mode = average"): 这行代码输出当前测试的模式是平均池化。

   12. print('mean of dA = ', np.mean(dA)): 这行代码再次输出池化层输出梯度 dA 的均值。

   13. print('dA_prev[1,1] = ', dA_prev[1,1]): 这行代码再次输出输入数据的梯度 dA_prev 中的一个特定位置 (1, 1) 的值。

   在每种池化模式下，您可以看到输出了池化层输出梯度的均值以及输入数据的梯度 dA_prev 中的一个特定位置的值。这个测试用例可以验证池化层的反向传播函数是否能够正确计算输入数据的梯度。