ELM-Chinese-Brief(极限学习机)
极限学习机原理介绍

11 21 ... l1
12 22 ... l 2
... 1m ... 2 m ... ... ... lm l m
(2)
其中, jk 表示隐含层第 j 个神经元与输出层第 k 个神经元间的连接权值。 设隐含层神经元的阈值 b 为
w11 w W 21 ... wl1
w12 w22 ... wl 2
... w1n ... w2 n ... ... ... wln l n
(1)
其中, w ji 表示输入层第 i 个神经元与隐含层第 j 个神经元的连接权值。 设隐含层与输出层间的连接权值 为
.
由定理 1 可知, 若隐含层神经元个数与训练集样本个数相等, 则对于任意的 w 和
b ,SLFN 都可以零误差逼近训练样本,即
|| t
j 1
Q
j
y j || 0
(8)
其中,
y j [ y1 j , y2 j ,..., ymj ]T ( j 1,2,..., Q) .
然而,当训练样本个数 Q 较大时,为了减少计算量,隐含层神经元个数 K 通常 取比 Q 小的数,由定理 2 可知,SLFN 的训练误差逼近一个任意的
^ ^
提及,ELM 的性能也得到了很大的提升,其应用范围亦愈来愈广,其重要性亦日 益体现出来。
二,ELM 概述 传统的典型单隐含层前馈神经网络结构如下图一所示,由输入层,隐含层和 输出层组成,输入层与隐含层,隐含层与输出层神经元间全连接。其中,输入层 有 n 个神经元, 对应 n 个输入变量; 隐含层有 l 个神经元; 输出层有 m 个神经元, 对应 m 个输出变量。在不失一般性的情况下,设输入层与隐含层间的连接权值 W为
ELM极限学习机算法源码

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import no.uib.cipr.matrix.DenseMatrix;import no.uib.cipr.matrix.DenseVector;import no.uib.cipr.matrix.Matrices;import no.uib.cipr.matrix.NotConvergedException;public class elm {private DenseMatrix train_set;private DenseMatrix test_set;private int numTrainData;private int numTestData;private DenseMatrix InputWeight;private float TrainingTime;private float TestingTime;private double TrainingAccuracy, TestingAccuracy;private int Elm_Type;private int NumberofHiddenNeurons;private int NumberofOutputNeurons;private int NumberofInputNeurons;private String func;private int []label;private DenseMatrix BiasofHiddenNeurons;private DenseMatrix OutputWeight;private DenseMatrix testP;private DenseMatrix testT;private DenseMatrix Y;private DenseMatrix T;public elm(int elm_type, int numberofHiddenNeurons, String ActivationFunction){Elm_Type = elm_type;NumberofHiddenNeurons = numberofHiddenNeurons;func = ActivationFunction;TrainingTime = 0;TestingTime = 0;TrainingAccuracy= 0;TestingAccuracy = 0;NumberofOutputNeurons = 1;}public elm(){}public DenseMatrix loadmatrix(String filename) throws IOException{BufferedReader reader = new BufferedReader(new FileReader(new File(filename)));String firstlineString = reader.readLine();String []strings = firstlineString.split(" ");int m = Integer.parseInt(strings[0]);int n = Integer.parseInt(strings[1]);if(strings.length > 2)NumberofOutputNeurons = Integer.parseInt(strings[2]);DenseMatrix matrix = new DenseMatrix(m, n);firstlineString = reader.readLine();int i = 0;while (i<m) {String []datatrings = firstlineString.split(" ");for (int j = 0; j < n; j++) {matrix.set(i, j,Double.parseDouble(datatrings[j]));}i++;firstlineString = reader.readLine();}return matrix;}public void train(String TrainingData_File) throws NotConvergedException{try {train_set = loadmatrix(TrainingData_File);} catch (IOException e) {e.printStackTrace();}train();}public void train(double [][]traindata) throws NotConvergedException{//classification require a the number of classtrain_set = new DenseMatrix(traindata);int m = train_set.numRows();if(Elm_Type == 1){double maxtag = traindata[0][0];for (int i = 0; i < m; i++) {if(traindata[i][0] > maxtag)maxtag = traindata[i][0];}NumberofOutputNeurons = (int)maxtag+1;}train();}private void train() throws NotConvergedException{numTrainData = train_set.numRows();NumberofInputNeurons = train_set.numColumns() - 1;InputWeight = (DenseMatrix)Matrices.random(NumberofHiddenNeurons, NumberofInputNeurons);DenseMatrix transT = new DenseMatrix(numTrainData, 1);DenseMatrix transP = new DenseMatrix(numTrainData, NumberofInputNeurons);for (int i = 0; i < numTrainData; i++) {transT.set(i, 0, train_set.get(i, 0));for (int j = 1; j <= NumberofInputNeurons; j++)transP.set(i, j-1, train_set.get(i, j));}T = new DenseMatrix(1,numTrainData);DenseMatrix P = newDenseMatrix(NumberofInputNeurons,numTrainData);transT.transpose(T);transP.transpose(P);if(Elm_Type != 0) //CLASSIFIER{label = new int[NumberofOutputNeurons];for (int i = 0; i < NumberofOutputNeurons; i++) {label[i] = i; }DenseMatrix tempT = newDenseMatrix(NumberofOutputNeurons,numTrainData);tempT.zero();for (int i = 0; i < numTrainData; i++){int j = 0;for (j = 0; j < NumberofOutputNeurons; j++){if (label[j] == T.get(0, i))break;}tempT.set(j, i, 1);}T = newDenseMatrix(NumberofOutputNeurons,numTrainData); //T=temp_T*2-1;for (int i = 0; i < NumberofOutputNeurons; i++){for (int j = 0; j < numTrainData; j++)T.set(i, j, tempT.get(i, j)*2-1);}transT = newDenseMatrix(numTrainData,NumberofOutputNeurons);T.transpose(transT);}long start_time_train = System.currentTimeMillis();BiasofHiddenNeurons = (DenseMatrix)Matrices.random(NumberofHiddenNeurons, 1);DenseMatrix tempH = newDenseMatrix(NumberofHiddenNeurons, numTrainData);InputWeight.mult(P, tempH);//DenseMatrix ind = new DenseMatrix(1, numTrainData);DenseMatrix BiasMatrix = newDenseMatrix(NumberofHiddenNeurons, numTrainData);for (int j = 0; j < numTrainData; j++) {for (int i = 0; i < NumberofHiddenNeurons; i++) {BiasMatrix.set(i, j, BiasofHiddenNeurons.get(i, 0));}}tempH.add(BiasMatrix);DenseMatrix H = new DenseMatrix(NumberofHiddenNeurons, numTrainData);if(func.startsWith("sig")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTrainData; i++) {double temp = tempH.get(j, i);temp = 1.0f/ (1 + Math.exp(-temp));H.set(j, i, temp);}}}else if(func.startsWith("sin")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTrainData; i++) {double temp = tempH.get(j, i);temp = Math.sin(temp);H.set(j, i, temp);}}}else if(func.startsWith("hardlim")){}else if(func.startsWith("tribas")){}else if(func.startsWith("radbas")){}DenseMatrix Ht = newDenseMatrix(numTrainData,NumberofHiddenNeurons);H.transpose(Ht);Inverse invers = new Inverse(Ht);DenseMatrix pinvHt = invers.getMPInverse();OutputWeight = new DenseMatrix(NumberofHiddenNeurons, NumberofOutputNeurons);pinvHt.mult(transT, OutputWeight);long end_time_train = System.currentTimeMillis();TrainingTime = (end_time_train -start_time_train)* 1.0f/1000;DenseMatrix Yt = newDenseMatrix(numTrainData,NumberofOutputNeurons);Ht.mult(OutputWeight,Yt);Y = new DenseMatrix(NumberofOutputNeurons,numTrainData);Yt.transpose(Y);if(Elm_Type == 0){double MSE = 0;for (int i = 0; i < numTrainData; i++) {MSE += (Yt.get(i, 0) - transT.get(i, 0))*(Yt.get(i, 0) - transT.get(i, 0));}TrainingAccuracy = Math.sqrt(MSE/numTrainData);}else if(Elm_Type == 1){float MissClassificationRate_Training=0;for (int i = 0; i < numTrainData; i++) {double maxtag1 = Y.get(0, i);int tag1 = 0;double maxtag2 = T.get(0, i);int tag2 = 0;for (int j = 1; j < NumberofOutputNeurons; j++) {if(Y.get(j, i) > maxtag1){maxtag1 = Y.get(j, i);tag1 = j;}if(T.get(j, i) > maxtag2){maxtag2 = T.get(j, i);tag2 = j;}}if(tag1 != tag2)MissClassificationRate_Training ++;}TrainingAccuracy = 1 -MissClassificationRate_Training* 1.0f/numTrainData;}}public void test(String TestingData_File){try {test_set = loadmatrix(TestingData_File);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}numTestData = test_set.numRows();DenseMatrix ttestT = new DenseMatrix(numTestData, 1);DenseMatrix ttestP = new DenseMatrix(numTestData, NumberofInputNeurons);for (int i = 0; i < numTestData; i++) {ttestT.set(i, 0, test_set.get(i, 0));for (int j = 1; j <= NumberofInputNeurons; j++)ttestP.set(i, j-1, test_set.get(i, j));}testT = new DenseMatrix(1,numTestData);testP = newDenseMatrix(NumberofInputNeurons,numTestData);ttestT.transpose(testT);ttestP.transpose(testP);long start_time_test = System.currentTimeMillis();DenseMatrix tempH_test = newDenseMatrix(NumberofHiddenNeurons, numTestData);InputWeight.mult(testP, tempH_test);DenseMatrix BiasMatrix2 = newDenseMatrix(NumberofHiddenNeurons, numTestData);for (int j = 0; j < numTestData; j++) {for (int i = 0; i < NumberofHiddenNeurons; i++) {BiasMatrix2.set(i, j, BiasofHiddenNeurons.get(i, 0));}tempH_test.add(BiasMatrix2);DenseMatrix H_test = newDenseMatrix(NumberofHiddenNeurons, numTestData);if(func.startsWith("sig")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTestData; i++) {double temp = tempH_test.get(j, i);temp = 1.0f/ (1 + Math.exp(-temp));H_test.set(j, i, temp);}}}else if(func.startsWith("sin")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTestData; i++) {double temp = tempH_test.get(j, i);temp = Math.sin(temp);H_test.set(j, i, temp);}}}else if(func.startsWith("hardlim")){}else if(func.startsWith("tribas")){}else if(func.startsWith("radbas")){}DenseMatrix transH_test = newDenseMatrix(numTestData,NumberofHiddenNeurons);H_test.transpose(transH_test);DenseMatrix Yout = newDenseMatrix(numTestData,NumberofOutputNeurons);transH_test.mult(OutputWeight,Yout);DenseMatrix testY = newDenseMatrix(NumberofOutputNeurons,numTestData);Yout.transpose(testY);long end_time_test = System.currentTimeMillis();TestingTime = (end_time_test -start_time_test)* 1.0f/1000;//REGRESSIONif(Elm_Type == 0){double MSE = 0;for (int i = 0; i < numTestData; i++) {MSE += (Yout.get(i, 0) -testT.get(0,i))*(Yout.get(i, 0) - testT.get(0,i));}TestingAccuracy = Math.sqrt(MSE/numTestData);}//CLASSIFIERelse if(Elm_Type == 1){DenseMatrix temptestT = newDenseMatrix(NumberofOutputNeurons,numTestData);for (int i = 0; i < numTestData; i++){int j = 0;for (j = 0; j < NumberofOutputNeurons; j++){if (label[j] == testT.get(0, i))break;}temptestT.set(j, i, 1);}testT = newDenseMatrix(NumberofOutputNeurons,numTestData);for (int i = 0; i < NumberofOutputNeurons; i++){for (int j = 0; j < numTestData; j++)testT.set(i, j, temptestT.get(i, j)*2-1);}float MissClassificationRate_Testing=0;for (int i = 0; i < numTestData; i++) {double maxtag1 = testY.get(0, i);int tag1 = 0;double maxtag2 = testT.get(0, i);int tag2 = 0;for (int j = 1; j < NumberofOutputNeurons; j++) { if(testY.get(j, i) > maxtag1){maxtag1 = testY.get(j, i);tag1 = j;}if(testT.get(j, i) > maxtag2){maxtag2 = testT.get(j, i);tag2 = j;}}if(tag1 != tag2)MissClassificationRate_Testing ++;}TestingAccuracy = 1 -MissClassificationRate_Testing* 1.0f/numTestData;}}public double[] testOut(double[][] inpt){test_set = new DenseMatrix(inpt);return testOut();}public double[] testOut(double[] inpt){test_set = new DenseMatrix(new DenseVector(inpt));return testOut();}//Output numTestData*NumberofOutputNeuronsprivate double[] testOut(){numTestData = test_set.numRows();NumberofInputNeurons = test_set.numColumns()-1;DenseMatrix ttestT = new DenseMatrix(numTestData, 1);DenseMatrix ttestP = new DenseMatrix(numTestData, NumberofInputNeurons);for (int i = 0; i < numTestData; i++) {ttestT.set(i, 0, test_set.get(i, 0));for (int j = 1; j <= NumberofInputNeurons; j++)ttestP.set(i, j-1, test_set.get(i, j));}testT = new DenseMatrix(1,numTestData);testP = newDenseMatrix(NumberofInputNeurons,numTestData);ttestT.transpose(testT);ttestP.transpose(testP);DenseMatrix tempH_test = newDenseMatrix(NumberofHiddenNeurons, numTestData);InputWeight.mult(testP, tempH_test);DenseMatrix BiasMatrix2 = newDenseMatrix(NumberofHiddenNeurons, numTestData);for (int j = 0; j < numTestData; j++) {for (int i = 0; i < NumberofHiddenNeurons; i++) {BiasMatrix2.set(i, j, BiasofHiddenNeurons.get(i, 0));}}tempH_test.add(BiasMatrix2);DenseMatrix H_test = newDenseMatrix(NumberofHiddenNeurons, numTestData);if(func.startsWith("sig")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTestData; i++) {double temp = tempH_test.get(j, i);temp = 1.0f/ (1 + Math.exp(-temp));H_test.set(j, i, temp);}}}else if(func.startsWith("sin")){for (int j = 0; j < NumberofHiddenNeurons; j++) { for (int i = 0; i < numTestData; i++) {double temp = tempH_test.get(j, i);temp = Math.sin(temp);H_test.set(j, i, temp);}}}else if(func.startsWith("hardlim")){}else if(func.startsWith("tribas")){}else if(func.startsWith("radbas")){}DenseMatrix transH_test = newDenseMatrix(numTestData,NumberofHiddenNeurons);H_test.transpose(transH_test);DenseMatrix Yout = newDenseMatrix(numTestData,NumberofOutputNeurons);transH_test.mult(OutputWeight,Yout);double[] result = new double[numTestData];if(Elm_Type == 0){for (int i = 0; i < numTestData; i++)result[i] = Yout.get(i, 0);}else if(Elm_Type == 1){for (int i = 0; i < numTestData; i++) {int tagmax = 0;double tagvalue = Yout.get(i, 0);for (int j = 1; j < NumberofOutputNeurons; j++) {if(Yout.get(i, j) > tagvalue){tagvalue = Yout.get(i, j);tagmax = j;}}result[i] = tagmax;}}return result;}public float getTrainingTime() {return TrainingTime;}public double getTrainingAccuracy() {return TrainingAccuracy;public float getTestingTime() {return TestingTime;}public double getTestingAccuracy() {return TestingAccuracy;}public int getNumberofInputNeurons() {return NumberofInputNeurons;}public int getNumberofHiddenNeurons() {return NumberofHiddenNeurons;}public int getNumberofOutputNeurons() {return NumberofOutputNeurons;}public DenseMatrix getInputWeight() {return InputWeight;}public DenseMatrix getBiasofHiddenNeurons() {return BiasofHiddenNeurons;}public DenseMatrix getOutputWeight() {return OutputWeight;}//for predicting a data file based on a trained model.public void testgetoutput(String filename) throws IOException {try {test_set = loadmatrix(filename);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}numTestData = test_set.numRows();NumberofInputNeurons = test_set.numColumns() - 1;double rsum = 0;double []actual = new double[numTestData];double [][]data = newdouble[numTestData][NumberofInputNeurons];for (int i = 0; i < numTestData; i++) {actual[i] = test_set.get(i, 0);for (int j = 0; j < NumberofInputNeurons; j++) data[i][j] = test_set.get(i, j+1);}double[] output = testOut(data);BufferedWriter writer = new BufferedWriter(new FileWriter(new File("Output")));for (int i = 0; i < numTestData; i++) {writer.write(String.valueOf(output[i]));writer.newLine();if(Elm_Type == 0){rsum += (output[i] - actual[i])*(output[i] - actual[i]);}if(Elm_Type == 1){if(output[i] == actual[i])rsum ++;}}writer.flush();writer.close();if(Elm_Type == 0)System.out.println("Regression GetOutPut RMSE: "+Math.sqrt(rsum* 1.0f/numTestData));else if(Elm_Type == 1)System.out.println("Classfy GetOutPut Right:"+rsum*1.0f/numTestData);}}。
Extremelearningmachine(ELM)到底怎么样,有没有做的前途?

Extremelearningmachine(ELM)到底怎么样,有没有做的前途?【WeicongLiu的回答(20票)】:利益相关:我本科时候做过这个,发过两篇ELM的会议,其中一篇被推荐到某不知名SCI期刊。
不过读了phd之后就不做了。
我觉得做ELM这些人最大的问题在于:1. 喜欢把以前SVM上曾经有过的一些idea直接套用。
比如加入一些正则项,或者考虑imbalanced dataset,或者ensemble几个ELM,就可以将原算法改头换面发个新paper。
因为以前SVM上这类paper太多了,照搬的话就可以写出很多很多类似的paper。
大家可以浏览一下ELM历届会议的list,相信会有体会。
这样的paper,贡献会比较局限;2. 很多做ELM的paper直接把ELM用在某回归/分类的应用上,跟SVM比,因为速度快,所以也算是有贡献,所以也就发出来了。
不过实际上,这样的贡献还是很有限的,在那些问题上,1秒和0.01秒其实都没啥差别;3 做实验太喜欢用比较基础的数据集了,比如UCI,Yale B这种。
包括之前黄老师他们做的ELM Auto Encoder,用的也只是MNIST数据集;4 主要贡献大部分都是黄老师他们自己做出来的,其他人的贡献有限。
所以我的感觉是,做ELM可以发paper,但是很难在理论和应用上有突破进展。
当然我也只是个普通学生,从我自己的角度回答下,算是抛砖引玉。
我本人对黄老师非常尊敬,本科时候数次发邮件向他请教问题,他都非常耐心地给出了详细的解答。
【张明仁的回答(10票)】:ELM神经网络与传统方法确实区别比较明显。
在优化论中,随机性的引入通常有助于增强算法的泛化能力;而ELM神经网络随机化隐含层的做法,虽然大幅提高了运算速度,但却不可避免地造成了过拟合的隐患。
同时,所谓在理论上证明的ELM神经网络的表达能力,也不过是线性方程组的简单结论,从训练上讲与SVM、核回归等方法无本质差异,因此至少在理论上我不认为ELM有什么大的贡献和创新所在。
极限学习机

2 图说极限学习机原理
其实说到机器学习的学习,最先被介绍的基本都是感知机算法,但是仔细一想,其实也可以
从极限学习机的角度进行最开始的拓展性介绍 ELM 是一种新型的快速学习算法, 对于单隐层神经网络, ELM 可以随机初始化输入权重和偏 置并得到的处理方便带入到 lagrange 方程的模型之中以便进行进一 步的求出局部极值的处理,又是万恶的 Lagrange
关于 ELM 极限学习机
0 引言
极限学习机不是一个新的东西,只是在算法(方法)上有新的内容。在神经网络结构上,就 是一个前向传播的神经网络,结构上也没有什么大的创新,感觉就是 BP 神经网络的经典结 构的升级
也有比较明显的创新点,比较值得拿来讨论的如下: 1)输入层和隐含层的连接权值、隐含层的阈值可以随机设定,且设定完后不用再调整。这 和 BP 神经网络不一样,BP 需要不断反向去调整权值和阈值。因此这里就能减少一半的运算 量了。不过在 BP 网络中其实初始化阈值与权值也是在比较靠前的时候随机化拟定的 2) 隐含层和输出层之间的连接权值β不需要迭代调整, 而是通过解方程组方式一次性确定。 研究表明,通过这样的规则,模型的泛化性能很好,速度提高了不少。 一言概之,ELM 最大的特点就是对于传统的神经网络,尤其是单隐层前馈神经网络(SLFNs), 在保证学习精度的前提下比传统的学习算法速度更快。
1 关于极限学习机的概念
极限学习机(Extreme Learning Machine) ELM,是由黄广斌提出来的求解单隐层神经网络的算 法。 ELM 最大的特点是对于传统的神经网络, 尤其是单隐层前馈神经网络(SLFNs), 在保证学习精 度的前提下比传统的学习算法速度更快。不过收敛的速度快不代表效果一定就好
极限学习机简介

极限学习机简介
在 Deep Learning 大行其道热度不减时,有机会接触到了极限学习机(Extreme Learning Machine,ELM)。
这个算法是新加坡南洋理工大学的黄广斌教授提出来的,idea 始于 2003 年,2004 年正式发表文章。
这种算法是针对SLFNs (即含单个隐藏层的前馈型神经网络)的监督型学习算法,其主要思想是:输入层与隐藏层之间的权值参数,以及隐藏层上的偏置向量参数是 once for all 的(不需要像其他基于梯度的学习算法一样通过迭代反复调整刷新),求解很直接,只需求解一个最小范数最小二乘问题(最终化归成求解一个矩阵的Moore-Penrose 广义逆问题)。
因此,该算法具有训练参数少、速度非常快等优点(总觉得 ELM 中的 Extreme 指的是 extreme fast,哈哈)。
接下来的若干年,黄教授带领的团队在此基础上又做了更多的发展,例如,将 ELM 推广到复数域,提出基于 ELM 的在线时序算法等等。
本文主要对最基本的 ELM 算法做一个简要介绍。
作者: peghoty
出处: /peghoty/article/details/9277721 欢迎转载/分享, 但请务必声明文章出处.。
极限学习机(ELM)网络结构调整方法综述

极限学习机(ELM)网络结构调整方法综述
翟敏;张瑞;王宇
【期刊名称】《西安文理学院学报(自然科学版)》
【年(卷),期】2014(017)001
【摘要】从原始ELM算法和增长结构ELM算法(I-ELM)的基本思想与基本理论出发,分析其优点与不足,概括基于不同角度所改进的网络结构调整方法,包括结构增长型算法、结构递减型算法和自适应型算法三大方面.最终对极限学习机(ELM)中网络结构的各种调整方法进行综述,为相关研究者提供该研究方向的发展历史和最新结果.
【总页数】6页(P1-6)
【作者】翟敏;张瑞;王宇
【作者单位】西北大学数学系,西安710127;西北大学数学系,西安710127;西北大学数学系,西安710127
【正文语种】中文
【中图分类】O29
【相关文献】
1.基于深度极限学习机的危险源识别算法HIELM [J], 李诗瑶;周良;刘虎
2.极限学习机 ELM 在图像分割中的应用研究 [J], 田钧;赵雪章
3.基于极限学习机(ELM)的视线落点估计方法 [J], 朱博;张天侠
4.改进序列前向选择法(ISFS)和极限学习机(ELM)相结合的SPC控制图模式识别方
法 [J], 张宇波;蔺小楠
5.核极限学习机的在线状态预测方法综述 [J], 戴金玲;吴明辉;刘星;李睿峰
因版权原因,仅展示原文概要,查看原文内容请购买。
极限学习机(ELM)网络结构调整方法综述

Vo l _ l 7 No . 1
J a n .2 0 1 4
文章 编 号 : 1 00 1 - 0 0 0 1 - 0 6
极 限学 习机 ( E L M) 网络 结 构 调 整 方 法 综 述
翟 敏, 张 瑞, 王 宇
( 西北大学 数 学系, 西安 7 1 0 1 2 7 )
n e t w o r k s t r u c t u r e a d j u s t m e n t f r o m v a i r o u s p e r s p e c t i v e s ,w h i c h i n c l u d e s t r u c t u r a l g r o w t h a l g o -
Abs t r a c t: We g i v e a n a n a l y s i s o f t h e a d v a n t a g e s a n d d i s a d v a n t a g e s o f o r i g i na l ELM a n d I— ELM a l g o r i t h ms b y a d d r e s s i n g t he i r b a s i c t h e o ie r s .W e h a v e e x a mi n e d t h e i mp r o v e d me t h o d s o f
机产生 , 最后通过最小二乘法直接计算输出层权值. E L M 算法无需迭代 , 因而其学习速度较快 , 并且具 有很 好 的泛化 能力 .
1 E L M算法简介
给定 N个不 同的样本 ( , t j ) ∈ R × R , 对于含有 N个 隐节点且激活 函数为 g ( ) 的单 隐层前向神
extremelearnmachines極限學習機

_create_random_layer() (hidden_layer = RandomLayer)
GenELMClassifier (继承BaseELM) Method: decision_function(X)
ELMClassifier (继承ELMRegressor)
MLPRandomLayer (继承RandomLayer)
Alpha = 1
RBFRandomLayer (继承RandomLayer)
Alpha = 0
input_activation = alpha * mlp_activation + (1-alpha) * rbf_activation mlp_activation(x) = dot(x, weights) + bias rbf_activation(x) = rbf_width * ||x - center||/radius
plot_elm_comparison.py
First Ime Second Ime
总结
• 基础知识 • 整个程序的结构 • Sklearn库
Any Question ?
Thanks for listening
References:
1. 简单易学的机器学习算法——极限学习机hLp:///google19890102/arIcle/details/ 18222103
Extreme Learn Machines (极限学习机)
Python 实现
Outline
1. ELM简介 2. ELM原理 3. Python实现 4. 总结
ELM简介
极限学习机(Extreme Learning Machine) ELM,是由黄广斌教授提出来的求解单隐层神经 网络的算法。ELM最大的特点是对于传统的神经网络,尤其是单隐层前馈神经网络,在 保证学习精度的前提下比传统的学习算法速度更快。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
2. 介绍
正如 Huang 等[6]指出:“一般来讲,‘超限’指超过传统人工学习方法的局限, 并向类脑学习靠拢。超限学习机的提出,是为了打破传统人工学习方法和生物学习机 制之间的屏障。‘超学习机’基于神经网络泛化理论,控制理论,矩阵理论和线性 系统理论,代表了一整套不需要调整隐层神经元的机器学习理论。”
定理 2 (分类能力[23])给定任何非常数分段连续函数作为激活函数,若调整隐 层参数可让单层前馈网络逼近任何连续的目标函数 f(x),那么这个拥有随机隐层映射 h(x)的单层前馈网络可以分割具有任何形状的不连通区域。
7. 单隐层前馈网络和多隐层前馈网络
在没有完全解决单隐层问题时在超限学习机中直接引入多隐层结构会比较困难。 所以在过去的十年中,大多数的超限学习机研究都注重“通用”单隐层前馈网络 (SLFNs)。
理论,控制理论,矩阵理论和线性系统理论。随机地生成隐层节点是“不需要调整隐 层神经元”的其中一种常用方法;与此同时,也有很多其他方法,例如核方法[6,23], 奇异值分解(SVD)和局部感受域[8]。我们相信超限学习机反映了某些生物学习机制 的实际情况。它的机器学习效能在 2004 年被确认[24],它的万能逼近性(对于“通用 单隐层前馈网络”,其隐层节点可以是由一些节点构成的子网络,并/或拥有基本上任 何类型的非线性分段连续激活函数的神经元(确切数学模型/公式/形状未知))在 2006 到 2008 年[5,25,26]被非常严格地证明。它的实际生物证据在 2011 到 2013 年 [27‐ 30] 接着出现。
数据压缩、特征学习、聚类、回归和分类是机器学习和机器智能的基础。超限学 习机的目标是在相同超限学习机架构中实现这五种基本学习操作(参见图 1)。
图 1 超限学习机的基础操作和角色。感谢匿名网络设计师提供此机器人图片。
4. 超限学习机理论 尽管在 1950 到 1990 年代,人们进行了一些随机 sigmoid 隐层神经元和/或径向基 函数神经元的尝试,除了 RVFL[34]以外,这些尝试并没有真正的成功和普及应用。原 因如下:
定理 1 (万能逼近能力[5,25,26])给定任何非常数分段连续函数作为激活函数,
若调整隐层参数可让单层前馈网络逼近任何连续的目标函数 f(x),那么
就可
以根据任何连续的概率分布生成,并且可以找到合适的输出权值 使
lim ∑
→
0以概率 1 的可能性成立。
6. 分类能力
另外,超限学习理论还证明了拥有随机隐层神经元的各类型网络的分类能力。这 种理论并没有被早期的工作研究。
5. 万能逼近能力
严格来讲,没有一种早期工作(比如 Baum[31],Schmidt 等[1]和 RVFL[2,32])在理 论上解释了随机隐层节点能否用于 sigmoid 或径向基函数网络上,自然就不包括由超限 学习理论覆盖的广泛神经网络类型。Lowe[35]的径向基函数网络并没有包括随机影响 因子,尽管其径向基函数节点的中心是随机产生的。人们还是需要根据不同应用来调 整其影响因子。换言之,这些网络[35]使用的是半随机的径向基函数节点。其详细分析 请参见 Huang[3]。
为了更清楚的理解其本质,我们从其哲学观,理论,网络结构,网络神经元类型, 学习目标和算法等角度分析超限学习机。
3. 超限学习机的信念、哲学观和目标
超限学习机的研究开始于我们对生物学习和神经网络泛化理论[14]的直观思考。进 一步来讲,超限学习机发展的基础是 Frank Rsenblatt 的多层“感知机”[9],支持向量 机[15],最小二乘支持向量机[16],傅里叶级数,线性系统,数值方法和矩阵理论等, 以及必要的衍生。
定义 [5,25,26] 给定一个隐层映射 h(x) = [h1(x), …, hL(x)],如果所有的隐层节点参数 都是根据一个任意连续的抽样分布生成的,那么该映射被称为超限学习随机特征映射。 其中,hi(x) = Gi(ai,bi,x), i=1,…,L(L 是隐层神经元数)。
不同的隐层节点允许有不同的激活函数 Gi。在大多数应用中,为了简单起见,对 所有隐层节点使用相同的激活函数,即对于所有 i, j=1,…L,Gi=Gj。
什么是超限学习机1
Guang‐Bin Huang
School of Electrical and Electronic Engineering, Nanyang Technological University, Singapore egbhuang@.sg
1. 摘要
近年来,超限学习机(Extreme Learning Machine, ELM)作为一种新兴的机器学习 方法,在全世界许多研究者的不断研究下,已经成为了一个热门研究方向。超限学习 机主要有以下四个特点。(1)超限学习理论探讨了一个 60 年来在神经网络、机器学 习和神经科学领域悬而未决的问题:在学习过程中隐层节点/神经元是否需要调整。与 常识和传统神经网络不同,该理论证明,对于大多数神经网络和学习算法(如隐层激 活为函数傅里叶级数,生物学习等),隐层节点/神经元不需要迭代式的调整,而早期 工作并没有提供随机隐层节点前馈神经网络的理论基础。(2)超限学习机既属于通用 单隐层前馈网络,又属于多隐层前馈网络(包括生物神经网络)。(3)超限学习机的 相同构架可用作特征学习,聚类,回归和(二类/多类)分类问题。(4)相比于超限 学习机,支持向量机(SVM)和最小二乘支持向量机(LS‐SVM)趋向于得到次优解。 支持向量机和最小二乘支持向量机也没考虑多层前馈网络中隐层的特征表征。
络,它包含很多随机连接,却能稳定的执行那些需要有完美电路才能执行的功能”?
在 2003 年以前,人们做了很多努力,但以上问题并没有解决。最终,我们发现问 题的关键“死结”在于:
1) Minsky 和 Papert[17]的反例说明隐层是必要的。 2) 早期的神经网络万能逼近理论(例如[21,22])也建立在学习过程中隐层神经元必须
1) 我们真的需要花费这么多人力物力来寻找这种需要人工调整隐层参数的学习算法, 并应用于不同的神经网络中吗?很明显,在生物大脑中没有调整参数的“小精灵”。
2) 我们真的需要不同的学习算法来使不同类型的神经网络可以有特征学习,聚类,回 归和分类能力吗?
3) 为什么生物大脑比那些集成人工学习算法的机器/电脑更加“高效”和“智能”? 4) 我们是否能解决 John von Neumann 的困惑[19,20]:为什么“一个不完美的神经网
超限学习机不仅面向“通用” 单隐层前馈网络,它还面向“通用” 多隐层前馈网 络,其中一个节点可以是由其它隐层节点组成的子网络[5,8,26]。单隐层超限学习机也 包括大多数类型的神经网络,包括 sigmoid 网络和径向基函数(RBF)网络(细节请参 见“‘通用’单隐层前馈网络(SLFNs)”章节)。
不断调整的假设之上。 3) 所以,自然可知,人工神经网络中的隐层神经元需要不断调整。
为了解决以上的问题,我们必须解决这些关键“死结”,即对于大多数类型的神 经网络(人工神经网络或人们未知其结构和神经模型的生物神经网络),隐层神经元 很重要,但无需调整。
我们在机器学习和生物学习领域中的这种信念和哲学观最终使我们提出一种新方 法,称为超限学习机(ELMs)及其相关理论。正如 Huang 等[6]强调,“超限”指超过 传统人工学习方法的局限,并向类脑学习靠拢。超限学习机是为了打破传统人工学习 方法和生物学习机制之间的屏障。超限学习机代表一整套机器学习方法(包括单隐层 前馈网络和多隐层前馈网络),它们不需要调整隐层神经元,同时符合神经网络泛化
7.1 “广义”单隐层前馈网络(SLFNs)
Schmidt 等[1]的研究注重 sigmoid 网络,而 Pao 等[32]的研究侧重 RVFL(使用 simoid 或径向基函数)。这两者都使用严格的标准单隐层结构,所以不是超限学习机 中研究的“通用”单隐层前馈网络(SLFNs)。Schmidt 等[1]提出的随机权值前馈网络 类 似 支 持 向 量 机 [15] , 在 隐 层 有 一 个 偏 移 量 来 吸 收 其 系 统 误 差 。 这 是 由 于 其 在 随 机 sigmoid 节点情况下的万能逼近性并没有被证明。
对比之下,超限学习机理论揭示了绝大多数使用非线性分段连续激活函数(包括 前期工作用到的 sigmoid 函数和径向基函数,也包括小波函数,傅里叶级数和生物神经 元)的隐层节点都可用于超限学习机,并且该网络有万能逼近能力[5,25,26]。不同于 RVFL 证明 [32] 中用到的半随机 sigmoid 和径向基函数节点,超限学习理论中的随机节 点是指所有的隐层节点都是随机生成,且与训练样本独立,例如对可加性的隐层节点, 输入权值 ai 和偏移 bi 都随机产生,对径向基函数网络,中心 ai 和影响因子 bi 都随机产 生,傅里叶级数和小波函数中的参数随机产生等。超限学习理论第一次揭示了在各种 类型的神经网络中,也包括在生物学习机制中,所以隐层节点/神经元的生成可以独立 于训练样本,也可以独立于其他节点[5,6,25,26]。
Baum[31]和 Schmidt 等[1]仅注重使用特定网络结构来处理经验性的、人工合成的 小型数据(可看作超限学习机的特例)。据我们所知,这些早期工作并没有理论分析 和严格理论证明。尽管简单地讲,Igelnik 和 Pao[32]在[4,8]中尝试证明了 RVFL 的万能逼 近能力。但是,其证明仅适用于使用半随机 sigmoid 和径向基函数隐层节点的情况,即 输入权值 ai 是随机生成的,而隐层节点偏移 bi 是根据训练样本 xi 和输入权值 ai 来计算 得到(详情请参见 Huang 等[4])。