使用该网络对手写数字进行分类。所获得的结果不是最先进的水平，但仍然令人满意。现在想更进一步，我们的目标是开发一个仅使用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从头构建卷积神经网络
