ELM极限学习机相关Word文档格式.docx

ELM极限学习机相关Word文档格式.docx

《ELM极限学习机相关Word文档格式.docx》由会员分享，可在线阅读，更多相关《ELM极限学习机相关Word文档格式.docx（10页珍藏版）》请在冰豆网上搜索。

1.%% 

主函数，二分类问题 

2. 

3.%导入数据集 

4.A 

= 

load（'

'

）;

5. 

6.data 

A（:

1:

2）;

%特征 

7.label 

3）;

%标签 

8. 

9.[N,n] 

size（data）;

10. 

11.L 

100;

%隐层节点个数 

12.m 

2;

%要分的类别数 

13. 

14.%--初始化权重和偏置矩阵 

15.W 

rand（n,L）*2-1;

16.b_1 

rand（1,L）;

17.ind 

ones（N,1）;

18.b 

b_1（ind,:

%扩充成N*L的矩阵 

19. 

20.tempH 

data*W+b;

21.H 

g（tempH）;

%得到H 

22. 

23.%对输出做处理 

24.temp_T=zeros（N,m）;

25.for 

i 

1:

N 

26. 

if 

label（i,:

） 

== 

0 

27. 

temp_T（i,1） 

1;

28. 

else 

29. 

temp_T（i,2） 

30. 

end 

31.end 

32.T 

temp_T*2-1;

33. 

34.outputWeight 

pinv（H）*T;

35. 

36.%--画出图形 

37.x_1 

data（:

1）;

38.x_2 

2）;

39.hold 

on 

40.for 

1 

:

41. 

42. 

plot（x_1（i,:

）,x_2（i,:

）,'

.g'

43. 

44. 

.r'

45. 

46.end 

47. 

48.output 

H 

* 

outputWeight;

49.%---计算错误率 

50.tempCorrect=0;

51.for 

52. 

[maxNum,index] 

max（output（i,:

））;

53. 

index 

index-1;

54. 

55. 

tempCorrect 

tempCorrect+1;

56. 

57.end 

58. 

59.errorRate 

1-tempCorrect./N;

激活函数

1.function 

[ 

] 

g（ 

X 

./ 

（1 

+ 

exp（-X））;

3.end 

ELM（ExtremeLearningMachine）是一种新型神经网络算法，最早由Huang于2004年提出【Extremelearning

machine:

anewlearningschemeoffeedforwardneuralnetworks】。

与SVM，传统神经网络相比，ELM的训练速度非常快，需要人工干扰较少，对于异质的数据集其泛化能力很强。

Huang在【Extremelearningmachines:

asurvey，2011】这篇论文中对ELM进行了总结，包括最初的ELM算法和后来被发展延伸的ELM算法（比如在线序列ELM算法、增量ELM算法和集成ELM算法等），里面的很多知识点值得学习。

ELM的原理

从神经网络的结构上来看，ELM是一个简单的SLFN，SLFN示意图如下：

该SLFN包括三层：

输入层、隐含层和输出层（忽略输入层则为两层）。

其中隐含层包括L个隐含神经元，一般情况下L远小于N，输出层的输出为m维的向量，对于二分类问题，显然该向量是一维的。

对于一个训练数据样本，忽略输入层和隐含层而只考虑隐含层神经元的输出和输出层，则神经网络的输出函数表达式为：

ai和bi是隐含层节点的参数，表示第i个隐含层神经元和输出神经元之间的连接权值，即它是一个m维的权值向量。

公式里面的G是隐含层神经元的输出。

针对加法型隐含层节点，G为：

其中，小g为激励函数，激励函数可以是线性函数，也可以是sigmoid函数；

针对RBF型隐含层节点，G为：

ai和bi分别表示了第i个径向基函数节点的中心和影响因子。

神经网络输出函数可以写成：

，其中：

如果神经网络能够无误差的预测训练样本，那么隐含层和输出层的权值是有解的，特别的，当L=N时，肯定有解。

但是实际问题中，L往往是远小于N的，那么求解权值向量的问题是无解的，即网络输出和实际值之间有误差，可以定义代价函数为：

接下来如何求解最优的权值向量，使得损失函数J最小呢？

针对这个问题ELM分两种情况解决：

a.如果H是列满秩的，那么可以通过最小二乘找到最佳的权值，其解为：

b.如果H是非列满秩的，则使用奇异值分解求解H的广义逆来计算最佳权值。

和BP使用梯度下降迭代更新所有层之间权值不同，ELM不调整SLFN的输入层和隐含层的权值，这些权值是随即设定的，因此ELM的训练速度非常快。

ELM注重于隐含层到输出层的权值的选取，其采用的方法是最小二乘。

ELM算法一般可以描述如下：

在Huang的survey中描述了一种思想，该思想把SVM也看成了神经网络，该思想把神经网络的输入层到最后一层隐含层的部分或者SVM核函数映射的部分都看成了从输入空间到一个新的空间的转换，然后，BP会将误差反向传播更新权值使得误差最小化，而SVM则力求找到最大分界间隔的分界面，将新空间映射到输出空间，从这个角度来看，SVM确实可以看成是一种神经网络。

ELM最初算法就如上所述，从2004年至今，后来的学者对其进行了很多改进，主要包括对输入层和隐含层权值随即确定权值的优化、求解隐含层和输出层权值的优化（使得ELM更适应于噪声数据集）、核函数ELM以及加入了正则化项的损失函数（求解结构风险而不再是经验风险）、ELM和其他方法相结合等。

ELM为神经网络的结构设计提供了一个新的思路，使我们更好地理解神经网络，但是还有很多问题需要解决，比如隐含层节点个数的确定，正则化项的选择等等。

作为一个性能很好的机器，我们也可以将其应用到诸多交叉学科的应用中。

极限学习机（ELM）算法的matlab与C++实现

极限学习机的原理 

极限学习机（Extremelearningmachine，ELM）是单隐层神经网络的算法，其最大特点就是能在保证学习精度的前提下比传统的学习算法快。

其结构如下图所示：

对于一个单隐层神经网络，假设有N个任意的样本（Xi,ti），其中， 

Xi=[xi1,xi2,⋯xin]T∈Rnti=[ti1,ti2,⋯tim]T∈Rm 

一个有L个隐层节点的单隐层神经网络可以表示为:

∑i=1Lβih（Wi⋅Xj+bi）=ojj=1,⋯,N

其中，h（x）为激活函数， 

Wi=[wi1,wi2,⋯,win]T 

为输入权重，βi为输出权重，bi是第个隐层单元的偏置。

Wi·

Wj表示Wi和Wj的内积。

单隐层神经网络学习的目标是使得输出的误差最小，可以表示为:

∑j=1N∥∥oj−tj∥∥=0 

即存在βi，Wi和bi使得 

∑i=1Lβih（Wi⋅Xj+bi）=tjj=1,⋯,N 

可以矩阵表示为:

Hβ=T 

其中，是H隐层节点的输出，β为输出权重，为T期望输出。

H（W1,⋯,WL,b1,⋯,bL,X1,⋯,XL）=⎡⎣⎢⎢h（W1⋅X1+b1）⋮h（W1⋅XN+b1）⋯⋯⋯h（WL⋅X1+bL）⋮h（WL⋅XN+bL）⎤⎦⎥⎥

β=⎡⎣⎢⎢βT1⋮βTL⎤⎦⎥⎥

T=⎡⎣⎢⎢TT1⋮TTN⎤⎦⎥⎥N×

m

而在ELM算法中,一旦输入权重Wi和隐层的偏置bi被随机确定，隐层的输出矩阵就被唯一确定。

训练单隐层神经网络可以转化为求解一个线性系统Hβ=T。

并且输出权重β可以被确定。

β∧=H+T

其中，H+是矩阵H的Moore-Penrose广义逆。

以一个简单的二分类为例，分别用matlab和c++实现。

matlab代码如下：

traindata=load（'

feature=traindata（:

%特征

label=traindata（:

%标签

X=feature;

[N,n]=size（X）;

L=100;

m=2;

%二分类

W=rand（n,L）*2-1;

%权重-1到1

b_1=rand（1,L）;

b=ones（N,1）*b_1;

H=1./（1+exp（-X*W+b））;

temp_T=zeros（N,m）;

fori=1:

N

if（label（i）==1）

temp_T（i,1）=1;

temp_T（i,2）=0;

else

temp_T（i,1）=0;

temp_T（i,2）=1;

end

end

T=temp_T*2-1;

beta=pinv（H）*T;

x_1=X（:

x_2=X（:

holdon

plot（x_1（i）,x_2（i）,'

c++代码如下，这里的矩阵运算采用Eigen工具包，最难的地方就是广义逆矩阵怎么求，参照网上的资源，代码如下：

#include<

iostream>

fstream>

vector>

string>

Eigen/Dense>

Eigen/SVD>

usingnamespacestd;

usingnamespaceEigen;

template<

typename_Matrix_Type_>

boolpseudoInverse（const_Matrix_Type_&

a,_Matrix_Type_&

result,doubleepsilon=std:

numeric_limits<

typename_Matrix_Type_:

Scalar>

epsilon（））

{

Eigen:

JacobiSVD<

_Matrix_Type_>

svd=（Eigen:

ComputeThinU|Eigen:

ComputeThinV）;

if（）<

（））

{

typename_Matrix_Type_:

Scalartolerance=epsilon*std:

max（）,（））*（）.array（）.abs（）（0）;

result=（）*（）.array（）.abs（）>

tolerance）.select（）.array（）.inverse（）,0）.matrix（）.asDiagonal（）*（）.adjoint（）;

}

rray（）.abs（）.maxCoeff（）;

rray（）.abs（）.maxCoeff（）;

result=（）*（（）.array（）.abs（）>

tolerance）.select（）.array（）.inverse（）,0））.matrix（）.asDiagonal（）*（）.adjoint（）;

returntrue;

}

intmain（）

ifstreamtrainfile;

（"

"

vector<

vector<

double>

>

traindata;

rowdata;

doubletemp[3];

while（!

（））

for（inti=0;

i<

3;

i++）

trainfile>

temp[i];

（temp[i]）;

（rowdata）;

（）,（））;

（）;

MatrixXdfeature（）,2）;

VectorXdlabel（））;

i++）

for（intj=0;

j<

j++）

if（j<

2）

feature（i,j）=traindata[i][j];

label（i）=traindata[i][j];

intL=50;

xp（）+1;

H=（）.inverse（）;

MatrixXdtemp_T,T;

temp_T=MatrixXd:

Zero（N,m）;

N;

if（label（i）==1）

temp_T（i,0）=1;

temp_T（i,1）=0;

temp_T（i,0）=0;

temp_T（i,1）=1;

T=temp_T*2-MatrixXd:

Ones（N,m）;

MatrixXdresult（L,N）;

pseudoInverse（H,result）;

MatrixXdbeta=result*T;

MatrixXdoutput=H*beta;

cout<

<

T（i,0）<

"

;

endl;

output（i,0）<

return0;