使用该网络对手写数字进行分类。所获得的结果不是最先进的水平，但仍然令人满意。现在想更进一步，我们的目标是开发一个仅使用Numpy的卷积神经网络（CNN）。

这项任务背后的动机与创建全连接的网络的动机相同：尽管Python深度学习库是强大的工具，但它阻止从业者理解底层正在发生的事情。对于CNNs来说，这一点尤其正确，因为该过程不如经典深度网络执行的过程直观。

解决这一问题的唯一办法是尝试自己实现这些网络。

打算将本文作为一个实践教程，而不是一个全面指导CNNs运作原则的教程。因此，理论部分很窄，主要用于对实践部分的理解。

对于需要更好地理解卷积网络工作原理的读者，留下了一些很好的资源。

什么是卷积神经网络？

卷积神经网络使用特殊的结构和操作，使其非常适合图像相关任务，如图像分类、对象定位、图像分割等。它们大致模拟了人类的视觉皮层，每个生物神经元只对视野的一小部分做出反应。此外，高级神经元对其他低级神经元的输出做出反应［1］。

正如我在上一篇文章中所展示的，即使是经典的神经网络也可以用于图像分类等任务。问题是，它们仅适用于小尺寸图像，并且在应用于中型或大型图像时效率极低。原因是经典神经网络需要大量的参数。

例如，200x200像素的图像具有40＇000个像素，如果网络的第一层具有1＇000个单位，则仅第一层的权重为4000万。由于CNN实现了部分连接的层和权重共享，这一问题得到了高度缓解。

卷积神经网络的主要组成部分包括：

· 卷积层

· 池化层

卷积层

卷积层由一组滤波器（也称为核）组成，当应用于层的输入时，对原始图像进行某种修改。滤波器是一种矩阵，其元素值定义了对原始图像执行的修改类型。类似以下的3x3内核具有突出显示图像中垂直边的效果：

不同的是，该核突出了水平边：

核中元素的值不是手动选择的，而是网络在训练期间学习的参数。

卷积的作用是隔离图像中存在的不同特征。Dense层稍后使用这些功能。

池化层

池化层非常简单。池化层的任务是收缩输入图像，以减少网络的计算负载和内存消耗。事实上，减少图像尺寸意味着减少参数的数量。

池化层所做的是使用核（通常为2x2维）并将输入图像的一部分聚合为单个值。例如，2x2最大池核获取输入图像的4个像素，并仅返回具有最大值的像素。

Python实现

此GitHub存储库中提供了所有代码。

这个实现背后的想法是创建表示卷积和最大池层的Python类。此外，由于该代码后来被应用于MNIST分类问题，我为softmax层创建了一个类。

每个类都包含实现正向传播和反向传播的方法。

这些层随后被连接在一个列表中，以生成实际的CNN。

卷积层实现

class ConvolutionLayer：

   def ＿＿init＿＿（self， kernel＿num， kernel＿size）：

       self．kernel＿num ＝ kernel＿num

       self．kernel＿size ＝ kernel＿size        

       self．kernels ＝ np．random．randn（kernel＿num， kernel＿size， kernel＿size） ／ （kernel＿size＊＊2）

   def patches＿generator（self， image）：

       image＿h， image＿w ＝ image．shape

       self．image ＝ image

       for h in range（image＿h－self．kernel＿size＋1）：

           for w in range（image＿w－self．kernel＿size＋1）：

               patch ＝ image［h：（h＋self．kernel＿size）， w：（w＋self．kernel＿size）］

               yield patch， h， w
   

   def forward＿prop（self， image）：

       image＿h， image＿w ＝ image．shape

       convolution＿output ＝ np．zeros（（image＿h－self．kernel＿size＋1， image＿w－self．kernel＿size＋1， self．kernel＿num））

       for patch， h， w in self．patches＿generator（image）：

           convolution＿output［h，w］ ＝ np．sum（patch＊self．kernels， axis＝（1，2））

       return convolution＿output
   

   def back＿prop（self， dE＿dY， alpha）：

       dE＿dk ＝ np．zeros（self．kernels．shape）

       for patch， h， w in self．patches＿generator（self．image）：

           for f in range（self．kernel＿num）：

               dE＿dk［f］ ＋＝ patch ＊ dE＿dY［h， w， f］

       self．kernels －＝ alpha＊dE＿dk

       return dE＿dk

构造器将卷积层的核数及其大小作为输入。我假设只使用大小为kernel＿size x kernel＿size的平方核。

在第5行中，我生成随机滤波器（kernel＿num、kernel＿size、kernel＿size），并将每个元素除以核大小的平方进行归一化。

patches＿generator（）方法是一个生成器。它产生切片。

forward＿prop（）方法对上述方法生成的每个切片进行卷积。

最后，back＿prop（）方法负责计算损失函数相对于层的每个权重的梯度，并相应地更新权重值。注意，这里提到的损失函数不是网络的全局损失。相反，它是由最大池层传递给前一卷积层的损失函数。

为了显示这个类的实际效果，我用32个3x3滤波器实例化了一个卷积层对象，并将正向传播方法应用于图像。输出包含32个稍小的图像。

原始输入图像的大小为28x28像素，如下所示：

在应用卷积层的前向传播方法后，我获得了32幅尺寸为26x26的图像。这里我绘制了其中一幅：

如你所见，图像稍小，手写数字变得不那么清晰。考虑到这个操作是由一个填充了随机值的滤波器执行的，所以它并不代表经过训练的CNN实际执行的操作。

尽管如此，你可以得到这样的想法，即这些卷积提供了较小的图像，其中对象特征被隔离。

最大池层实现

class MaxPoolingLayer：

   def ＿＿init＿＿（self， kernel＿size）：

       self．kernel＿size ＝ kernel＿size

   def patches＿generator（self， image）：

       output＿h ＝ image．shape［0］ ／／ self．kernel＿size

       output＿w ＝ image．shape［1］ ／／ self．kernel＿size

       self．image ＝ image

       for h in range（output＿h）：

           for w in range（output＿w）：

               patch ＝ image［（h＊self．kernel＿size）：（h＊self．kernel＿size＋self．kernel＿size）， （w＊self．kernel＿size）：（w＊self．kernel＿size＋self．kernel＿size）］

               yield patch， h， w

   def forward＿prop（self， image）：

       image＿h， image＿w， num＿kernels ＝ image．shape

       max＿pooling＿output ＝ np．zeros（（image＿h／／self．kernel＿size， image＿w／／self．kernel＿size， num＿kernels））

       for patch， h， w in self．patches＿generator（image）：

           max＿pooling＿output［h，w］ ＝ np．amax（patch， axis＝（0，1））

       return max＿pooling＿output

   def back＿prop（self， dE＿dY）：

       dE＿dk ＝ np．zeros（self．image．shape）

       for patch，h，w in self．patches＿generator（self．image）：

           image＿h， image＿w， num＿kernels ＝ patch．shape

           max＿val ＝ np．amax（patch， axis＝（0，1））

           for idx＿h in range（image＿h）：

               for idx＿w in range（image＿w）：

                   for idx＿k in range（num＿kernels）：

                       if patch［idx＿h，idx＿w，idx＿k］ ＝＝ max＿val［idx＿k］：

                           dE＿dk［h＊self．kernel＿size＋idx＿h， w＊self．kernel＿size＋idx＿w， idx＿k］ ＝ dE＿dY［h，w，idx＿k］

           return dE＿dk

构造函数方法只分配核大小值。以下方法与卷积层的方法类似，主要区别在于反向传播函数不更新任何权重。事实上，池化层不依赖于权重来执行。

Sigmoid层实现

class SoftmaxLayer：

   def ＿＿init＿＿（self， input＿units， output＿units）：

       self．weight ＝ np．random．randn（input＿units， output＿units）／input＿units

       self．bias ＝ np．zeros（output＿units）

   def forward＿prop（self， image）：

       self．original＿shape ＝ image．shape

       image＿flattened ＝ image．flatten（）

       self．flattened＿input ＝ image＿flattened

       first＿output ＝ np．dot（image＿flattened， self．weight） ＋ self．bias

       self．output ＝ first＿output

       softmax＿output ＝ np．exp（first＿output） ／ np．sum（np．exp（first＿output）， axis＝0）

       return softmax＿output

   def back＿prop（self， dE＿dY， alpha）：

       for i， gradient in enumerate（dE＿dY）：

           if gradient ＝＝ 0：

               continue

           transformation＿eq ＝ np．exp（self．output）

           S＿total ＝ np．sum（transformation＿eq）

           dY＿dZ ＝ －transformation＿eq［i］＊transformation＿eq ／ （S＿total＊＊2）

           dY＿dZ［i］ ＝ transformation＿eq［i］＊（S＿total － transformation＿eq［i］） ／ （S＿total＊＊2）

           dZ＿dw ＝ self．flattened＿input

           dZ＿db ＝ 1

           dZ＿dX ＝ self．weight

           dE＿dZ ＝ gradient ＊ dY＿dZ

           dE＿dw ＝ dZ＿dw［np．newaxis］．T ＠ dE＿dZ［np．newaxis］

           dE＿db ＝ dE＿dZ ＊ dZ＿db

           dE＿dX ＝ dZ＿dX ＠ dE＿dZ

           self．weight －＝ alpha＊dE＿dw

           self．bias －＝ alpha＊dE＿db

           return dE＿dX．reshape（self．original＿shape）

softmax层使最大池提供的输出体积变平，并输出10个值。它们可以被解释为与数字0–9相对应的图像的概率。

结论

你可以克隆包含代码的GitHub存储库并使用main．py脚本。该网络一开始没有达到最先进的性能，但在几个epoch后达到96％的准确率。

参考引用

       原文标题 : 使用Numpy从头构建卷积神经网络