神经网络（全连接神经网络）

对人类中枢神经系统的观察启发了人工神经网络这个概念。在人工神经网络中，简单的人工节点，称作神经元（neurons），连接在一起形成一个类似生物神经网络的网状结构。人工神经网络与生物神经网络的相似之处在于，它可以集体地、并行地计算函数的各个部分，而不需要描述每一个单元的特定任务。神经网络这个词一般指统计学、认知心理学和人工智能领域使用的模型，而控制中央神经系统的神经网络属于理论神经科学和计算神经科学。
在神经网络的现代软件实现中，被生物学启发的那种方法已经很大程度上被抛弃了，取而代之的是基于统计学和信号处理的更加实用的方法。在一些软件系统中，神经网络或者神经网络的一部分（例如人工神经元）是大型系统中的一个部分。这些系统结合了适应性的和非适应性的元素。虽然这种系统使用的这种更加普遍的方法更适宜解决现实中的问题，但是这和传统的连接主义人工智能已经没有什么关联了。不过它们还有一些共同点：非线性、分布式、并行化，局部性计算以及适应性。从历史的角度讲，神经网络模型的应用标志着二十世纪八十年代后期从高度符号化的人工智能（以用条件规则表达知识的专家系统为代表）向低符号化的机器学习（以用动力系统的参数表达知识为代表）的转变。

感知器（perceptron）

要先理解神经网络，让我们先从最简单的感知器开始。感知机算法是一种很好的二分类在线算法，对于线性可分的模型，感知机能在输入空间将实例划分为正负样本，而分离他们的是超平面。感知机是神经网络以及支持向量机的基础。

让我们先来看一下下面一张图：
一个感知机包含多个输入 $(x_1,x_2,\cdot,x_n)$ ,每个输入 $x_i$ 对应一个权重 $w_i$ ，此外还有一个偏置项 $b$ ，求和后通过一个激活函数(perceptron中是阶跃函数，其他还有sigmoid，tanh，Relu等)得到我们的输出。即

y = f (w x + b)

$y=f({\bf wx}+b)$
激活函数可表示为

f (x) = s i g n (w x + b)

$f(x)=sign({\bf w}{\bf x}+b)$

s i g n (x) = {\begin{cases} + 1 x>0 \\ - 1 x<0 \end{cases}

$sign(x)=\begin{cases} +1 \quad\text{x>0} \\ -1 \quad\text{x<0}\end{cases}$
感知机是一个简单的二类分类的线性分类模型，要求我们的样本是线性可分的我们要做的就是找到一个最合适的超平面，将正负样本分割开来。

假定数据集

T = {(x_{1}, y_{1}) (x_{2}, y_{2}) (x_{3}, y_{3}) \dots (x_{m}, y_{m})}

$T=\{(x_1,y_1)(x_2,y_2)(x_3,y_3)\ldots(x_m,y_m)\}$

对每一个样本有若 ${\bf w}{\bf x_i}>0$ , $y_i＝１$ 反之 ${\bf w}{\bf x_i}<0$ , $y_i＝-1$
由几何意义易得，每一个样本到这个超平面的距离为：

d = \frac{∣ w x_{i} + b ∣}{∣ ∣ w ∣ ∣}

$d=\frac{\mid{\bf w}{\bf x_i}+b\mid}{\mid\mid{\bf w}\mid\mid}$
由上面论述可知，对于一个分类错误的误分类点，有

- y_{i} (w x_{i} + b) > 0

$-y_i({\bf w}{\bf x_i}+b)>0$
所以误分类点导超平面的距离为

- \frac{1}{∣ ∣ w ∣ ∣} y_{i} (w x_{i} + b)

$-\frac{1}{\mid\mid{\bf w}\mid\mid}y_i({\bf w}{\bf x_i}+b)$
则误分类点到超平面的总和为

- \frac{1}{∣ ∣ w ∣ ∣} \sum_{x_{i} \in M} y_{i} (w x_{i} + b)

$-\frac{1}{\mid\mid{\bf w}\mid\mid}\sum_{x_i\in M}y_i({\bf w}{\bf x_i}+b)$
根据如上所述，我们定义损失函数为

L (w, b) = - \sum_{x_{i} \in M} y_{i} (w x_{i} + b)

$L({\bf w},b)=-\sum_{x_i\in M}y_i({\bf w}{\bf x_i}+b)$
其中M是误分类的样本的集合。对于损失函数，当所有样本都正确分类时损失函数为０，感知机学习的策略就是在假设空间中选取使损失函数最小的模型参数，即感知机模型。
为正确获得损失函数的最小值，我们可以使用随机梯度下降的方法

min_{w, b} L (w, b) = - \sum_{x_{i} \in M} y_{i} (w x_{i} + b)

$\min_{w,b}L({\bf w},b)=-\sum_{x_i\in M}y_i({\bf w}{\bf x_i}+b)$
分别对

w 和 b

${\bf w}和b$ 求偏导得梯度

\partial_{w} L (w, b) = - \sum_{x_{i} \in M} y_{i} x_{i}

$\partial_wL(w,b)=-\sum_{x_i\in M}y_ix_i$

\partial_{b} L (w, b) = - \sum_{x_{i} \in M} y_{i}

$\partial_bL(w,b)=-\sum_{x_i\in M}y_i$
对权值进行更新后得到

w \leftarrow w + η y_{i} x_{i}

${\bf w}\leftarrow{\bf w}+\eta y_i{\bf x_i}$

b \leftarrow b + η y_{i}

$b\leftarrow b+\eta y_i$

η

$\eta$ 称为学习率(步长)，随着迭代的不断增加，损失函数逐渐收敛于一个局部最小值。最终我们可以获得我们想要的感知机模型。

神经元

首先让我们来看看人脑中的神经元：
一个神经元包含多个树突，接受来自其他多个神经元的电信号，一个轴突，轴突末梢又与其他多个神经元相连，传递信息。

人类模拟生物神经元的结构，构建出了抽象的神经元模型，见下图：
由此可以看出，神经元与感知机的本质上是一样的，输入多个，经过求和转化最终得到输出。有所区别的是，感知机是用的阶跃函数，而神经元大多是sigmoid函数或者是tanh函数。

以下是几个激活函数(active function)的差别：

(1)阶跃函数

阶跃函数的定义是

s i g n (x) = {\begin{cases} + 1 & x>0 \\ 0 & x<0 \end{cases}

$sign(x)=\begin{cases} +1 \quad&\text{x>0} \\\; 0 \quad&\text{x<0}\end{cases}$

(2)sigmoid函数

sigmoid函数的定义是

s i g m o i d (x) = \frac{1}{1 + e^{- x}}

$sigmoid(x)=\frac{1}{1+e^{-x}}$ 值域为

(0, 1)

$(0,1)$

除此之外，sigmoid函数还有一个很重要的性质，即

y = s i g m o i d (x) y^{‘} = y (1 - y)

$y=sigmoid(x)\\y^‘=y(1-y)$
(3)tanh函数

tanh函数的定义是

t a n h (x) = \frac{e^{x} - e^{- x}}{e^{x} + e^{- x}}

$tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$

(4)Relu函数

Relu函数的定义是

R e l u (x) = {\begin{cases} x, & x>0 \\ 0, & x<0 \end{cases}

$Relu(x)=\begin{cases}x,&\text{x>0}\\0,&\text{x<0} \end{cases}$

神经网络的结构

神经网络之所以被称为网络(network)，是因为他通常用许多不同的函数复合在一起来表示。该模型有一个有向无环图相关联，而图描述了函数是如何复合在一起的。例如，我们有三个函数 $f(x)=f^{(3)}(f^{(2)}(f^{(1)}(x)))$ 。这些链式结构视神经网络中最常见的结构。
如上图所示，我们有四层网络，第一层是输入层(input layer),最右边的一层是输出层(output layer)。在上面的例子中输出层只有一个输出神经元。而中间的两层既不是输入层也不是输出层，我们称之为隐层(hidden layer)。链的全长我们称之为深度(depth)，正因如此，才出现了深度学习(deep learning)这个名词。上面这个模型也可称为前馈神经网络(feedforward neural network)或者多层感知机(multilayer perceptron,MLP)，即把上一层的输出作为下层输入的神经网络。

上面这些规则定义了全连接神经网络的结构。事实上还存在很多其它结构的神经网络，比如卷积神经网络(CNN)、循环神经网络(RNN)，他们都具有不同的连接规则。(以后会比较详细的介绍)

反向传播算法(back propagation)

接下来介绍一个比较基础也比较重要的算法，反向传播算法。

由上图可知，我们定义输入层 $x^0$ ，输出层 $y$ ,权重 $w^i$ ， $w^l_ij$ 是第l-1层第i个元素到l层第j个元素的权重。

我们另输出

y_{n} = s i g m o i d (s_{n}^{l}) x_{i}^{l} = f (s_{i}^{l})

$y_n=sigmoid(s^l_n)\\x_i^l=f(s_i^l)$

f (x)

$f(x)$ 是我们选择的激活函数

我们设损失函数

E = \frac{1}{2} \sum_{i = 1}^{m} (y_{i} - t a r g e t_{i})^{2}

$E=\frac{1}{2}\sum_{i=1}^m(y_i-target_i)^2$
我们要做的就是通过学习得到最佳的

{w_{i j}^{l}}

$\{w_{ij}^l\}$ 使得我们的损失函数

E

$E$ 达到最小，为达到这个目的，我们使用梯度下降算法。

在输出层

\begin{aligned} (98) & S_{1}^{l} = x_{1}^{l - 1} w_{11}^{l} + x_{2}^{l - 1} w_{21}^{l} + \dots & + x_{k}^{l - 1} w_{k 1}^{l} = \sum_{i = 0}^{k} x_{i}^{l - 1} w_{i 1}^{l} \\ (99) & ⋮ \\ (100) & S_{m}^{l} = x_{1}^{l - 1} w_{1 m}^{l} + x_{2}^{l - 1} w_{2 m}^{l} + \dots & + x_{k}^{l - 1} w_{k m}^{l} = \sum_{i = 0}^{k} x_{i}^{l - 1} w_{i m}^{l} \end{aligned}

$\begin{align} S^l_1=x_1^{l-1}w_{11}^l+x_2^{l-1}w_{21}^l+\cdots&+x_k^{l-1}w_{k1}^l=\sum_{i=0}^kx_i^{l-1}w_{i1}^l\\ &\vdots \\ S^l_m=x_1^{l-1}w_{1m}^l+x_2^{l-1}w_{2m}^l+\cdots&+x_k^{l-1}w_{km}^l=\sum_{i=0}^kx_i^{l-1}w_{im}^l \end{align}$
我们让

\frac{\partial E}{\partial S_{i}^{l}} = \frac{\partial E}{\partial y_{i}^{l}} \frac{\partial y_{i}^{l}}{\partial S_{i}^{l}} = (y_{i} - t a r g e t_{i}) y_{i} (1 - y_{i})

$\frac{\partial E}{\partial S_i^l}=\frac{\partial E}{\partial y_i^l}\frac{\partial y_i^l}{\partial S_i^l}=(y_i-target_i)y_i(1-y_i)$
我们令

\frac{\partial E}{\partial S_{i}^{l}} = δ_{i}^{l} = (y_{i} - t a r g e t_{i}) y_{i} (1 - y_{i})

$\frac{\partial E}{\partial S^l_i}=\delta_i^l=(y_i-target_i)y_i(1-y_i)$
所以得到,其中

δ

$\delta$ 是输出误差

\frac{\partial E}{\partial w_{i j}^{l}} = \frac{\partial E}{\partial S_{j}^{l}} \frac{\partial S_{j}^{l}}{\partial w_{i j}^{l}} = δ_{j}^{l} x_{i}^{l - 1}

$\frac{\partial E}{\partial w_{ij}^l}=\frac{\partial E}{\partial S^l_j}\frac{\partial S_j^l}{\partial w_{ij}^l}=\delta_j^lx_i^{l-1}$
接下来我们对前一层求偏导

\begin{aligned} (101) & \frac{\partial E}{\partial S_{i}^{l - 1}} & = \frac{\partial E}{\partial x_{i}^{l - 1}} \frac{\partial x_{i}^{l - 1}}{\partial S_{i}^{l - 1}} \\ (102) & = (\frac{\partial E}{\partial S_{1}^{l}} \frac{\partial S_{1}^{l}}{\partial x_{i}^{l - 1}} + \frac{\partial E}{\partial S_{2}^{l}} \frac{\partial S_{2}^{l}}{\partial x_{i}^{l - 1}} + \dots + \frac{\partial E}{\partial S_{m}^{l}} \frac{\partial S_{m}^{l}}{\partial x_{i}^{l - 1}}) f^{^{'}} (S_{i}^{l - 1}) \\ (103) & = (δ_{1}^{l} w_{i 1}^{l} + δ_{2}^{l} w_{i 2}^{l} + \dots + δ_{2}^{l} w_{i 2}^{l}) f^{^{'}} (S_{i}^{l - 1}) \\ (104) & = \sum_{k}^{m} δ_{k}^{l} w_{i k}^{l} f^{^{'}} (S_{i}^{l - 1}) \\ (105) & = δ_{i}^{l - 1} \end{aligned}

$\begin{align} \frac{\partial E}{\partial S^{l-1}_i}&=\frac{\partial E}{\partial x_i^{l-1}}\frac{\partial x_i^{l-1}}{\partial S^{l-1}_i}\\ &=(\frac{\partial E}{\partial S_1^l}\frac{\partial S_1^l}{\partial x_i^{l-1}}+\frac{\partial E}{\partial S_2^l}\frac{\partial S_2^l}{\partial x_i^{l-1}}+\cdots+\frac{\partial E}{\partial S_m^l}\frac{\partial S_m^l}{\partial x_i^{l-1}})f^{'}(S^{l-1}_i)\\ &=(\delta_1^lw_{i1}^l+\delta_2^lw_{i2}^l+\cdots+\delta_2^lw_{i2}^l)f^{'}(S^{l-1}_i)\\ &=\sum_{k}^{m}\delta^l_kw_{ik}^lf^{'}(S^{l-1}_i)\\ &=\delta_i^{l-1} \end{align}$
由此，我们可以类推得到

\begin{aligned} (106) & δ_{j}^{(l)} & = \frac{\partial E}{\partial S_{j}^{(l)}} \\ (107) & = \sum_{k = 1}^{d^{(} l + 1)} \frac{\partial E}{\partial S_{k}^{(l + 1)}} \frac{\partial S_{k}^{(l + 1)}}{\partial x_{j}^{(l)}} \frac{\partial x_{j}^{(l)}}{\partial S_{j}^{(l)}} \\ (108) & = \sum_{k} (δ_{k}^{(l + 1)}) (w_{j k}^{(l + 1)}) (f^{^{'}} (S_{j}^{(l)})) \end{aligned}

$\begin{align} \delta_j^{(\cal{l})}&=\frac{\partial E}{\partial S_j^{(l)}}\\ &=\sum_{k=1}^{d^(l+1)}\frac{\partial E}{\partial S_k^{(l+1)}}\frac{\partial S_k^{(l+1)}}{\partial x_j^{(l)}}\frac{\partial x_j^{(l)}}{\partial S_j^{(l)}}\\ &=\sum_{k}(\delta_k^{(l+1)})(w_{jk}^{(l+1)})(f^{'}(S_j^{(l)})) \end{align}$

δ_{j}^{(l)}

$\delta_j^{(\cal{l})}$ 就是由

δ_{k}^{(l + 1)}

$\delta_k^{(\cal{l+1})}$ 反向传播得到的。
而后对w进行求偏导，得到

\begin{aligned} (109) & \frac{\partial E}{\partial w_{i j}^{(l)}} & = \frac{\partial E}{\partial S_{j}^{(l)}} \frac{\partial S_{j}^{(l)}}{\partial w_{i j}^{(l)}} \\ (110) & = δ_{j}^{(l)} (x_{i}^{(l - 1)}) \end{aligned}

$\begin{align} \frac{\partial E}{\partial w_{ij}^{(l)}}&=\frac{\partial E}{\partial S_j^{(l)}}\frac{\partial S_j^{(l)}}{\partial w_{ij}^{(l)}}\\ &=\delta_j^{(l)}(x_i^{(l-1)}) \end{align}$
由此便是反向传播的主要思路：

\begin{aligned} (111) & 初 始 化 权 重 w_{i} j^{(l)} \\ (112) & f o r t = 0, 1, \dots, T \\ (113) & 随 机 选 取 n \in {1, 2, \dots, N}; \\ (114) & 前 向 传 播 ： 通 过 初 始 化 x^{(0)} = x_{n} 计 算 所 有 x_{i}^{(l)}; \\ (115) & 反 向 传 播 ： 通 过 x^{(0)} = x_{n}, 反 向 推 出 所 有 δ_{j}^{(l)}; \\ (116) & 通 过 梯 度 下 降 算 法 ， 更 新 权 重 : w_{i j}^{(l)} = w_{i j}^{(l)} - η x_{i}^{(l - 1)} δ_{j}^{(l)} \\ (117) & 返 回 g_{N N E T} (X) = (\dots f (\sum_{j} w_{j k}^{(2)} f (\sum_{i} w_{i j}^{(1)} x - i))) \end{aligned}

$\begin{align} &初始化权重w_ij^{(l)}\\ &for \;t=0,1,\cdots,T\\ &\quad\,随机选取n\in\{1,2,\cdots,N\};\\ &\quad\,前向传播：通过初始化x^{(0)}=x_n计算所有x_i^{(l)};\\ &\quad\,反向传播：通过x^{(0)}=x_n,反向推出所有\delta_j^{(l)};\\ &\quad\,通过梯度下降算法，更新权重:w_{ij}^{(l)}=w_{ij}^{(l)}-\eta x_i^{(l-1)}\delta_j^{(l)}\\ &返回g_{NNET}(X)=(\cdots f(\sum_jw_{jk}^{(2)}f(\sum_iw_{ij}^{(1)}x-i))) \end{align}$

import numpy as np
import matplotlib.pyplot as plt
import random

def sigmoid(x):

    return 1.0 / (1.0 + np.exp(-x))

def sigmoid_prime(x):

    return sigmoid(x)*(1.0 - sigmoid(x))

class BP_Network(object):

    def __init__(self,sizes):

        self.num_layer = len(sizes)
        self.sizes = sizes
        #初始化bias和权重
        self.bias = [np.random.randn(y,1) for y in sizes[1:]]
        self.weight = [np.random.randn(y,x) for y,x in zip(sizes[1:],sizes[:-1])]

    def forwardpro(self,a):\
        #输入第一层，前向传播求出每一层
        activity = np.array([a]).transpose()
        for b,w in zip(self.bias,self.weight):
            activity = sigmoid(np.dot(w,activity) + b)     
        return activity

    def Mini_Batch_GD(self,train_data,num_literation,mini_batch_size,eta):
        """
        num_literation：梯度下降迭代的次数
        mini_batch_size:mini_batch的长度
        eta:
        """
        n = len(train_data)

        for j in range(num_literation):
            random.shuffle(train_data)
            mini_batches = [train_data[k:k + mini_batch_size] for k in range(0,n,mini_batch_size)]
            for mini_batch in mini_batches:
                self.update_weight(mini_batch,eta)

    def update_weight(self,mini_batch,eta):
        # 初始化b，w
        partial_b = [np.zeros(b.shape) for b in self.bias]
        partial_w = [np.zeros(w.shape) for w in self.weight]
        #更新b，w
        for (x,y) in mini_batch:
            change_b,change_w = self.backpro(x,y)
            partial_b = [cb + pb for cb,pb in zip(change_b,partial_b)]
            partial_w = [cw + pw for cw,pw in zip(change_w,partial_w)]

        self.weight = [w - (eta/len(mini_batch)*nw) for w,nw in zip(self.weight,partial_w)]
        self.bias = [b - (eta/len(mini_batch)*nb) for b,nb in zip(self.bias,partial_b)]

    def backpro(self,x,y):
        partial_b = [np.zeros(b.shape) for b in self.bias]
        partial_w = [np.zeros(w.shape) for w in self.weight]
        #前向传播计算出所有隐藏层和输出层的值
        activity = np.array([x]).transpose()
        y = np.array([y]).transpose()
#         print(y.shape)
        forward = [activity]
        ss = []
        for b,w in zip(self.bias,self.weight):
            s = np.dot(w,activity)+b
            ss.append(s)
            activity = sigmoid(s)
            forward.append(activity)
        #计算最后一层的误差和权重
        delta = sigmoid_prime(ss[-1])*(forward[-1]-y)

        partial_b[-1] = delta
        partial_w[-1] = np.dot(delta,forward[-2].transpose())
        # 反向传播计算误差
        for l in range(2,self.num_layer):
            sp = sigmoid_prime(ss[-l])
            delta = np.dot(self.weight[-l+1].transpose(),delta)*sp
            partial_b[-l] = delta
            partial_w[-l] = np.dot(delta,forward[-l-1].transpose())

        return (partial_b,partial_w)

    def predict_digits(self,train_data):
        random.shuffle(train_data)
        test_data = train_data[0:10]
        i=0
        # 打印出预测数据和准确率
        plt.figure()
        for (x,y) in test_data:
            i = i+1
            plt.subplot(2, 5, i)
            plt.axis('off')
            plt.imshow(x.reshape(8,8), cmap=plt.cm.gray_r, interpolation='nearest')
            plt.title('Training: {}'.format(np.argmax(self.forwardpro(x))))
        plt.show()
        count = 0
        for (x,y) in train_data:
            if(np.argmax(self.forwardpro(x))==np.argmax(y)):
                count = count + 1

        print(count/1797)

from sklearn import datasets
# 导入数据
digits = datasets.load_digits()
digits['data'].shape
digits['images'].shape

(1797, 8, 8)

# 处理数据进行预测
r = digits['target']
x = digits['data']
(a,) = r.shape
y = np.zeros((10,a))
# y.shape
for i in range(a):
    y[r[i],i] = 1
x=x.transpose()
print(x.shape)
X = [(x[:,i],y[:,i]) for i in range(a)]
k=499

bp = BP_Network([64,30,10])
bp.Mini_Batch_GD(X,1000,30,0.1)
#输出预测准确率
bp.predict_digits(X)

(64, 1797)

0.8770172509738453

自此，全连接神经网络介绍完毕，接下来，我会花一些时间总结一下cnn与rnn的实现原理并给出相应的代码，由于是新手，所写出的介绍必定会有许多方面的不足，对于其中写的不好的地方，欢迎指出。

参考文献

零基础入门深度学习(3) - 神经网络和反向传播算法
 神经网络浅讲：从神经元到深度学习
 一文弄懂神经网络中的反向传播法——BackPropagation

神经网络与反向传播

神经网络（全连接神经网络）

感知器（perceptron）

神经元

神经网络的结构

反向传播算法(back propagation)

参考文献

猜你喜欢