声明

本文参考Deep-Learning-Specialization-Coursera/Convolution_model_Step_by_Step_v1.ipynb at main · abdur75648/Deep-Learning-Specialization-Coursera · GitHub，力求理解。

资料下载

链接：https://pan.baidu.com/s/1LoMe9bS_ig0wB7ubR9m39Q
提取码：afhc，请在开始之前下载好所需资料。

【博主使用的python版本：3.9.12】，当然也使用tensorflow2.

1. 神经网络的底层搭建

  这里，我们要实现一个拥有卷积层（CONV）和池化层（POOL）的网络，它包含了前向和反向传播。

nH,nW,nc,是指分别表示给定层的图像的高度、宽度和通道数。如果你想特指某一层，那么可以这样写：nH[L],nW[L],nc[L]

1 – Packages

我们先要引入一些库：

import numpy as np
import h5py
import matplotlib.pyplot as plt
from public_tests import *

%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

np.random.seed(1)

2 – Outline of the Assignment

我们将实现一个卷积神经网络的一些模块，下面我们将列举我们要实现的模块的函数功能：

  1. 卷积模块，包含了以下函数：
  • 使用0扩充边界
  • 卷积窗口
  • 前向卷积
  • 反向卷积（可选）

　　  2.池化模块，包含了以下函数：

  • 前向池化
  • 创建掩码
  • 值分配
  • 反向池化（可选）
  • 我们将在这里从底层搭建一个完整的模块，之后我们会用TensorFlow实现。模型结构如下：

  需要注意的是我们在前向传播的过程中，我们会存储一些值，以便在反向传播的过程中计算梯度值。

3 – Convolutional Neural Networks

尽管编程框架使卷积容易使用，但它们仍然是深度学习中最难理解的概念之一。卷积层将输入转换成不同维度的输出，如下所示。

 我们将一步步构建卷积层，我们将首先实现两个辅助函数：一个用于零填充，另一个用于计算卷积。

3.1 – Zero-Padding

边界填充将会在图像边界周围添加值为0的像素点，如下图所示：

使用0填充边界有以下好处：

卷积了上一层之后的CONV层，没有缩小高度和宽度。 这对于建立更深的网络非常重要，否则在更深层时，高度/宽度会缩小。 一个重要的例子是“same”卷积，其中高度/宽度在卷积完一层之后会被完全保留。

它可以帮助我们在图像边界保留更多信息。在没有填充的情况下，卷积过程中图像边缘的极少数值会受到过滤器的影响从而导致信息丢失。

  我们将实现一个边界填充函数，它会把所有的样本图像X XX都使用0进行填充。我们可以使用np.pad来快速填充。需要注意的是如果你想使用pad = 1填充数组**a**.shape = ( 5 , 5 , 5 , 5 , 5 )的第二维，使用pad = 3填充第4维，使用pad = 0来填充剩下的部分，我们可以这么做：

 Average Pooling – Backward Pass

在最大值池化层中，对于每个输入窗口，输出的所有值都来自输入中的最大值，但是在均值池化层中，因为是计算均值，所以输入窗口的每个元素对输出有一样的影响，我们来看看如何反向传播吧~

def distribute_value(dz,shape):
    """
    给定一个值，为按矩阵大小平均分配到每一个矩阵位置中。
    
    参数：
        dz - 输入的实数
        shape - 元组，两个值，分别为n_H , n_W
        
    返回：
        a - 已经分配好了值的矩阵，里面的值全部一样。
    
    """
    #获取矩阵的大小
    (n_H , n_W) = shape
    
    #计算平均值
    average = dz / (n_H * n_W)
    
    #填充入矩阵
    a = np.ones(shape) * average
    
    return a

测试一下：

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


assert type(a) == np.ndarray, "Output must be a np.ndarray"
assert a.shape == (2, 2), f"Wrong shape {a.shape} != (2, 2)"
assert np.sum(a) == 2, "Values must sum to 2"

a = distribute_value(100, (10, 10))
assert type(a) == np.ndarray, "Output must be a np.ndarray"
assert a.shape == (10, 10), f"Wrong shape {a.shape} != (10, 10)"
assert np.sum(a) == 100, "Values must sum to 100"

print("\033[92m All tests passed.")
distributed value = [[0.5 0.5]
 [0.5 0.5]]
 All tests passed.

 Putting it Together: Pooling Backward

def pool_backward(dA,cache,mode = "max"):
    """
    实现池化层的反向传播
    
    参数:
        dA - 池化层的输出的梯度，和池化层的输出的维度一样
        cache - 池化层前向传播时所存储的参数。
        mode - 模式选择，【"max" | "average"】
        
    返回：
        dA_prev - 池化层的输入的梯度，和A_prev的维度相同
    
    """
    #获取cache中的值
    (A_prev , hparaeters) = cache
    
    #获取hparaeters的值
    f = hparaeters["f"]
    stride = hparaeters["stride"]
    
    #获取A_prev和dA的基本信息
    (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_like(A_prev)
    
    #开始处理数据
    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
                        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 = 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

测试一下：

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)
print(A.shape)
print(cache[0].shape)
dA = np.random.randn(5, 4, 2, 2)

dA_prev1 = pool_backward(dA, cache, mode = "max")
print("mode = max")
print('mean of dA = ', np.mean(dA))
print('dA_prev1[1,1] = ', dA_prev1[1, 1])  
print()
dA_prev2 = pool_backward(dA, cache, mode = "average")
print("mode = average")
print('mean of dA = ', np.mean(dA))
print('dA_prev2[1,1] = ', dA_prev2[1, 1]) 
print("\033[92m All tests passed.")
(5, 4, 2, 2)
(5, 5, 3, 2)
mode = max
mean of dA =  0.14571390272918056
dA_prev1[1,1] =  [[ 0.          0.        ]
 [ 5.05844394 -1.68282702]
 [ 0.          0.        ]]

mode = average
mean of dA =  0.14571390272918056
dA_prev2[1,1] =  [[ 0.08485462  0.2787552 ]
 [ 1.26461098 -0.25749373]
 [ 1.17975636 -0.53624893]]
 All tests passed.

到此就结束了，下面我们进行应用。

 

原文地址：http://www.cnblogs.com/kk-style/p/16905693.html

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，请务用于商业用途! 3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！ 8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载 声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性