BP网络以及深度学习.docx

BP网络以及深度学习.docx

《BP网络以及深度学习.docx》由会员分享，可在线阅读，更多相关《BP网络以及深度学习.docx（15页珍藏版）》请在冰豆网上搜索。

BP网络以及深度学习

神经网络

1BP网

图：

三层BP网

信号正向传播和误差反向传播

k=1,2……l有l个输出（l常常为1）。

中间隐层有m层：

i=1,2,……mn个输入。

j=1,2……m

其中Sigmoid函数：

（单极性）

1.1计算流程

不同样本误差：

E=（（T-Ok）'*（T-Ok））/2;

一般使用

1.2影响参数:

1.2.1隐层节点数

nn=

+a，其中m为输出神经元数，n为输入神经元数，

a为[1，10]之间的常数。

nn=

nn=2n+1;

nn=

1.2.2学习率

学习率

，太大会影响训练稳定性，太小使训练收敛速度慢。

一般在0.01--0.8之间。

我取0.2

Emin一般在0.1--之间。

1.3样本/输入

1.3.1训练样本

训练样本数：

M

，

为权值阈值总数，一般为连接权总数的5~10倍。

训练数据必须作平衡处理，不同类别的样本需要交叉输入，轮流输入--时间延长。

1.3.2输入形式

字符：

形状格填充、边缘距离

曲线：

采样变化大可以密集采样

输出：

不同的输出用不同的码表示

1.3.3归一化：

样本分布比较均匀

[0,1]区间：

[-1,1]区间：

其中

不均匀：

对数平方根

[coef,score,latent,t2]=princomp（x）;（个人观点）：

x：

为要输入的n维原始数据。

带入这个matlab自带函数，将会生成新的n维加工后的数据（即score）。

此数据与之前的n维原始数据一一对应。

score：

生成的n维加工后的数据存在score里。

它是对原始数据进行的分析，进而在新的坐标系下获得的数据。

他将这n维数据按贡献率由大到小排列。

（即在改变坐标系的情况下，又对n维数据排序）

latent：

是一维列向量，每一个数据是对应score里相应维的贡献率，因为数据有n维所以列向量有n个数据。

由大到小排列（因为score也是按贡献率由大到小排列）。

coef：

是系数矩阵。

通过cofe可以知道x是怎样转换成score的。

1.4权值/阈值

1.4.1初始权值

初始权值足够小，初始值为1和-1的权值数相等。

1.4.2权值学习算法

P99

traingd:

标准梯度下降算法

traingdm:

附加动量项

traingda:

自适应学习速率，效果比上者好。

traingdx:

附加动量项、自适应学习速率

更好的算法如下：

trainlm:

trainscg:

权值学习算法

算法描述

traingd

标准BP

traingda

可变学习率BP

traingdm

附加动量的BP

traingdx

附加动量、可变学习率BP

traincgf

Fletcher-Powell共轭梯度法

traincgp

Polak-Ribiere共轭梯度法

traincgb

Powell-Beale共轭梯度法

trainscg

Scaled共轭梯度法

trainbfg

BFGS拟牛顿法

trainoss

正割拟牛顿法

trainlm

Levenberg-Marquardt法

trainrp

弹性BP

1.5优化

1提高训练速度：

附加动量法：

其中

见P85

2

改为

，一般

=1

较大时，进入平坦区，令

>1

常用的改进方法有附加冲量项、自适应学习参数、模拟退火法等,

1.6技巧

若show设为NaN,则不显示训练过程

一篇论文中案例：

初始权值不可过大过小。

网络1的初始权值和偏差定为-0.25--0.25的随机数，网络2的定为-0.5--0.5的随机数。

目标误差：

0.05两个连续迭代过程平均相差小于

，

样本数：

200

1.7常用函数归纳

1.7.1train之前

net.trainParam.show=10;%showinterval25

%net.trainParam.showWindow=flase;

net.trainParam.epochs=5000;%traintimes.default:

10

net.trainParam.goal=0.0001;%0

net.trainParam.lr=0.2;%0.15

net.trainParam.max_fail=5;%maxtimesofaffirmfailure

net.trainParam.min_grad=1e-10;%mingradient

net.trainParam.time=inf;%maxtraintime

net.trainParam.mc=0.95;%momentumfactorwhenusetraingdm,default:

0.9

1.7.2

%net.iw{1,1}=iw;net.lw{2,1}=lw;net.b{1}=theta1;net.b{2}=theta2;

%net.layers{1}.initFcn='initlay';

Plotpv（p,t,v）

Plotpc（net.iw{1,1},net.b{1}）

初始化网络:

Net.inputWeights{1,1}.initFcn=’rands’;%initializeweight

Net.biases{1}.initFcn=’rands’;%initializedeviation

net=init（net）

误差平方和：

sumsqr

Newffnewcf

1.8评价标准

实际为正类

实际为负类

预测为正类

TP

FP

预测为负类

FN

TN

查准率/精度:

precision=TP/（TP+FP）

真正类率（TPR）/查全率/真阳性率/灵敏度/召回率/敏感性（sensitivity）:

recall=TP/（TP+FN）

正确率：

accuracy=（TP+TN）/ALL

特异性（specificity）/真阴性率/1-假阳性率：

TN/（FP+TN）

2前馈神经网络

无隐层：

线性

单隐层：

凸域

双隐层：

任意复杂形状区域，所以一般使用单隐层，较少情况下可以使用双隐层。

解决已知的线性问题，使用感知器或者自适应网络更好，非线性使用BP。

2.1单层感知器

方程组求解的形式，只能做线性划分

Newp

检验：

hardlim（W+P,B）

2.2Adaline自适应线性元件

神经元有一个激活函数,因此输出可以是任意值。

可以做线性逼近。

采用LMS（最小均方差规则，又称W-H学习规则）：

不用求导

newlin

newlind

带有延时的自适应线性网络

3深度神经网络

在语音识别和图像识别等领域获得了巨大的成功

4递归神经网络

反馈神经网络

4.1全局反馈递归神经网络

4.1.1ARX和NARX网络

4.1.2Hopfield网络

4.1.3约旦网络

4.2前向递归神经网络

4.2.1局部连接

4.2.2全连接型

Elman

记忆递归神经网络

4.3混合型网络

5RBF网络

径向基函数解决插值问题

完全内插法要求插值函数经过每个样本点，即

。

样本点总共有P个。

RBF的方法是要选择P个基函数，每个基函数对应一个训练数据，各基函数形式为

，由于距离是径向同性的，因此称为径向基函数。

||X-Xp||表示差向量的模，或者叫2范数。

基于为径向基函数的插值函数为：

输入X是个m维的向量，样本容量为P，P>m。

可以看到输入数据点Xp是径向基函数φp的中心。

隐藏层的作用是把向量从低维m映射到高维P，低维线性不可分的情况到高维就线性可分了。

将插值条件代入：

写成向量的形式为

，显然Φ是个规模这P对称矩阵，且与X的维度无关，当Φ可逆时，有

。

对于一大类函数，当输入的X各不相同时，Φ就是可逆的。

下面的几个函数就属于这“一大类”函数：

1）Gauss（高斯）函数

2）ReflectedSigmoidal（反常S型）函数

3）Inversemultiquadrics（拟多二次）函数

σ称为径向基函数的扩展常数，它反应了函数图像的宽度，σ越小，宽度越窄，函数越具有选择性。

完全内插存在一些问题：

1）插值曲面必须经过所有样本点，当样本中包含噪声时，神经网络将拟合出一个错误的曲面，从而使泛化能力下降。

由于输入样本中包含噪声，所以我们可以设计隐藏层大小为K，K

2）基函数个数等于训练样本数目，当训练样本数远远大于物理过程中固有的自由度时，问题就称为超定的，插值矩阵求逆时可能导致不稳定。

拟合函数F的重建问题满足以下3个条件时，称问题为适定的：

1.解的存在性

2.解的唯一性

3.解的连续性

不适定问题大量存在，为解决这个问题，就引入了正则化理论。

正则化理论

正则化的基本思想是通过加入一个含有解的先验知识的约束来控制映射函数的光滑性，这样相似的输入就对应着相似的输出。

寻找逼近函数F（x）通过最小化下面的目标函数来实现：

加式的第一项好理解，这是均方误差，寻找最优的逼近函数，自然要使均方误差最小。

第二项是用来控制逼近函数光滑程度的，称为正则化项，λ是正则化参数，D是一个线性微分算子，代表了对F（x）的先验知识。

曲率过大（光滑度过低）的F（x）通常具有较大的||DF||值，因此将受到较大的惩罚。

直接给出

（1）式的解：

权向量

********************************

（2）

G（X,Xp）称为Green函数，G称为Green矩阵。

Green函数与算子D的形式有关，当D具有旋转不变性和平移不变性时，

。

这类Green函数的一个重要例子是多元Gauss函数：

。

代码

%//ThisisaRBFnetworktrainedbyBPalgorithm

%//Author:

zouxy

%//Date:

2013-10-28

%//HomePage:

%//Email:

zouxy09@

closeall;clear;clc;

%%%************************************************

%%%************step0:

loaddata****************

display（'step0:

loaddata...'）;

%train_x=[12345678];%eachsamplearrangedasacolumnoftrain_x

%train_y=2*train_x;

train_x=rand（5,10）;

train_y=2*train_x;

test_x=train_x;

test_y=train_y;

%%frommatlab

%rbf=newrb（train_x,train_y）;

%output=rbf（test_x）;

%%%************************************************

%%%********step1:

initializeparameters********

display（'step1:

initializeparameters...'）;

numSamples=size（train_x,2）;

rbf.inputSize=size（train_x,1）;

rbf.hiddenSize=numSamples;%numofRadialBasisfunction

rbf.outputSize=size（train_y,1）;

rbf.alpha=0.1;%learningrate（shouldnotbelarge!

）

%%centreofRBF

fori=1:

rbf.hiddenSize

%randomlypickupsomesamplestoinitializecentresofRBF

index=randi（[1,numSamples]）;

rbf.center（:

i）=train_x（:

index）;

end

%%deltaofRBF

rbf.delta=rand（1,rbf.hiddenSize）;

%%weightofRBF

r=1.0;%randomnumberbetween[-r,r]

rbf.weight=rand（rbf.outputSize,rbf.hiddenSize）*2*r-r;

%%%************************************************

%%%************step2:

starttraining************

display（'step2:

starttraining...'）;

maxIter=400;

preCost=0;

fori=1:

maxIter

fprintf（1,'Iteration%d,',i）;

rbf=trainRBF（rbf,train_x,train_y）;

fprintf（1,'thecostis%d\n',rbf.cost）;

curCost=rbf.cost;

ifabs（curCost-preCost）<1e-8

disp（'ReachediterationterminationconditionandTerminationnow!

'）;

break;

end

preCost=curCost;

end

%%%************************************************

%%%************step3:

starttesting************

display（'step3:

starttesting...'）;

Green=zeros（rbf.hiddenSize,1）;

fori=1:

size（test_x,2）

forj=1:

rbf.hiddenSize

Green（j,1）=green（test_x（:

i）,rbf.center（:

j）,rbf.delta（j））;

end

output（:

i）=rbf.weight*Green;

end

disp（test_y）;

disp（output）;

function[rbf]=trainRBF（rbf,train_x,train_y）

%%%step1:

calculategradient

numSamples=size（train_x,2）;

Green=zeros（rbf.hiddenSize,1）;

output=zeros（rbf.outputSize,1）;

delta_weight=zeros（rbf.outputSize,rbf.hiddenSize）;

delta_center=zeros（rbf.inputSize,rbf.hiddenSize）;

delta_delta=zeros（1,rbf.hiddenSize）;

rbf.cost=0;

fori=1:

numSamples

%%Feedforward

forj=1:

rbf.hiddenSize

Green（j,1）=green（train_x（:

i）,rbf.center（:

j）,rbf.delta（j））;

end

output=rbf.weight*Green;

%%Backpropagation

delta3=-（train_y（:

i）-output）;

rbf.cost=rbf.cost+sum（delta3.^2）;

delta_weight=delta_weight+delta3*Green';

delta2=rbf.weight'*delta3.*Green;

forj=1:

rbf.hiddenSize

delta_center（:

j）=delta_center（:

j）+delta2（j）.*（train_x（:

i）-rbf.center（:

j））./rbf.delta（j）^2;

delta_delta（j）=delta_delta（j）+delta2（j）*sum（（train_x（:

i）-rbf.center（:

j））.^2）./rbf.delta（j）^3;

end

end

%%%step2:

updateparameters

rbf.cost=0.5*rbf.cost./numSamples;

rbf.weight=rbf.weight-rbf.alpha.*delta_weight./numSamples;

rbf.center=rbf.center-rbf.alpha.*delta_center./numSamples;

rbf.delta=rbf.delta-rbf.alpha.*delta_delta./numSamples;

end

functiongreenValue=green（x,c,delta）

greenValue=exp（-1.0*sum（（x-c）.^2）/（2*delta^2））;

end

五、代码测试

   首先，我测试了一维的输入，需要拟合的函数很简单，就是y=2x。

train_x=[12345678];

train_y=2*train_x;