Neural Networks and Deep Learing笔记：一个简单的识别手写数字的神经网络

主要参考整理了：Neural Networks and Deep Learning 这网络书籍的核心内容

文章目录

主要内容
神经网络分类
Perceptrons
S型神经元的基本原理
神经网络的结构
梯度下降算法
对手写数字识别的基本思路与代码实现

主要内容

1、对神经网络的基本结构进行
2、整理理一下神经网络的基本思路。
3、根据作者提供的数据集与代码实现一个对手写字母实现的算法实现（建议这部分直接去看文献描写的不清楚）
4、学习结果展示

神经网络分类

神经网络分为两种：1、Perceptrons 2、Sigmoid neurons
第一种中文翻译应该是感知器，第二种译本上翻译叫S型神经元。

Perceptrons

在发明S型神经元之前，先出现的是感知器神经元，这个神经网络中的单个神经元都类似于分段函数。
输入x1、x2、x3x_1、x_2、x_3x1、x2、x3再通过中间圆形神经元处理后，然后输入outputoutputoutput.
中间的处理方法如下：
(ω1,ω2,ω3)(x1x2x3)≥b?\begin{pmatrix} \omega_1 ,\omega_2,\omega_3 \end{pmatrix}\begin{pmatrix} x_1 \\ x_2 \\ x_3 \end{pmatrix}\ge b\ ?(ω1,ω2,ω3)⎝⎛x1x2x3⎠⎞≥b ?
根据上面这个的条件是否满足，我们的输出值outputoutputoutput将为000或111。
通过对上面式子的改写我们可以获得一个
(ω1,ω2,ω3)(x1x2x3)−b≥0?\begin{pmatrix} \omega_1 ,\omega_2,\omega_3 \end{pmatrix}\begin{pmatrix} x_1 \\ x_2 \\ x_3 \end{pmatrix} - b\ge0 \ ?(ω1,ω2,ω3)⎝⎛x1x2x3⎠⎞−b≥0 ?
多个神经元一起组成了神经网路

S型神经元的基本原理

S型神经元与感知器神经元类似，只是处理方法不同，先讲方法，在做分析。

还是上面这个图，我们依然选择x1、x2、x3x_1、x_2、x_3x1、x2、x3与权重值ω1、ω2、ω3\omega_1、\omega_2、\omega_3ω1、ω2、ω3，还有偏置（常数b）b=−bb=-bb=−b。但是转化处理方法有所不同，我们使用一个公式。
σ(z)=11+e−z\sigma(z)=\cfrac 1 {1+e^{-z}}σ(z)=1+e−z1
其中z=ωa+bz=\omega a+bz=ωa+b，aaa是输入向量，输出值为σ\sigmaσ。
分析一下这个公式：
问题一：为什么使用这个公式来计算
原因：1、该方程为连续方程，根据△σ≈∂σ∂ω△ω+∂σ∂b△b\triangle\sigma \approx \cfrac {\partial \sigma } {\partial \omega}\triangle\omega+\cfrac {\partial \sigma} {\partial b}\triangle b △σ≈∂ω∂σ△ω+∂b∂σ△b则看出为连续的。不像step function（微小的△ω\triangle\omega△ω可能对outputoutputoutput产生很大的影响）。

2、当z→−∞z\rightarrow-\infinz→−∞时趋向于0，σ\sigmaσ趋向于0，而z→∞z\rightarrow\infinz→∞其曲线与1，非常满足[0,1][0,1][0,1]的规则。

神经网络的结构

神经网络，我们根据神经网络的功能，将众多层数构成三大层。分别是：输入层——隐藏层——输出层。
如下图所示：

别称MLPs也是神经网络。

梯度下降算法

每一步的权重和偏置要是可以自动生成和修改，肯定是我们所希望的，我们使用一个算法来调整ω\omegaω和bbb。
首先我们要先找到一个评价ω\omegaω与bbb的方法。就是通过ω\omegaω与bbb在改变后与实际值a的差距大小，越小越好。
那就形成了

我们称我感觉更像克里金插值里面的半变异值。
为了找到C最小的值，我们可以尝试使用△C\triangle C△C，只要保证△C\triangle C△C恒为负就可找到最小值。
根据二元微分方法我们可导出：

进而推导出

根据柯西-施瓦兹不等式得

不过每一个都求偏导不太现实，我们往往通过一个简化的算法：随机梯度下降算法。（实际就是随机抽m个数求平均来代替求n个数）

直到CCC迭代到一定的次数就可以了。

对手写数字识别的基本思路与代码实现

这部分建议直接看顶部的参考文献！Neural Networks and Deep Learning
如果不习惯作者python2的代码还可以去看作者python3的代码文章尾部有链接
一、将手写的众多数字分成单一的数字。如：1、2、3、4、5、6、6这样分开。
方法：利用软件。等其他算法，而不是神经网络相关内容。
二、区分单一数字的类型。我们将单一数字，按照像素划分成输入层的神经元，一个数字为28×28=78428×28 = 78428×28=784个神经元。
我们设置3层神经网络。
第一层：784个神经元
第二层：15个神经元
第三层：10个神经元
利用代码构造一个神经网络的类：

class Networks:#size表示的是神经元每一层的个数，例如建立一个神经元Networks[4,15,3]#就是建立一个3层神经元，每层分别由4个，15个，3个神经元构成。def __init__(self,sizes):self.sizes = sizesself.net_layer = len(sizes)#建立偏置向量：偏置向量的特点是x行1列的矩阵，这个矩阵的数值为均值为0，方差为1的正态分布随机数。self.biases = [numpy.random.randn(x,1) for x in sizes[1:]]#生成权重向量：权重向量的特点是x行y列的矩阵，#第一次循环：x为第2层神经元的个数，y为第1层神经元的个数#第二次循环：x为第3层神经元的个数，y为第2层神经元的个数#第n次循环：………………self.weights = [numpy.random.randn(x,y) for y,x in zip(size[:-1],size[1:])]#这样biases就形成了一个2元组的列表#weight形成了2元组的列表

三、根据灰度值设置为不同的灰阶aaa矩阵：
(a1a2⋯a784)T{\begin{pmatrix} a_1\ a_2\ \cdots\ a_{784} \end{pmatrix}}^T(a1 a2 ⋯ a784)T
与随机产生的ω10×784\omega_{10×784}ω10×784矩阵点乘，再和偏置b10×1b_{10×1}b10×1相加，进而作到递推式如下：a′=σ(ωa+b)a' = \sigma(\omega a+b)a′=σ(ωa+b)

#首先需要sigmoid函数
def sigmoid(z):return 1.0/(1.0+numpy.exp(-z))
def feedforword(self,a):for w,b in zip(self.weights,self.bias):#找到所对应的w与ba = sigmoid(numpy.dot(w,a)+b)return a

四、迭代算法完成，下面进行写训练算法的算法（随机梯度下降算法）
训练算法的具体流程如下：

'''
SGD算法主要包括变量：训练数据集，迭代次数，随机数据集的个数，学习速度，测试数据。
1、打乱训练数据 :通过shuffle方法
2、挑选训练数据：mini_batch
3、迭代训练数据:updata_mini_batch
4、处理测试数据
'''
def SGD(self,training_data,epochs,mini_batch_size,eta,test_data=None):if test_data: n_test = len(test_data)n = len(training_data)for j in xrange(epochs):random.shuffle(training_data)#mini_batchs是一个列表的列表，列表中的每一个列表是mini_batch_size个训练数据集#训练数据是一个元组数组[(x,y)……],x为目标输入值,y为目标值mini_batchs = [training_data[k:k+mini_batch_size] for k in xrange(0,n,mini_batch_size]for mini_batch in mini_batchs:self.updata_mini_batch(mini_batch,eta)if test_data:print "Epoch {0}: {1} / {2}".format(j, self.evaluate(test_data), n_test) else:print "Epoch {0} complete".format(j)

五、补全方法：

def updata_mini_batch(self,mini_batch,eta):
'''
updata_mini_batch的最终目的是为了调整self.weight与self.biase
self.weights = []
'''#先建立两个填充为0的weight与biase的同型矩阵,作为梯度下降矩阵变化后矩阵。nabla_w = [numpy.zeros(w.shape) for w in self.weights]nabla_b = [numpy.zeros(b.shape) for b in self.biase]#求delta_nabla_w与delta_nabla_bfor x,y in mini_batch:delta_nabla_b,delta_nabla_w = self.backprop(x,y)#这一步利用的是backprop方法将在后面展示，就是求偏导用的nabla_w = [nw+dnw for nw,dnw in zip(self.weights,delta_nabla_w)]nabla_b = [nb+dnb for nb,dnb in zip(self.biase,delta_nabla_b)]self.weights = [w - (eta)/len(mini_batch)*nw for w,nw in zip(self.weight,nabla_w)]self.biases = [b - (eta)/len(mini_batch)*nb for b,nb in zip(self.biases,nabla_b)]
"""
后面的方法下一章介绍backprop是一种求delta的方法
"""
def backprop(self, x, y):nabla_b = [np.zeros(b.shape) for b in self.biases]nabla_w = [np.zeros(w.shape) for w in self.weights]# feedforwardactivation = xactivations = [x] # list to store all the activations, layer by layerzs = [] # list to store all the z vectors, layer by layerfor b, w in zip(self.biases, self.weights):z = np.dot(w, activation)+bzs.append(z)activation = sigmoid(z)activations.append(activation)
# backward passdelta = self.cost_derivative(activations[-1], y) * \sigmoid_prime(zs[-1])nabla_b[-1] = deltanabla_w[-1] = np.dot(delta, activations[-2].transpose())for l in xrange(2, self.num_layers):z = zs[-l]sp = sigmoid_prime(z)delta = np.dot(self.weights[-l+1].transpose(), delta) * spnabla_b[-l] = deltanabla_w[-l] = np.dot(delta, activations[-l-1].transpose())return (nabla_b, nabla_w)
def evaluate(self, test_data):test_results = [(np.argmax(self.feedforward(x)), y)for (x, y) in test_data]return sum(int(x == y) for (x, y) in test_results)
def cost_derivative(self, output_activations, y):return (output_activations-y)

代码地址：
基于python3的神经网络
训练结果展示：