第五章　神经网络_综合

神经网络

1.基础知识

神经网络是由具有适应性的简单单元组成的广泛并行互连的网络

Perceptron 感知机

感知机只有两层神经元组成，而且只有输出层是M-P神经单元也就是功能神经元

反向传播算法（Back propagation）可以应用于多层前馈神经网络，还可以应用于训练递归神经网络

一般说　BP算法就是训练的多层前馈神经网络．

深度学习的基本名词

卷积神经网络(convolutional neural network CNN)

cnn复合多个　卷积层　和　采样层　来对输入信号进行加工．最终在连接层实现与输出目标之间的映射．

卷积层：包含多个特征映射，每个特征映射是一个由多个神经元构成的平面．

采样层：基于局部相关性原理进行亚采样，减少数据量的同时保留有用信息．

换个角度理解就是　用机器代替原来专家的＂特征工程（feature engineering）＂

神经网络的激活函数

1.logitic:典型的激活函数sigmod函数，在计算分类概率时，非常有用．

f (z) = 1 1 + e x p ( ? z ), 0 < f (z) < 1

$f(z)=\frac{1}{1+exp(-z)} ,　0<f(z)<1$

2.Tanh:

f (z) = t a n h (z) = e z ? e ? z e z + e ? z, ? 1 < f (z) < 1

$f(z)=tanh(z)=\frac{e^{z}-e^{-z}}{e^{z}+e^{-z}}　,-1<f(z)<1$

3.Relu:线性修正函数，函数的主要目的是对抗梯度消失，当梯度反向传播到第一层的时候，梯度容易趋近于０或者一个非常小的值．

f (z) = m a x (0, x)

$f(z)=max(0,x)$

卷积神经网络(CNN)

卷积：就是两个操作在时间维度上的融合．

(f ? g) (τ) = \int \infty ? \infty f (τ) g (t ? τ) d τ

$(f\cdot g)(\tau)=\int_{-\infty}^{\infty}f(\tau)g(t-\tau)d\tau$ 卷积的使用范围可以被延展到离散域，数学表达式为

(f ? g) [n] = \sum m = ? \infty \infty f (m) g (n ? m)

$(f\cdot g)\left [ n \right ]=\sum_{m=-\infty}^{\infty} f(m)g(n-m)$ 卷积运算中最重要的是核函数，利用核函数分别与每个点的乘积再求和．作为下一个层的元素点．

2.思想脉络

根据训练数据集来调整神经元之间的连接权　connection weight ,以及每个功能神经元的阈值．

也就是说，神经网络所学到的东西都在连接权和阈值中．

参数的确定（利用迭代更新）调整感知机（神经网络）的权重．

$\omega_{i}\leftarrow \omega+\Delta \omega_{i}$

$\Delta \omega_{i}=\eta(y-\hat{y}x_{i})$

先将输入事例提供给输入层神经元，逐层将信号进行前传，直到产生输出层的结果

计算输出层的误差，再将误差逆向传播至隐层神经元

最后根据隐层神经元的误差来对连接权和阈值进行调整．并进行迭代循环进行．

3.算法推导

BP算法：

训练集
$D=\left\{(x_{1},y_{1}),(x_{2},y_{2}),...,(x_{m},y_{m})\right\}$

输入：d个属性

输出：l维实值向量阈值 $\theta_{j}$

隐藏层：q个隐层神经元网络阈值　 $\gamma_{h}$

$b_{h}=f_{1}(\alpha_{h}-\gamma_{h})$

$y_{j}=f_{2}(\beta_{j}-\theta_{j})$

任意参数的更新估计式

υ \leftarrow υ + Δ υ

$\upsilon \leftarrow \upsilon +\Delta \upsilon$

BP算法基于梯度下降策略来进行参数的调整

知识点补充：梯度下降法（gradient descent）

梯度下降法是一种常用的一阶优化方法，是求解无约束优化问题最简单,最经典的方法之一．

f(x)是连续可微函数，且满足

f (x t + 1) < f (x t) t = 0, 1, 2, 3...

$f(x^{t+1})<f(x^{t}) t=0,1,2,3...$

则不断执行该过程可收敛到局部最小点，根据泰勒公式展开

f (x + Δ x) ? f (x) + Δ x T ▽ f (x)

$f(x+\Delta x)\simeq f(x)+\Delta x^{T}\triangledown f(x)$ 为了使

f(x+Δx)<f(x)f(x+Δx)<f(x) $f(x+\Delta x)<f(x)$ 　可以让

Δ x = ? γ ▽ f (x), 其 中 γ 为 步 长 ， 一 个 小 常 数

$\Delta x=-\gamma \triangledown f(x), 其中　\gamma为步长，一个小常数$ 目标函数：

Ek=12∑lj=1(ykj^?yKj)Ek=12∑j=1l(yjk^?yjK) $E_{k}=\frac{1}{2}\sum_{j=1}^{l}(\hat{y_{j}^{k}}-y_{j}^{K})$ 最小化目标函数推导

ΔυihΔυih $\Delta \upsilon_{ih}$ 的更新公式: 对目标函数进行求导

? E k ? υ i h = ? E k ? b h . ? b h ? α h = ? \sum j = 1 l ? E k ? β j . ? β j ? α h f' (α h ? γ h) = \sum i = 1 l ω h j g j f' (α h ? γ h) = b h (1 ? b h) \sum j = 1 l ω h j g j .

$\frac{\partial E_{k}}{\partial \upsilon_{ih}}=\frac{\partial E_{k}}{\partial b_{h}}. \frac{\partial b_{h}}{\partial \alpha_{h} }=-\sum_{j=1}^{l} \frac{\partial E_{k}}{\partial \beta{j}}.\frac{\partial \beta{j}}{\partial \alpha_{h}}{f}'(\alpha_{h}-\gamma_{h})=\sum_{i=1}^{l} \omega_{hj}g_{j}{f}'(\alpha_{h}-\gamma_{h})=b_{h}(1-b_{h})\sum_{j=1}^{l}\omega_{hj}g_{j}.$ 隐藏层和输出层的激活函数是相同的

全局最小　＆　局部最小

其实整个算法是一个参数寻优的过程．找到一组最优的参数．

4.编程推导

4.1BP算法，在西瓜数据集3.0上用算法训练一个单隐层神经网络

PesudoCode:

          输入：训练集学习率 过程：1.在(0,1)范围内随机初始化网络中所有的连接权值和阈值2．repeat3.　for all (Xk,Yk) do4.      根据当前参数和公式，计算当前样本的输出5.      根据公式计算出输出层神经元的梯度项6.      根据公式计算隐层神经元的梯度项7.      根据公式更新连接权和阈值8.  end for9. until 达到停止条件输出：连接权与阈值确定的多层前馈神经网络注意区分标准BP算法，和累积BP算法(accumulated error backpropagation)
累积BP算法:是将训练集进行读取一遍后才进行更新
标准BP算法：针对一个训练样例进行更新

# input()函数
# 将西瓜数据集3.0进行读取
def input():"""@param : none or filepath@return : dataSet，dataFrame using pandasRandom double or random.uniform()"""try:import pandas as pdexcept ImportError:print("module import error")with open('/home/dengshuo/GithubCode/ML/CH05/watermelon3.csv') as data_file:df=pd.read_csv(data_file)return df

# learningRatio()函数
# 初始化函数的学习率
def learningRatio():"""@ return : learningRatio """try:import randomexcept ImportError:print('module import error')learningRatio=random.uniform(0,1)return learningRatio

ratio=learningRatio()
print(ratio)
input()

0.8475765311660175

.dataframe thead tr:only-child th { text-align: right; } .dataframe thead th { text-align: left; } .dataframe tbody tr th { vertical-align: top; }

	编号	色泽	根蒂	敲声	纹理	脐部	触感	密度	含糖率	好瓜
0	1	青绿	蜷缩	浊响	清晰	凹陷	硬滑	0.697	0.460	是
1	2	乌黑	蜷缩	沉闷	清晰	凹陷	硬滑	0.774	0.376	是
2	3	乌黑	蜷缩	浊响	清晰	凹陷	硬滑	0.634	0.264	是
3	4	青绿	蜷缩	沉闷	清晰	凹陷	硬滑	0.608	0.318	是
4	5	浅白	蜷缩	浊响	清晰	凹陷	硬滑	0.556	0.215	是
5	6	青绿	稍蜷	浊响	清晰	稍凹	软粘	0.403	0.237	是
6	7	乌黑	稍蜷	浊响	稍糊	稍凹	软粘	0.481	0.149	是
7	8	乌黑	稍蜷	浊响	清晰	稍凹	硬滑	0.437	0.211	是
8	9	乌黑	稍蜷	沉闷	稍糊	稍凹	硬滑	0.666	0.091	否
9	10	青绿	硬挺	清脆	清晰	平坦	软粘	0.243	0.267	否
10	11	浅白	硬挺	清脆	模糊	平坦	硬滑	0.245	0.057	否
11	12	浅白	蜷缩	浊响	模糊	平坦	软粘	0.343	0.099	否
12	13	青绿	稍蜷	浊响	稍糊	凹陷	硬滑	0.639	0.161	否
13	14	浅白	稍蜷	沉闷	稍糊	凹陷	硬滑	0.657	0.198	否
14	15	乌黑	稍蜷	浊响	清晰	稍凹	软粘	0.360	0.370	否
15	16	浅白	蜷缩	浊响	模糊	平坦	硬滑	0.593	0.042	否
16	17	青绿	蜷缩	沉闷	稍糊	稍凹	硬滑	0.719	0.103	否
17	18	青绿	蜷缩	浊响	清晰	凹陷	硬滑	0.697	0.460	NaN

# outputlayer() 函数
# 计算函数输出层的输出值Yk
def outputlayer(df):"""@param df: the dataframe of pandas@return Yk:the output """
# 复杂的参数让人头疼

# define class()
# define the neural networks structure，创建整个算法的框架
''' the definition of BP network class '''
class BP_network: def __init__(self):'''initial variables'''# node number each layerself.i_n = 0           self.h_n = 0   self.o_n = 0# output value for each layerself.i_v = []       self.h_v = []self.o_v = []# parameters (w, t)self.ih_w = []    # weight for each linkself.ho_w = []self.h_t  = []    # threshold for each neuronself.o_t  = []# definition of alternative activation functions and it's derivationself.fun = {'Sigmoid': Sigmoid, 　　　　　　　　　# 对数几率函数'SigmoidDerivate': SigmoidDerivate,'Tanh': Tanh, 　　　　　　　　　　　　　# 双曲正切函数'TanhDerivate': TanhDerivate,}

'Sigmoid': Sigmoid, 　　　　　　　　　# 对数几率函数^
SyntaxError: invalid character in identifier

# CreateNN()　函数
# 将架构进行填充def CreateNN(self, ni, nh, no, actfun):'''build a BP network structure and initial parameters@param ni, nh, no: the neuron number of each layer@param actfun: string, the name of activation function'''# import module packagesimport numpy as np import random# assignment of node number# 对每层的结点树的输入值进行赋值self.i_n = niself.h_n = nhself.o_n = no# initial value of output for each layerself.i_v = np.zeros(self.i_n)self.h_v = np.zeros(self.h_n)self.o_v = np.zeros(self.o_n)# initial weights for each link (random initialization)self.ih_w = np.zeros([self.i_n, self.h_n])self.ho_w = np.zeros([self.h_n, self.o_n])# 利用循环来对权值进行赋值for i in range(self.i_n):  for h in range(self.h_n): self.ih_w[i][h] = rand(0,1)# float(0,1) # 调用rand()函数for h in range(self.h_n):  for j in range(self.o_n): self.ho_w[h][j] = rand(0,1)# initial threshold for each neuronself.h_t = np.zeros(self.h_n)self.o_t = np.zeros(self.o_n)for h in range(self.h_n): self.h_t[h] = rand(0,1)for j in range(self.o_n): self.o_t[j] = rand(0,1)# initial activation function# 这个不调库能直接用？不是很理解self.af  = self.fun[actfun]self.afd = self.fun[actfun+'Derivate']

# 随机取值函数的定义
''' the definition of random function '''
def rand(a, b):'''random value generation for parameter initialization@param a,b: the upper and lower limitation of the random value'''from random import randomreturn (b - a) * random() + a

# define th need functions
# 一些激活函数
''' the definition of activation functions '''
def Sigmoid(x):'''definition of sigmoid function and it's derivation'''from math import expreturn 1.0 / (1.0 + exp(-x))
def SigmoidDerivate(y):return y * (1 - y)def Tanh(x):'''definition of sigmoid function and it's derivation'''from math import tanhreturn tanh(x)
def TanhDerivate(y):return 1 - y*y

# predict process through the network
# 计算一个输出def Pred(self, x):'''@param x: the input array for input layer'''# activate input layerfor i in range(self.i_n):self.i_v[i] = x[i]# activate hidden layerfor h in range(self.h_n):total = 0.0for i in range(self.i_n):total += self.i_v[i] * self.ih_w[i][h]self.h_v[h] = self.af(total - self.h_t[h])# activate output layerfor j in range(self.o_n):total = 0.0for h in range(self.h_n):total += self.h_v[h] * self.ho_w[h][j]self.o_v[j] = self.af(total - self.o_t[j])

**还有一个问题就是，已经读取的西瓜数据，该以什么样的形式来进行输入
西瓜数据集的离散性变量该如何处理　例如：色泽｛青緑，乌黑，浅白｝＝｛0,1,2｝  ??
如何不是这样，怎么实现离散性变量的计算？**

# the implementation of BP algorithms on one slide of sample
# backPropagate()　函数
# 后向传播函数，进行计算def BackPropagate(self, x, y, lr):'''@param x, y: array, input and output of the data sample@param lr: float, the learning rate of gradient decent iteration'''# import need module packagesimport numpy as np # get current network outputself.Pred(x)# calculate the gradient based on outputo_grid = np.zeros(self.o_n) for j in range(self.o_n):# 输出层的神经元梯度项，参考西瓜书　5.3　公式(5.10)o_grid[j] = (y[j] - self.o_v[j]) * self.afd(self.o_v[j])# 这个self.afd()函数就相当于yk(1-yk)# caculate the gradient of hidden layer# 计算隐藏层的梯度项Ｅhh_grid = np.zeros(self.h_n)for h in range(self.h_n):for j in range(self.o_n):h_grid[h] += self.ho_w[h][j] * o_grid[j]h_grid[h] = h_grid[h] * self.afd(self.h_v[h]) # self.afd()函数就是 Bh(1-Bh)# updating the parameter# 将参数进行更新for h in range(self.h_n):  for j in range(self.o_n): # 更新公式self.ho_w[h][j] += lr * o_grid[j] * self.h_v[h]for i in range(self.i_n):  for h in range(self.h_n): self.ih_w[i][h] += lr * h_grid[h] * self.i_v[i]     for j in range(self.o_n):self.o_t[j] -= lr * o_grid[j]    for h in range(self.h_n):self.h_t[h] -= lr * h_grid[h]

# define TrainStandard() 函数
# 标准的BP函数，计算累积误差def TrainStandard(self, data_in, data_out, lr=0.05):'''@param lr, learning rate, default 0.05@param data_in :the networks input data@param data_out:the output data of output layer@return: e, accumulated error@return: e_k, error array of each step'''    e_k = []for k in range(len(data_in)):x = data_in[k]y = data_out[k]self.BackPropagate(x, y, lr)# error in train set for each step# 计算均方误差y_delta2 = 0.0for j in range(self.o_n):y_delta2 += (self.o_v[j] - y[j]) * (self.o_v[j] - y[j])  e_k.append(y_delta2/2)# total error of training# 先计算出累积误差，然后最小化累积误差e = sum(e_k)/len(e_k)return e, e_k

# 返回预测的标签，好瓜是１，坏瓜是０
def PredLabel(self, X):'''predict process through the network@param X: the input sample set for input layer@return: y, array, output set (0,1 - class) based on [winner-takes-all] 也就是竞争学习，胜者通吃'''    import numpy as npy = []for m in range(len(X)):self.Pred(X[m])if self.o_v[0] > 0.5:  y.append(1)else : y.append(0)
# max_y = self.o_v[0]
# label = 0
# for j in range(1,self.o_n):
# if max_y < self.o_v[j]: label = j
# y.append(label)return np.array(y)

4.2 利用tensorflow 来实现BP算法

先学习如何实现BP算法

汽车燃油效率建模，一个非线性回归．建立一个多变量输入，单变量输出的前向神经网络

1.数据集的描述和加载

这个数据集是一个著名的，标准的输入数据集．这是一个非常简单的例子，主要还是理解其主要的步骤和方法．

因为这个数据集是标准封装好的数据集，不需要进行详细的数据分析．

一般情况下，数据集会进行可视化处理和详细的数据分析．

2.数据的预处理

一般情况下的预处理也是利用sklearn包中的函数进行直接调用处理．

Sklearn中的Pre-Processing模块

sklearn.preprocessing.StandardScaler
# Standardize features by removing the mean and scaling to unit variance
scaler=preprocessing.StandardScaler()
X_train=scaler.fit_transform(X_train)

这是我现阶段认为进行算法分析最难，也是最不容易操作的地方就是将数据进行处理，满足算法分析的要求．一般情况下都是数据进行处理，满足输入的条件　向算法靠拢有没有根据数据，算法向数据靠拢的，是不是就是一开始的算法选择问题？

3.模型架构

多输入，双隐层，单输出的前向神经网络

七个输入结点，第一隐藏层10,第二隐藏层5，一个输出结点．

不过这个比较简单，可直接利用tensorflow中skflow库来直接调取，skflow库的学习

4.准确度测试

利用均方误差来监测准确度．

还是sklearn.metrics 模型的性能度量．

这个例子不需要进行参数的更新？　主要还是损失函数的优化，本例中没有体现．

score=metrics.mean_squared_error(regressor.predict(scaler.transform(X_test)),y_test)
print("Total mean squared error :".format(score))

上述代码进行汇总，步骤进行合成

完整的源代码

from sklearn import datasets,cross_validation,metrics
from sklearn import preprocessing
from tensorflow.contrib import learn
import pandas as pd 
import matplotlib.pyplot as plt 
%matplotlib inline
%config InlineBackend.figure_format='svg'
from keras.models import Sequential
from keras.layers import Dense

read the original dataset with pandas packages

df=pd.read_csv('mpg.csv',header=0)
df