实战教程 | 使用Scratch中的NumPy构建卷积神经网络，开放源码-阿里云开发者社区

终于和大家见面了！见字如面，这中间遇到点始料未及的事情，但终究将该实践指导撰写完毕。

按照常规，我本以为这是一个类似于之前做过的专栏、课程，需要先写一个专栏概述，介绍本专栏/课程具体包含的内容，给出大致课程的安排，最后带领大家一起学习交流。最后发现，咱们这边chat不是这样的方式，是一篇文章，这跟我之前的预期不太一样，所以在接到这边平台的飘静的审稿通知后，不得不马不停蹄从3号重新规划文章内容，编写源程序。总之，这边的文章质量真的是对得起读者，审稿很仔细。

接下来，我大致将此文按照这样的逻辑进行撰写。分享机器学习、计算机视觉的基础知识（不会很难，从小白开始），接着我们以一个实际的项目，带领大家自己动手实践，这也是我这个chat最想做的。最后，结合本chat申请时向读者承诺的五点，分享更多学习资料、进阶项目实战，这部分属于我CSDN上的专栏，最后会按照顺序给出相应的链接，供大家选择学习。

理论篇：算法基础（可选择后看）

本专栏所涉及的项目所需机器学习/图像处理知识并不深入，但我之前也开设了《机器学习算法讲解与Python实现》和《计算机视觉前沿论文研读》两个专栏。一个更偏算法理论，一个则关注于计算机视觉顶会的前沿论文成果，解读新的方法和Idea。

《机器学习算法讲解与Python实现》

该专栏分类讲解机器学习算法原理，深度解析决策树、贝叶斯算法、逻辑回归、梯度下降、集成学习、k最近邻、支持向量机等，并给出Python实现源程序，同时分享以实战为导向的Kaggle进阶指南。

- 专栏链接 https://blog.csdn.net/charmve/category_9657673.html

《计算机视觉前沿论文研读》

研读计算机视觉顶会论文，CVPR、ECCV、ICCV等，也有部分项目开源到Github上，论文、源码、数据集。

链接：https://github.com/Charmve/Mirror-Glass-Detection

专栏链接 https://blog.csdn.net/charmve/category_10281912_2.html

计算机视觉实战 | 练手项目，开放源码

知乎上收到了太多人给我的私信，想找可以具体操作的机器视觉项目，回复的时候总是零零散散，我经过大半年的收集整理，现完成此专栏。例如手写字识别、人脸识别、表情识别、图像分割、表面缺陷检测、车道线检测、车辆可通行区域检测等项目，提供完整指导文档和开源代码…

专栏链接 https://blog.csdn.net/charmve/category_10595130.html

实战案例（本文核心）

为什么说上述两个关于机器学习基础的专栏可以跳过？我的考虑是，如果对于机器学习刚入门的同学，直接上手算法理论，公式推导很容易消耗我们的学习热情和积极性；另外，对于一些非研究人员，我们做项目的直接目的是能跑出实验结果，一开始就带着工程思维去学习，效率会很高，学习的积极性也容易保持。这也是当前很多模型都已在相应的深度学习框架下集成了模块和函数库。而对于剩余一部分，可能需要重新回顾上述两章内容，深入理解算法原理，对算法性能的提升、模型的压缩优化都是很有必要的。

在某些情况下，直接调用已经搭好的模型可能是非常方便且有效的，比如Caffe、TensorFlow工具箱，但这些工具箱需要的硬件资源比较多，不利于初学者实践和理解。因此，为了更好的理解并掌握相关知识，最好是能够自己编程实践下。本文将展示如何使用NumPy来构建卷积神经网络（Convolutional Neural Network , CNN）。

本文将仅使用NumPy实现CNN网络，创建三个层模块，分别为卷积层（Conv）、ReLu激活函数和最大池化（max pooling）。

使用Scratch中的NumPy构建卷积神经网络

涉及的主要步骤如下：

读取输入图像
准备过滤器
转换层：将每个滤镜与输入图像进行卷积
ReLU层：在特征图上应用ReLU激活功能（conv层的输出）
最大池化层：在ReLU层的输出上应用池化操作
堆叠conv，ReLU和max池化层

（卷积神经网络的其他案例在我之前的专栏中也有写过，例如：手写字识别、面部表情识别等）

0. 软件环境搭建

这里我们使用一个叫PyGAD的python库。PyGAD是在Python 3.7.3中开发的，它依赖于NumPy来创建和操作数组，而依赖Matplotlib来创建图形。开发PyGAD时使用的确切NumPy版本是1.16.4。对于Matplotlib的版本为3.1.0。

安装也较为方便，只需使用pip从PyPI（Python软件包索引）下载并安装该库。该库位于此页面https://pypi.org/project/pygad上的PyPI。

对于Windows，发出以下命令：

pip install pygad

对于Linux和Mac，请使用pip3替换pip，因为该库仅支持Python 3。

pip install pygad

由于本身使用的只是一个库，所以这里知道如何安装、生命周期即可。

更多详细信息，大家也可以参考 https://pygad.readthedocs.io上的文档。

1.读取输入图像

以下代码将从skimage Python库中读取已经存在的图像，并将其转换为灰度图：

import skimage.data  
# Reading the image  
img = skimage.data.chelsea()  
# Converting the image into gray.  
img = skimage.color.rgb2gray(img)js

读取图像是第一步，下一步的操作取决于输入图像的大小。将图像转换为灰度图如下所示：

图1 输入图像

2.准备滤波器

以下代码为第一个卷积层Conv准备滤波器组（Layer 1，缩写为l1，下同）：

l1_filter = numpy.zeros((2,3,3))

根据滤波器的数目和每个滤波器的大小来创建零数组。上述代码创建了2个3x3大小的滤波器，（2,3,3）中的元素数字分别表示2：滤波器的数目（num_filters）、3：表示滤波器的列数、3：表示滤波器的行数。由于输入图像是灰度图，读取后变成2维图像矩阵，因此滤波器的尺寸选择为2维阵列，舍去了深度。如果图像是彩色图（具有3个通道，分别为RGB），则滤波器的大小必须为（3,3,3），最后一个3表示深度，上述代码也要更改，变成（2,3,3,3）。

滤波器组的大小由自己指定，但没有给定滤波器中具体的数值，一般采用随机初始化。下列一组值可以用来检查垂直和水平边缘：

l1_filter[0, :, :] = numpy.array([[[-1, 0, 1],   
                                    [-1, 0, 1],   
                                    [-1, 0, 1]]])  
 l1_filter[1, :, :] = numpy.array([[[1,   1,  1],   
                                    [0,   0,  0],   
                                    [-1, -1, -1]]])

3.卷积层（Conv Layer）

构建好滤波器后，接下来就是与输入图像进行卷积操作。下面代码使用conv函数将输入图像与滤波器组进行卷积：

l1_feature_map = conv(img, l1_filter)

conv函数只接受两个参数，分别为输入图像、滤波器组：

def conv(img, conv_filter):  
    if len(img.shape) > 2 or len(conv_filter.shape) > 3: # Check if number of image channels matches the filter depth.  
        if img.shape[-1] != conv_filter.shape[-1]:  
            print("Error: Number of channels in both image and filter must match.")  
            sys.exit()  
    if conv_filter.shape[1] != conv_filter.shape[2]: # Check if filter dimensions are equal.  
        print('Error: Filter must be a square matrix. I.e. number of rows and columns must match.')  
        sys.exit()  
    if conv_filter.shape[1]%2==0: # Check if filter diemnsions are odd.  
        print('Error: Filter must have an odd size. I.e. number of rows and columns must be odd.')  
        sys.exit()  
    # An empty feature map to hold the output of convolving the filter(s) with the image.  
    feature_maps = numpy.zeros((img.shape[0]-conv_filter.shape[1]+1,   
                                img.shape[1]-conv_filter.shape[1]+1,   
                                conv_filter.shape[0]))  
    # Convolving the image by the filter(s).  
    for filter_num in range(conv_filter.shape[0]):  
        print("Filter ", filter_num + 1)  
        curr_filter = conv_filter[filter_num, :] # getting a filter from the bank.  
        """  
        Checking if there are mutliple channels for the single filter. 
        If so, then each channel will convolve the image. 
        The result of all convolutions are summed to return a single feature map. 
        """  
        if len(curr_filter.shape) > 2:  
            conv_map = conv_(img[:, :, 0], curr_filter[:, :, 0]) # Array holding the sum of all feature maps.  
            for ch_num in range(1, curr_filter.shape[-1]): # Convolving each channel with the image and summing the results.  
                conv_map = conv_map + conv_(img[:, :, ch_num],   
                                  curr_filter[:, :, ch_num])  
        else: # There is just a single channel in the filter.  
            conv_map = conv_(img, curr_filter)  
        feature_maps[:, :, filter_num] = conv_map # Holding feature map with the current filter.
     return feature_maps # Returning all feature maps.

该函数首先确保每个滤波器的深度等于图像通道的数目，代码如下。if语句首先检查图像与滤波器是否有一个深度通道，若存在，则检查其通道数是否相等，如果匹配不成功，则报错。

if len(img.shape) > 2 or len(conv_filter.shape) > 3: # Check if number of image channels matches the filter depth.  
        if img.shape[-1] != conv_filter.shape[-1]:  
            print("Error: Number of channels in both image and filter must match.")

此外，滤波器的大小应该是奇数，且每个滤波器的大小是相等的。这是根据下面两个if条件语块来检查的。如果条件不满足，则程序报错并退出。

if conv_filter.shape[1] != conv_filter.shape[2]: # Check if filter dimensions are equal.  
     print('Error: Filter must be a square matrix. I.e. number of rows and columns must match.')  
     sys.exit()  
  if conv_filter.shape[1]%2==0: # Check if filter diemnsions are odd.  
     print('Error: Filter must have an odd size. I.e. number of rows and columns must be odd.')  
     sys.exit()

上述条件都满足后，通过初始化一个数组来作为滤波器的值，通过下面代码来指定滤波器的值：

# An empty feature map to hold the output of convolving the filter(s) with the image.  
feature_maps = numpy.zeros((img.shape[0]-conv_filter.shape[1]+1,   
                            img.shape[1]-conv_filter.shape[1]+1,   
                            conv_filter.shape[0]))

由于没有设置步幅（stride）或填充（padding），默认为步幅设置为1，无填充。那么卷积操作后得到的特征图大小为（img_rows-filter_rows+1, image_columns-filter_columns+1, num_filters），即输入图像的尺寸减去滤波

器的尺寸后再加1。注意到，每个滤波器都会输出一个特征图。

Convolving the image by the filter(s).  
   for filter_num in range(conv_filter.shape[0]):  
       print("Filter ", filter_num + 1)  
       curr_filter = conv_filter[filter_num, :] # getting a filter from the bank.  
       """  
       Checking if there are mutliple channels for the single filter. 
       If so, then each channel will convolve the image. 
       The result of all convolutions are summed to return a single feature map. 
       """  
       if len(curr_filter.shape) > 2:  
           conv_map = conv_(img[:, :, 0], curr_filter[:, :, 0]) # Array holding the sum of all feature maps.  
           for ch_num in range(1, curr_filter.shape[-1]): # Convolving each channel with the image and summing the results.  
               conv_map = conv_map + conv_(img[:, :, ch_num],   
                                 curr_filter[:, :, ch_num])  
       else: # There is just a single channel in the filter.  
           conv_map = conv_(img, curr_filter)  
       feature_maps[:, :, filter_num] = conv_map # Holding feature map with the current filter.

循环遍历滤波器组中的每个滤波器后，通过下面代码更新滤波器的状态：

curr_filter = conv_filter[filter_num, :] # getting a filter from the bank.

如果输入图像不止一个通道，则滤波器必须具有同样的通道数目。只有这样，卷积过程才能正常进行。最后将每个滤波器的输出求和作为输出特征图。下面的代码检测输入图像的通道数，如果图像只有一个通道，那么一次卷积即可完成整个过程：

if len(curr_filter.shape) > 2:  
     conv_map = conv_(img[:, :, 0], curr_filter[:, :, 0]) # Array holding the sum of all feature map 
     for ch_num in range(1, curr_filter.shape[-1]): # Convolving each channel with the image and summing the results.  
        conv_map = conv_map + conv_(img[:, :, ch_num],   
                                  curr_filter[:, :, ch_num])  
else: # There is just a single channel in the filter.  
    conv_map = conv_(img, curr_filter)

上述代码中conv_函数与之前的conv函数不同，函数conv只接受输入图像和滤波器组这两个参数，本身并不进行卷积操作，它只是设置用于conv_函数执行卷积操作的每一组输入滤波器。下面是conv_函数的实现代码：

def conv_(img, conv_filter):  
    filter_size = conv_filter.shape[0]  
    result = numpy.zeros((img.shape))  
    Looping through the image to apply the convolution operation.  
    for r in numpy.uint16(numpy.arange(filter_size/2,   
                          img.shape[0]-filter_size/2-2)):  
        for c in numpy.uint16(numpy.arange(filter_size/2, img.shape[1]-filter_size/2-2)):  
            Getting the current region to get multiplied with the filter.  
            curr_region = img[r:r+filter_size, c:c+filter_size]  
            Element-wise multipliplication between the current region and the filter.  
            curr_result = curr_region * conv_filter  
            conv_sum = numpy.sum(curr_result) #Summing the result of multiplication.  
            result[r, c] = conv_sum #Saving the summation in the convolution layer feature map.  
    Clipping the outliers of the result matrix.  
    final_result = result[numpy.uint16(filter_size/2):result.shape[0]-numpy.uint16(filter_size/2),   
                          numpy.uint16(filter_size/2):result.shape[1]-numpy.uint16(filter_size/2)]  
    return final_result

每个滤波器在图像上迭代卷积的尺寸相同，通过以下代码实现：

curr_region = img[r:r+filter_size, c:c+filter_size]

之后，在图像区域矩阵和滤波器之间对位相乘，并将结果求和以得到单值输出：

Element-wise multipliplication between the current region and the filter.  
curr_result = curr_region * conv_filter  
conv_sum = numpy.sum(curr_result) #Summing the result of multiplication.  
result[r, c] = conv_sum #Saving the summation in the convolution layer feature map.

输入图像与每个滤波器卷积后，通过conv函数返回特征图。下图显示conv层返回的特征图（由于l1卷积层的滤波器参数为（2,3,3），即2个3x3大小的卷积核，最终输出2个特征图）：

图2 卷积后图像

卷积层的后面一般跟着激活函数层，本文采用ReLU激活函数。

4.ReLU激活函数层

ReLU层将ReLU激活函数应用于conv层输出的每个特征图上，根据以下代码行调用ReLU激活函数：

l1_feature_map_relu = relu(l1_feature_map)

ReLU激活函数（ReLU）的具体实现代码如下：

def relu(feature_map):  
    Preparing the output of the ReLU activation function.  
    relu_out = numpy.zeros(feature_map.shape)  
    for map_num in range(feature_map.shape[-1]):  
        for r in numpy.arange(0,feature_map.shape[0]):  
            for c in numpy.arange(0, feature_map.shape[1]):  
                relu_out[r, c, map_num] = numpy.max(feature_map[r, c, map_num], 0)

ReLU思想很简单，只是将特征图中的每个元素与0进行比较，若大于0，则保留原始值。否则将其设置为0。ReLU层的输出如下图所示：

图3 ReLU层输出图像

激活函数层后面一般紧跟池化层，本文采用最大池化（max pooling）。

5.最大池化层

ReLU层的输出作为最大池化层的输入，根据下面的代码行调用最大池化操作：

l1_feature_map_relu_pool = pooling(l1_feature_map_relu, 2, 2)

最大池化函数（max pooling）的具体实现代码如下：

def pooling(feature_map, size=2, stride=2):  
    Preparing the output of the pooling operation.  
    pool_out = numpy.zeros((numpy.uint16((feature_map.shape[0]-size+1)/stride),  
                            numpy.uint16((feature_map.shape[1]-size+1)/stride),  
                            feature_map.shape[-1]))  
    for map_num in range(feature_map.shape[-1]):  
        r2 = 0  
        for r in numpy.arange(0,feature_map.shape[0]-size-1, stride):  
            c2 = 0  
            for c in numpy.arange(0, feature_map.shape[1]-size-1, stride):  
                pool_out[r2, c2, map_num] = numpy.max(feature_map[r:r+size,  c:c+size])  
                c2 = c2 + 1  
            r2 = r2 +1

该函数接受3个参数，分别为ReLU层的输出，池化掩膜的大小和步幅。首先也是创建一个空数组，用来保存该函数的输出。数组大小根据输入特征图的尺寸、掩膜大小以及步幅来确定。

pool_out = numpy.zeros((numpy.uint16((feature_map.shape[0]-size+1)/stride),  
                        numpy.uint16((feature_map.shape[1]-size+1)/stride),  
                        feature_map.shape[-1]))

对每个输入特征图通道都进行最大池化操作，返回该区域中最大的值，代码如下：

pool_out[r2, c2, map_num] = numpy.max(feature_map[r:r+size, c:c+size])

池化层的输出如下图所示，这里为了显示让其图像大小看起来一样，其实池化操作后图像尺寸远远小于其输入图像。

图4 池化层输出图像

6.层堆叠

以上内容已经实现CNN结构的基本层——conv、ReLU以及max pooling，现在将其进行堆叠使用，代码如下：

1.  Second conv layer  
2.  l2_filter = numpy.random.rand(3, 5, 5, l1_feature_map_relu_pool.shape[-1])  
3.  print("\n**Working with conv layer 2**")  
4.  l2_feature_map = conv(l1_feature_map_relu_pool, l2_filter)  
5.  print("\n**ReLU**")  
6.  l2_feature_map_relu = relu(l2_feature_map)  
7.  print("\n**Pooling**")  
8.  l2_feature_map_relu_pool = pooling(l2 _feature_map_relu, 2, 2)  
9.  print("**End of conv layer 2**\n")

从代码中可以看到，l2表示第二个卷积层，该卷积层使用的卷积核为（3,5,5），即3个5x5大小的卷积核（滤波器）与第一层的输出进行卷积操作，得到3个特征图。后续接着进行ReLU激活函数以及最大池化操作。将每个操作的结果可视化，如下图所示：

图4 l2层处理过程可视化图像

# Third conv layer  
l3_filter = numpy.random.rand(1, 7, 7, l2_feature_map_relu_pool.shape[-1])  
print("\n**Working with conv layer 3**")  
l3_feature_map = conv(l2_feature_map_relu_pool, l3_filter)  
print("\n**ReLU**")  
l3_feature_map_relu = relu(l3_feature_map)  
print("\n**Pooling**")  
l3_feature_map_relu_pool = pooling(l3_feature_map_relu, 2, 2)  
print("**End of conv layer 3**\n"）

从代码中可以看到，l3表示第三个卷积层，该卷积层使用的卷积核为（1,7,7），即1个7x7大小的卷积核（滤波器）与第二层的输出进行卷积操作，得到1个特征图。后续接着进行ReLU激活函数以及最大池化操作。将每个操作的结果可视化，如下图所示：

图5 l3层处理过程可视化图像

神经网络的基本结构是前一层的输出作为下一层的输入，比如l2层接收l1层的输出，l3层接收来l2层的输出，代码如下：

l2_feature_map = conv(l1_feature_map_relu_pool, l2_filter)  
l3_feature_map = conv(l2_feature_map_relu_pool, l3_filter)

7.完整代码

全部代码已经上传至我的Github上，每层的可视化是使用Matplotlib库实现。

文章原标题《Building Convolutional Neural Network using NumPy from Scratch》，译者：海棠

更多精彩学习资料，承诺大家的，一个也不会少，我分类整理好并附上链接。

实战教程 | 使用Scratch中的NumPy构建卷积神经网络，开放源码