极限学习机 订阅
极限学习机(Extreme Learning Machine, ELM)或“超限学习机”是一类基于前馈神经网络(Feedforward Neuron Network, FNN)构建的机器学习系统或方法,适用于监督学习和非监督学习问题 [1]  。ELM在研究中被视为一类特殊的FNN,或对FNN及其反向传播算法的改进,其特点是隐含层节点的权重为随机或人为给定的,且不需要更新,学习过程仅计算输出权重 [2]  。传统的ELM具有单隐含层,在与其它浅层学习系统,例如单层感知机(single layer perceptron)和支持向量机(Support Vector Machine, SVM)相比较时,被认为在学习速率和泛化能力方面可能具有优势 [2]  。ELM的一些改进版本通过引入自编码器构筑或堆叠隐含层获得了深度结构,能够进行表征学习 [3-4]  。ELM的应用包括计算机视觉和生物信息学,也被应用于一些地球科学、环境科学中的回归问题 [1]  。 展开全文
极限学习机(Extreme Learning Machine, ELM)或“超限学习机”是一类基于前馈神经网络(Feedforward Neuron Network, FNN)构建的机器学习系统或方法,适用于监督学习和非监督学习问题 [1]  。ELM在研究中被视为一类特殊的FNN,或对FNN及其反向传播算法的改进,其特点是隐含层节点的权重为随机或人为给定的,且不需要更新,学习过程仅计算输出权重 [2]  。传统的ELM具有单隐含层,在与其它浅层学习系统,例如单层感知机(single layer perceptron)和支持向量机(Support Vector Machine, SVM)相比较时,被认为在学习速率和泛化能力方面可能具有优势 [2]  。ELM的一些改进版本通过引入自编码器构筑或堆叠隐含层获得了深度结构,能够进行表征学习 [3-4]  。ELM的应用包括计算机视觉和生物信息学,也被应用于一些地球科学、环境科学中的回归问题 [1]  。
信息
外文名
Extreme Learning Machine, ELM
提出时间
2004年
提出者
Guang-Bin Huang,Qin-Yu Zhu,Chee-Kheong Siew
类    型
机器学习算法,神经网络算法
中文名
极限学习机
学    科
人工智能
应    用
计算机视觉,生物信息学,环境科学
极限学习机历史
极限学习机(Extreme Learning Machine, ELM)在2004年由南洋理工大学的Guang-Bin Huang、Qin-Yu Zhu和Chee-Kheong Siew提出,并发表于当年的IEEE国际交互会议(IEEE International Joint Conference)中,目的是为了对反向传播算法(Backward Probagation, BP)进行改进以提升学习效率低并简化学习参数的设定 [5-6]  。2006年,ELM原作者在对算法进行了进一步的测评后,将结论发表至Neurocomputing并得到了关注 [2]  。ELM提出时是为监督学习问题而设计的,但在随后的研究中,其应用范围得到了推广,包括以聚类为代表的非监督学习问题 [7]  ,并出现了具有表征学习能力的变体和改进算法 [8]  。
收起全文
精华内容
参与话题
问答
  • 极限学习机

    2018-06-07 12:18:35
    为了解决人工神经网络训练时间长的缺点,新加坡南洋理工大学教授黄广斌提出了一种全新的单隐藏层前馈神经网络-极限学习机(extreme learning machine ,ELM),该神经网络能够以极快的学习速度达到较好的泛化性能,...
  • 摘要:极限学习机(ELM)是当前一类非常热门的机器学习算法,被用来训练单隐层前馈神经网络(SLFN)。本篇博文尽量通俗易懂地对极限学习机的原理进行详细介绍,之后分析如何用MATLAB实现该算法并对代码进行解释。...
    图片展示

    摘要:极限学习机(ELM)是当前一类非常热门的机器学习算法,被用来训练单隐层前馈神经网络(SLFN)。本篇博文尽量通俗易懂地对极限学习机的原理进行详细介绍,之后分析如何用MATLAB实现该算法并对代码进行解释。本文主要内容如下:

    点击跳转至全部文件下载页


    1. 前言

        ELM自2004年南洋理工大学的黄广斌教授提出相关概念以来一直争议不断,但每年相关论文层出不穷,在过去的十年里其理论和应用被广泛研究。如果您想深入学习和了解ELM的原理,博主建议可在ScienceDirect的数据库中检索ELM相关论文,里面有众多优质论文其理解和表述将帮助你更准确了解ELM的内在原理。
        博主对于极限学习机(Extreme Learning Machine, ELM)的学习和研究已一年多,目前ELM相关两篇SCI论文已发表。后续转深度学习方向继续研究,这里就ELM作一个简单整理并给出实现代码,也希望对刚接触的朋友能够有所帮助。


    2. 算法的原理

        极限学习机(ELM)用来训练单隐藏层前馈神经网络(SLFN)与传统的SLFN训练算法不同,极限学习机随机选取输入层权重和隐藏层偏置,输出层权重通过最小化由训练误差项和输出层权重范数的正则项构成的损失函数,依据Moore-Penrose(MP)广义逆矩阵理论计算解析求出。理论研究表明,即使随机生成隐藏层节点,ELM仍保持SLFN的通用逼近能力。在过去的十年里,ELM的理论和应用被广泛研究,从学习效率的角度来看,极限学习机具有训练参数少、学习速度快、泛化能力强的优点。

        简单来说,极限学习机(ELM)模型的网络结构与单隐层前馈神经网络(SLFN)一样,只不过在训练阶段不再是传统的神经网络中屡试不爽的基于梯度的算法(后向传播),而采用随机的输入层权值和偏差,对于输出层权重则通过广义逆矩阵理论计算得到。所有网络节点上的权值和偏差得到后极限学习机(ELM)的训练就完成了,这时测试数据过来时利用刚刚求得的输出层权重便可计算出网络输出完成对数据的预测。

        ELM的理论推导比较简单,但是需要知道一些线性代数和矩阵论的知识,我会尽量写得简单一些,接下来就一起来推导一下吧。我们假设给定训练集{xi,tixiRD,tiRm,i=1,2,,N}\left\{\mathrm{x}_{i}, \mathrm{t}_{i} | \mathrm{x}_{i} \in \mathrm{R}^{D}, \mathrm{t}_{i} \in \mathrm{R}^{m}, i=1,2, \ldots, N\right\}(符号式表达,xi\mathrm{x}_{i}表示第ii个数据示例,ti\mathrm{t}_{i}表示第ii个数据示例对应的标记,集合代指所有训练数据),极限学习机的隐藏层节点数为 L,与单隐层前馈神经网络的结构一样,极限学习机的网络结构如下图所示:

    图片展示

        对于一个神经网络而言,我们完全可以把它看成一个“函数”,单从输入输出看就显得简单许多。很明显上图中,从左往右该神经网络的输入是训练样本集x\mathrm{x},中间有个隐藏层,从输入层到隐藏层之间是全连接,记隐藏层的输出为H(x)H(\mathrm{x}),那么隐藏层输出H(x)H(\mathrm{x})的计算公式如下。
    H(x)=[h1(x),,hL(x)](2.1)H(\mathrm{x})=\left[h_{1}(\mathrm{x}), \ldots, h_{L}(\mathrm{x})\right] \tag{2.1}     隐藏层的输出是输入乘上对应权重加上偏差,再经过一个非线性函数其所有节点结果求和得到。H(x)=[h1(x),,hL(x)]\mathrm{H}(\mathrm{x})=\left[h_{1}(\mathrm{x}), \ldots, h_{L}(\mathrm{x})\right]ELM非线性映射(隐藏层输出矩阵),hi(x)h_{i}(\mathrm{x})是第ii个隐藏层节点的输出。隐藏层节点的输出函数不是唯一的,不同的输出函数可以用于不同的隐藏层神经元。通常,在实际应用中,hi(x)h_{i}(\mathrm{x})用如下的表示:
    hi(x)=g(wi,bi,x)=g(wix+bi),wiRD,biR(2.2)h_{i}(\mathrm{x})=g\left(\mathrm{w}_{i}, b_{i}, \mathrm{x}\right)=g(\mathrm{w}_{i}\mathrm{x}+\mathrm{b}_{i}), \mathrm{w}_{i} \in \mathrm{R}^{D}, b_{i} \in R\tag{2.2}     其中g(wi,bi,x)g\left(\mathrm{w}_{i}, b_{i}, \mathrm{x}\right)wi\mathrm{w}_{i}bib_{i}是隐藏层节点参数)是激活函数,是一个满足ELM通用逼近能力定理的非线性分段连续函数,常用的有Sigmoid函数、Gaussian函数等。如我们可以使用Sigmoid函数,那么式(2.2)中的gg函数为g(x)=11+ex=exex+1(2.3)g(x)=\frac{1}{1+e^{-x}}=\frac{e^{x}}{e^{x}+1}\tag{2.3}(将wix+bi\mathrm{w}_{i}\mathrm{x}+\mathrm{b}_{i}代入xx即可),该函数图像如下图所示

    图片展示

        经过隐层后进入输出层,根据上面的图示和公式,那么用于“广义”的单隐藏层前馈神经网络ELM的输出是
    fL(x)=i=1Lβihi(x)=H(x)β(2.4)f_{L}(\mathrm{x})=\sum_{i=1}^{L} \boldsymbol{\beta}_{i} h_{i}(\mathrm{x})=\mathrm{H}(\mathrm{x}) \boldsymbol{\beta} \tag{2.4} 其中β=[β1,,βL]T\boldsymbol{\beta}=\left[\boldsymbol{\beta}_{1}, \ldots, \boldsymbol{\beta}_{L}\right]^{T}是隐藏层(LL个节点)与输出层(mm个节点,m1m \geq 1)之间的输出权重。至此神经网络从输入到输出的操作就是上面公式的计算过程。需要注意的是,目前为止上面公式中的未知量有w,b,β\mathrm{w}, \mathrm{b}, \boldsymbol{\beta},分别是隐藏层节点上的权值、偏差及输出权值。我们知道神经网络学习(或训练)的过程就是根据训练数据来调整神经元之间的权值以及偏差,而实际上学到的东西则蕴含在连接权值和偏差之中。接下来我们就要用ELM的机理来求解这三个值(ELM训练过程)。

        基本上,ELM训练SLFN分为两个主要阶段:(1)随机特征映射(2)线性参数求解

        第一阶段,隐藏层参数随机进行初始化,然后采用一些非线性映射作为激活函数,将输入数据映射到一个新的特征空间(称为ELM特征空间)。简单来说就是ELM隐层节点上的权值和偏差是随机产生的。随机特征映射阶段与许多现有的学习算法(如使用核函数进行特征映射的SVM、深度神经网络中使用限制玻尔兹曼机器(RBM)、用于特征学习的自动编码器/自动解码器)不同。ELM 中的非线性映射函数可以是任何非线性分段连续函数。在ELM中,隐藏层节点参数(wwbb)根据任意连续的概率分布随机生成(与训练数据无关),而不是经过训练确定的,从而致使与传统BP神经网络相比在效率方面占很大优势。

        经过第一阶段w,b\mathrm{w}, \mathrm{b}已随机产生而确定下来,由此可根据公式(2.1)和(2.2)计算出隐藏层输出HH。在ELM学习的第二阶段,我们只需要求解输出层的权值(β\beta)。为了得到在训练样本集上具有良好效果的β\beta,需要保证其训练误差最小,我们可以用Hβ\mathrm{H} \boldsymbol{\beta}是网络的输出,如公式(2.4))与样本标签TT求最小化平方差作为评价训练误差(目标函数),使得该目标函数最小的解就是最优解。即通过最小化近似平方差的方法对连接隐藏层和输出层的权重(β\beta)进行求解,目标函数如下:
    minHβT2,βRL×m(2.5)\min \|\mathrm{H} \boldsymbol{\beta}-\mathrm{T}\|^{2} , \boldsymbol{\beta} \in \mathbf{R}^{L \times m} \tag{2.5} 其中H是隐藏层的输出矩阵,T是训练数据的目标矩阵:
    H=[h(x1),...,h(xN)]T=[h1(x1)...hL(x1)...h1(xN)...hL(xN)],T=[t1T...tNT](2.6)H=[h(x_1),...,h(x_{N})]^{T}=\begin{bmatrix} h_1(x_1)&...&h_L(x_1) \\ & ... & \\ h_1(x_N) &...&h_L(x_N) \end{bmatrix},T=\begin{bmatrix} t_{1}^{T}\\ ... \\ t_{N}^{T} \end{bmatrix} \tag{2.6} 通过线代和矩阵论的知识可推导得公式(2.5)的最优解为:
    β=HT(2.7) \beta^{*}=\mathrm{H}^{\dagger} \mathrm{T} \tag{2.7} 其中H\mathrm{H}^{\dagger}为矩阵HMoore–Penrose广义逆矩阵。

        这时问题就转化为求计算矩阵HMoore–Penrose广义逆矩阵,该问题主要的几种方法有正交投影法、正交化法、迭代法和奇异值分解法(SVD)。当HTHH^{T}H为非奇异(可逆)时可使用正交投影法,这时可得计算结果是:
    H=(HTH)1HT\mathbf{H}^{\dagger}=\left(\mathbf{H}^{T} \mathbf{H}\right)^{-1} \mathbf{H}^{T}    然而有时候在应用时会出现HTHH^{T}H为奇异的(不可逆)情况,因此正交投影法并不能很好地应用到所有的情况。由于使用了搜索和迭代,正交化方法和迭代方法具有局限性。而奇异值分解(SVD)总是可以用来计算HHMoore–Penrose广义逆,因此用于ELM的大多数实现中。具体的求解过程涉及矩阵论的知识,而且在许多编程语言中都已封装了求解广义逆的可调用的函数,限于篇幅这里博主就不多展开了。至此训练部分全部完成,在测试时利用训练得到的结果便可预测结果。

        综合上面说的,对于训练单隐层前馈神经网络的极限学习机算法做出总结,算法如下所示:

    算法:极限学习机(ELM)
    输入
        数据集:{xi,tixiRD,tiRm,i=1,2,,N}\left\{\mathrm{x}_{i}, \mathrm{t}_{i} | \mathrm{x}_{i} \in \mathrm{R}^{D}, \mathrm{t}_{i} \in \mathrm{R}^{m}, i=1,2, \ldots, N\right\}
        隐层神经元数目:LL
        激活函数:g(.)g( .)
    输出
        输出权重:β\beta
        1.随机产生输入权重ww和隐层偏差bb
        2.计算隐藏层输出H=g(xω+b)\mathrm{H}=\mathrm{g}(\mathrm{x} * \boldsymbol{\omega}+\mathrm{b})
        3.采用式(2.7)计算输出层权重β\mathrm{\beta}

        其实以上的理论尚有不足之处,根据Bartlett理论,对于达到较小的训练误差的前馈神经网络,通常其权值范数越小,网络趋向于获得更好的泛化性能。为了进一步提高传统极限学习机的稳定性和泛化能力,可以在上面目标函数中增加权值范数的约束项来重新求解输出权重,因此提出了优化等式约束的极限学习机。除此之外后来还有许多文章在原有极限学习机的理论和算法上进行了改进,这里就不多介绍了有兴趣的可以了解一下。


    3. 算法程序实现

        数学中的符号语言可谓精简巧妙,其简洁之美不经间引人入胜,同时它的复杂又让人觉得自己知道的还很匮乏。作为工科的我数学基本功仅限于刚考研时的临阵磨枪,如今的研究生阶段接触了最优理论、统计分析和矩阵论的知识但自感尚不能得其万一。上面的算法推导是完成了,但不代表程序就能完整照上面的步骤实现了,毕竟理论和实际总是有差距的。

        其实ELM的程序代码早已开放,提供源码下载的网站:黄广斌老师的ELM资源主页,上面已经有了MATLABC++pythonJava的版本,使用起来也比较方便。这里博主就其中MATLAB的代码介绍下算法的程序实现,为方便初学者理解源码,我只是在其中的大部分代码中进行了注释,当然为避免个人理解的偏差建议可去官网查看英文源码。

    function [TrainingTime, TestingTime, TrainingAccuracy, TestingAccuracy] = ELM(TrainingData_File, TestingData_File, Elm_Type, NumberofHiddenNeurons, ActivationFunction)
    %% ELM 算法程序
    % 调用方式: [TrainingTime, TestingTime, TrainingAccuracy, TestingAccuracy] = elm(TrainingData_File, TestingData_File, Elm_Type, NumberofHiddenNeurons, ActivationFunction)
    %
    % 输入:
    % TrainingData_File     - 训练数据集文件名
    % TestingData_File      - 测试训练集文件名
    % Elm_Type              - 任务类型:0 时为回归任务,1 时为分类任务
    % NumberofHiddenNeurons - ELM的隐层神经元数目
    % ActivationFunction    - 激活函数类型:
    %                           'sig' , Sigmoidal 函数
    %                           'sin' , Sine 函数
    %                           'hardlim' , Hardlim 函数
    %                           'tribas' , Triangular basis 函数
    %                           'radbas' , Radial basis 函数
    % 输出: 
    % TrainingTime          - ELM 训练花费的时间(秒)
    % TestingTime           - 测试数据花费的时间(秒)
    % TrainingAccuracy      - 训练的准确率(回归任务时为RMSE,分类任务时为分类正确率)                       
    % TestingAccuracy       - 测试的准确率(回归任务时为RMSE,分类任务时为分类正确率)
    %
    % 调用示例(回归): [TrainingTime, TestingTime, TrainingAccuracy, TestingAccuracy] = ELM('sinc_train', 'sinc_test', 0, 20, 'sig')
    % 调用示例(分类): [TrainingTime, TestingTime, TrainingAccuracy, TestingAccuracy] = ELM('diabetes_train', 'diabetes_test', 1, 20, 'sig')
    
    
    %% 数据预处理
    
    % 定义任务类型
    REGRESSION=0;
    CLASSIFIER=1;
    
    % 载入训练数据集
    train_data=load(TrainingData_File);
    T=train_data(:,1)';                   % 第一列:分类或回归的期望输出
    P=train_data(:,2:size(train_data,2))';% 第二列到最后一列:不同数据的属性
    clear train_data;                     % 清除中间变量
    
    % 载入测试数据集
    test_data=load(TestingData_File);
    TV.T=test_data(:,1)';                  % 第一列:分类或回归的期望输出
    TV.P=test_data(:,2:size(test_data,2))';% 第二列到最后一列:不同数据的属性
    clear test_data;                       % 清除中间变量
    
    % 获取训练、测试数据情况
    NumberofTrainingData=size(P,2);        % 训练数据中分类对象个数
    NumberofTestingData=size(TV.P,2);      % 测试数据中分类对象个数
    NumberofInputNeurons=size(P,1);        % 神经网络输入个数,训练数据的属性个数
    
    %% 分类任务时的数据编码
    if Elm_Type~=REGRESSION
        % 分类任务数据预处理
        sorted_target=sort(cat(2,T,TV.T),2);% 将训练数据和测试数据的期望输出合并成一行,然后按从小到大排序
        label=zeros(1,1);                   %  Find and save in 'label' class label from training and testing data sets
        label(1,1)=sorted_target(1,1);      % 存入第一个标签
        j=1;
        % 遍历所有数据集标签(期望输出)得到数据集的分类数目
        for i = 2:(NumberofTrainingData+NumberofTestingData)
            if sorted_target(1,i) ~= label(1,j)
                j=j+1;
                label(1,j) = sorted_target(1,i);
            end
        end
        number_class=j;                    % 统计数据集(训练数据和测试数据)一共有几类
        NumberofOutputNeurons=number_class;% 一共有几类,神经网络就有几个输出
           
        % 预定义期望输出矩阵
        temp_T=zeros(NumberofOutputNeurons, NumberofTrainingData);
        % 遍历所有训练数据的标记,扩充为num_class*NumberofTraingData的矩阵 
        for i = 1:NumberofTrainingData
            for j = 1:number_class
                if label(1,j) == T(1,i)
                    break; 
                end
            end
            temp_T(j,i)=1;                %一个矩阵,行是分类,列是对象,如果该对象在此类就置1
        end
        T=temp_T*2-1;                     % T为处理的期望输出矩阵,每个对象(列)所在的真实类(行)位置为1,其余为-1
    
        % 遍历所有测试数据的标记,扩充为num_class*NumberofTestingData的矩阵 
        temp_TV_T=zeros(NumberofOutputNeurons, NumberofTestingData);
        for i = 1:NumberofTestingData
            for j = 1:number_class
                if label(1,j) == TV.T(1,i)
                    break; 
                end
            end
            temp_TV_T(j,i)=1;            % 期望输出表示矩阵,行是分类,列是对象,如果该对象在此类就置1
        end
        TV.T=temp_TV_T*2-1;              % T为处理的期望输出矩阵,每个对象(列)所在的真实类(行)位置为1,其余为-1
    
    
    end  % Elm_Type
    
    %% 计算隐藏层的输出H
    start_time_train=cputime;           % 训练开始计时
    
    % 随机产生输入权值InputWeight (w_i)和隐层偏差biases BiasofHiddenNeurons (b_i)
    InputWeight=rand(NumberofHiddenNeurons,NumberofInputNeurons)*2-1; % 输入节点的权重在[-1,1]之间
    BiasofHiddenNeurons=rand(NumberofHiddenNeurons,1);                % 连接偏重在[0,1]之间
    tempH=InputWeight*P; % 不同对象的属性*权重
    clear P; % 释放空间 
    ind=ones(1,NumberofTrainingData);     % 训练集中分类对象的个数
    BiasMatrix=BiasofHiddenNeurons(:,ind);% 扩展BiasMatrix矩阵大小与H匹配 
    tempH=tempH+BiasMatrix;               % 加上偏差的最终隐层输入
    
    %计算隐藏层输出矩阵
    switch lower(ActivationFunction) % 选择激活函数,lower是将字母统一为小写
        case {'sig','sigmoid'}
            H = 1 ./ (1 + exp(-tempH));% Sigmoid 函数
        case {'sin','sine'}
            H = sin(tempH);            % Sine 函数
        case {'hardlim'}
            H = double(hardlim(tempH));% Hardlim 函数
        case {'tribas'}
            H = tribas(tempH);         % Triangular basis 函数
        case {'radbas'}
            H = radbas(tempH);         % Radial basis 函数
        % 可在此添加更多激活函数                
    end
    clear tempH;% 释放不在需要的变量
    
    %% 计算输出权重 OutputWeight (beta_i)
    OutputWeight=pinv(H') * T';   % 无正则化因子的应用,参考2006年 Neurocomputing 期刊上的论文
    % OutputWeight=inv(eye(size(H,1))/C+H * H') * H * T';   % faster method 1 ,参考 2012 IEEE TSMC-B 论文
    % OutputWeight=(eye(size(H,1))/C+H * H') \ H * T';      % faster method 2 ,refer to 2012 IEEE TSMC-B 论文
    
    end_time_train=cputime;
    TrainingTime=end_time_train-start_time_train; % 计算训练ELM时CPU花费的时间
    
    % 计算输出
    Y=(H' * OutputWeight)';                       % Y为训练数据输出(列向量) 
    if Elm_Type == REGRESSION 
        TrainingAccuracy=sqrt(mse(T - Y));        % 回归问题计算均方误差根
    end
    clear H;
    
    %% 计算测试数据的输出(预测标签)
    start_time_test=cputime;    % 测试计时
    tempH_test=InputWeight*TV.P;% 测试的输入
    clear TV.P;  
    
    ind=ones(1,NumberofTestingData);
    BiasMatrix=BiasofHiddenNeurons(:,ind); % 扩展BiasMatrix矩阵大小与H匹配 
    tempH_test=tempH_test + BiasMatrix;% 加上偏差的最终隐层输入
    switch lower(ActivationFunction)
        case {'sig','sigmoid'}% Sigmoid 函数   
            H_test = 1 ./ (1 + exp(-tempH_test));
        case {'sin','sine'}   % Sine 函数 
            H_test = sin(tempH_test);        
        case {'hardlim'}      % Hardlim 函数
            H_test = hardlim(tempH_test);        
        case {'tribas'}       % Triangular basis 函数
             H_test = tribas(tempH_test);        
        case {'radbas'}       % Radial basis 函数
             H_test = radbas(tempH_test);        
        % 可在此添加更多激活函数             
    end
    TY=(H_test' * OutputWeight)';                       %   TY: 测试数据的输出
    
    end_time_test=cputime;
    TestingTime=end_time_test-start_time_test;          % 计算ELM测试集时CPU花费的时间
    
    %% 计算准确率
    if Elm_Type == REGRESSION
        TestingAccuracy=sqrt(mse(TV.T - TY));           % 回归问题计算均方误差根
    end
    
    % 如果是分类问题计算分类的准确率
    if Elm_Type == CLASSIFIER 
        MissClassificationRate_Training=0;
        MissClassificationRate_Testing=0;
        % 计算训练集上的分类准确率
        for i = 1 : size(T, 2) 
            [x, label_index_expected]=max(T(:,i));
            [x, label_index_actual]=max(Y(:,i));
            if label_index_actual~=label_index_expected
                MissClassificationRate_Training=MissClassificationRate_Training+1;
            end
        end
        % 计算测试集上的分类准确率
        TrainingAccuracy=1-MissClassificationRate_Training/size(T,2); % 训练集分类正确率
        for i = 1 : size(TV.T, 2)
            [x, label_index_expected]=max(TV.T(:,i));
            [x, label_index_actual]=max(TY(:,i));
            if label_index_actual~=label_index_expected
                MissClassificationRate_Testing=MissClassificationRate_Testing+1;
            end
        end
        TestingAccuracy=1-MissClassificationRate_Testing/size(TV.T,2);  % 测试集分类正确率
    end
    

        在以上代码中博主已相当详实地进行了注释,需要注意的是程序中默认训练和测试文件中第一列上的数据为样本标记,其余所有列中数据为样本属性,因此在调用该函数时应先保证自己的数据集已经整理为正确的格式,如下面整理好的Iris数据集(第一列为样本标号)。

    图片展示

        至于数据集如何整理可参考博主前面的博文:UCI数据集整理(附论文常用数据集),其中提供了详细的数据集和相关介绍。这里我们写一个测试函数验证以上的ELM函数,对于分类任务我们选取经典的UCI Iris数据集,测试的代码如下:

    clear all 
    clc
    
    dataSet = load('iris.txt');                             % 载入数据集
    len_dataSet = size(dataSet,1);                          % 数据集样本数
    ind = randperm(len_dataSet);                            % 随机挑选数据
    train_set = dataSet(ind(1:round(len_dataSet*0.7)),:);   % 随机的70%数据作为训练集
    test_set = dataSet(ind(round(len_dataSet*0.7)+1:end),:);% 随机的30%数据作为测试集
    
    save iris_train.txt -ascii train_set                    % 保存训练集为txt文件
    save iris_test.txt -ascii test_set                      % 保存测试集为txt文件
    
    % 调用ELM函数
    [TrainingTime, TestingTime, TrainingAccuracy, TestingAccuracy] = ELM('iris_train.txt', 'iris_test.txt', 1, 20, 'sig');
    
    % 输出结果
    fprintf('训练集准确率:%g \n',TrainingAccuracy);
    fprintf('测试集准确率:%g \n',TestingAccuracy);
    

    运行结果如下:

    图片展示

        对于回归任务可选取Sinc的数据集(该数据已整理分为训练和测试集),测试的代码如下:

    clear all
    clc
    
    % 调用ELM函数
    [TrainingTime,TestingTime,TrainingAccuracy,TestingAccuracy] = ELM('sinc_train','sinc_test',0,20,'sig');
    
    % 输出结果
    fprintf('训练集MSE:%g \n',TrainingAccuracy);
    fprintf('测试集MSE:%g \n',TestingAccuracy);
    

    运行结果如下:

    图片展示


    下载链接
        若您想获得博文中涉及的实现完整全部程序文件(包括数据集,m, txt文件等,如下图),这里已打包上传至博主的CSDN下载资源中,下载后运行run_ELM1.mrun_ELM2.m文件即可运行。文件下载链接如下:
    文件情况
    下载链接1:博文中涉及的完整程序文件(CSDN下载)

    下载链接2:博文中涉及的完整程序文件(面包多下载)

    公众号获取
        本人微信公众号已创建,扫描以下二维码并关注公众号“AI技术研究与分享”,后台回复“EF20190607”即可获取全部资源文件。


    5. 结束语

        由于博主能力有限,博文中提及的方法与代码即使经过测试,也难免会有疏漏之处。希望您能热心指出其中的错误,以便下次修改时能以一个更完美更严谨的样子,呈现在大家面前。同时如果有更好的实现方法也请您不吝赐教。

        大家的点赞和关注是博主最大的动力,博主所有博文中的代码文件都可分享给您,如果您想要获取博文中的完整代码文件,可通过C币或积分下载,没有C币或积分的朋友可在关注、点赞博文后提供邮箱,我会在第一时间发送给您。博主后面会有更多的分享,敬请关注哦!

    展开全文
  • 极限学习机matlab代码

    2017-09-17 10:44:21
    极限学习机matlab代码,极限学习机matlab代码,极限学习机matlab代码极限学习机matlab代码,,极限学习机matlab代码,极限学习机matlab代码
  • 极限学习机 代码

    2018-03-19 08:51:39
    极限学习机是机器学习中一种必不可少的方法,是一种基础方法,我们只要学习机器学习,都必须要理解其内容,而这个文档用一个实例揭示了极限学习机的内涵。
  • 极限学习机和支持向量机Around 2005, A novel machine learning approach was introduced by Guang-Bin Huang and a team of researchers at Nanyang Technological University, Singapore. 2005年前后,黄光斌和...

    极限学习机和支持向量机

    Around 2005, A novel machine learning approach was introduced by Guang-Bin Huang and a team of researchers at Nanyang Technological University, Singapore.

    2005年前后,黄光斌和新加坡南洋理工大学的一组研究人员介绍了一种新颖的机器学习方法。

    This new proposed learning algorithm tends to reach the smallest training error, obtain the smallest norm of weights and the best generalization performance, and runs extremely fast, in order to differentiate it from the other popular SLFN learning algorithms, it is called the Extreme Learning Machine (ELM).

    这种新提出的学习算法趋于达到最小的训练误差获得最小的权重范数最佳的泛化性能 ,并且运行速度极快 ,以使其与其他流行的SLFN学习算法区分开来,称为极限学习机。 (榆树)。

    This method mainly addresses the issue of far slower training time of neural networks than required, the main reasons for which is that all the parameters of the networks are tuned iteratively by using such learning algorithms. These slow-gradient based learning algorithms are extensively used to train neural networks.

    该方法主要解决了神经网络的训练时间比所需的慢得多的问题,其主要原因是通过使用这种学习算法来迭代地调整网络的所有参数。 这些基于慢梯度的学习算法被广泛用于训练神经网络。

    Before going into how ELM works and how is it so good, let’s see how gradient-based neural networks based off.

    在探讨ELM的工作原理以及它的性能如何之前,让我们看看基于梯度的神经网络是如何建立的。

    基于梯度的神经网络的演示 (Demonstration of Gradient-based Neural networks)

    Below are the steps followed in a single-layered feedforward neural network in brief:

    下面简要介绍了单层前馈神经网络中的步骤:

    Step 1: Evaluate Wx + B

    步骤1:评估Wx + B

    Step 2: Apply activation function g(Wx + B) and Compute output

    步骤2:应用激活函数g(Wx + B)并计算输出

    Step 3: Calculate Loss

    步骤3:计算损失

    Step 4: Compute gradients (using delta rule)

    第4步:计算梯度(使用增量规则)

    Step 5: Repeat

    步骤5:重复

    This method of propagating forward and back involves a hefty number of calculations Also if the input size is large or if there are more layers/nodes, the training takes up a significant amount of time.

    这种向前和向后传播的方法涉及大量计算。此外,如果输入大小很大或如果有更多的层/节点,则训练会占用大量时间。

    Image for post
    fig.1. 3-layered Neural Network
    图。1。 三层神经网络

    In the above example, we can see for a 4 node input we require W1 (20 parameters), W2 (53 parameters), and W3 (21 parameters), i.e. 94 parameters in total. And the parameters increase rapidly with the increasing input nodes.

    在上面的示例中,我们可以看到对于4节点输入,我们需要W1(20个参数),W2(53个参数)和W3(21个参数),即总共94个参数。 并且参数随着输入节点的增加而Swift增加。

    Let’s take a real-life example of image classification of numbers with MNIST Dataset:

    让我们以MNIST数据集为例,对数字进行图像分类:

    MNIST Example

    MNIST示例

    Image for post
    Source资源

    This has a 28x28 input size i.e. 784 input nodes. For its architecture, let’s consider two layers with 128 nodes and 64 nodes, which are then classified into 10 classes. Then parameters will be:

    输入大小为28x28,即784个输入节点。 对于其体系结构,让我们考虑两层,分别具有128个节点64个节点 ,然后将它们分为10类。 然后参数将是:

    • First Layer (784, 128) = 100352 parameters

      第一层(784,128)= 100352参数
    • Second Layer (128, 64) = 8192 parameters

      第二层(128、64)= 8192个参数
    • Output Layer (64, 10) = 640 parameters

      输出层(64、10)= 640个参数

    This will give us a total of 109184 parameters. And the repeated adjustment of weights by backpropagation increases the training time by a lot.

    这将给我们总共109184个参数。 而且通过反向传播对权重进行反复调整会大大增加训练时间。

    And this just for a 28x28 image, consider training it for bigger input size with 10000’s of features. The training time just gets out of hand.

    而这仅适用于28x28的图片,请考虑使用10000项功能对其进行训练以获取更大的输入大小。 培训时间变得一发不可收拾。

    结论: (Conclusion:)

    In almost all practical learning algorithms of feedforward neural networks, the conventional backpropagation method requires all these weights to be adjusted at every back-prop step.

    在几乎所有前馈神经网络的实用学习算法中,常规的反向传播方法都需要在每个反向传播步骤调整所有这些权重。

    For most of the time, gradient-descent based strategies have been employed in varied learning algorithms of feedforward neural networks. However, it’s clear that gradient descent-based learning strategies square measure usually terribly slow because of improper learning steps or could simply converge to local minimums. And many iterative learning steps are needed by such learning algorithms so as to get higher learning performance.

    在大多数情况下,前馈神经网络的各种学习算法都采用了基于梯度下降的策略。 但是,很明显,由于学习步骤不适当,基于梯度下降的学习策略的平方测量通常非常慢,或者可能会收敛到局部最小值。 并且,这样的学习算法需要许多迭代学习步骤,以便获得更高的学习性能。

    This makes the training far slower than required, which has been a major bottleneck for various applications.

    这使培训速度大大慢于所需的时间,这已成为各种应用程序的主要瓶颈。

    Next Article in this series: Part II: Algorithm https://medium.com/@prasad.kumkar/extreme-learning-machines-9c8be01f6f77

    本系列的下一篇文章: 第二部分:算法 https://medium.com/@prasad.kumkar/extreme-learning-machines-9c8be01f6f77

    翻译自: https://medium.com/datadriveninvestor/extreme-learning-machines-82095ee198ce

    极限学习机和支持向量机

    展开全文
  • 极限学习机源码

    2018-11-01 13:46:30
    极限学习机的matlab代码,跑了许多次,表示可以用,之前输出是一维,现在改成了四维。
  • 在线顺序极限学习机原理 在线顺序极限学习机原理 在线顺序极限学习机原理
  • 极限学习机

    2018-03-30 10:17:46
    极限学习机引入核思想 保障了一个更好的泛化性能 类似于SVM 但是比SVM更好的泛化能力
  • 极限学习机算法

    2018-05-31 16:17:55
    极限学习机算法 是一种前馈式神经网络算法,相比于BP神经网络,其随机初始化输入项的权值,训练速度快,预测精度较高。
  • 极限学习机Matlab代码

    2017-04-28 09:54:00
    极限学习机Matlab代码
  • 极限学习机 光谱诊断

    2019-04-04 13:55:05
    利用小波包变换对电弧光谱数据进行分析,利用极限学习机对焊缝状态进行分类
  • 极限学习机工具箱

    2018-06-27 11:05:11
    极限学习机的训练和测试,可用于模式识别,定量分析等计算。
  • 中文版,对黄广斌老师极限学习机简明的介绍,主要包括有极限学习机的定义,以及在及极限学习机中的各个参数的具体的代表的什么的理解。以及ELM的目前的研究现状
  • 终于要毕业了,毕业设计也做完了,我的毕设是《极限学习机和强化学习在单一资产交易中的应用》,本质上用以极限学习机为值函数逼近器的一类强化学习算法去对一个资产进行交易。既然毕设也做完了,大学生涯也要结束了...

    前言

    终于要毕业了,毕业设计也做完了,我的毕设是《极限学习机和强化学习在单一资产交易中的应用》,本质上用以极限学习机为值函数逼近器的一类强化学习算法去对一个资产进行交易。既然毕设也做完了,大学生涯也要结束了,那在去工作之前将毕设的东西好好总结一下,也方便以后自己看。

    算法基础

    ELM

    极限学习机ELM是一类Single-hidden Layer Feedforward Neural Network(SLFNs)算法,由Huang等基于 Moore-Penrose 广义逆的理论提出,主要针对SLFNs中存在的学习速率慢,迭代时间长,学习参数如学习步长、学习率需要人为提前设置等问题。与传统的神经网络学习算法相比,ELM只需要设置合适的隐层节点数,随机生成隐层所需所有参数,利用最小二乘法确定输出层权值。整个学习过程只需一步而无需多次更新隐层参数。正是因为ELM算法的快速学习能力以及较强的非线性逼近能力等特点,使得ELM在实际应用中受到了研究者们的青睐。例如ELM及改进算法被广泛应用于故障检测、时间序列预测、姿态识别、化学分析、医疗诊断、智能供电等领域。
    如果说ELM有什么公式比较重要的话,那应该是T=HβT=H\betaβ=HT\beta=H^\dag T。这里一个用以求得预测值TT,一个用来求解输出权重β\beta。需要注意HH^\dagHH广义逆
    而RELM则是在标准ELM在ELM的二次型指标中引入l2l_2正则化项。省略掉推导过程的话,β\beta的求解公式将变成:
    β=HT=(HTH+gI) \beta = H^\dag T=(H^TH+gI)
    其中,gg为用于调整正则化作用的权重系数,II为单位矩阵。

    OS-ELM

    在线学习的极限学习机和标准ELM之间的区别在于引入在线机制,这个机制的引入涉及到输出权重的更新,省略推导过程的话,当第k批样本到达时的β\beta更新方式:
    βk=βk1+PkHkT(TkHkβk1) \beta^{k}=\beta^{k-1}+P_kH^{T}_k(T_k-H_k\beta^{k-1})
    其中,命名PkP_k为工作矩阵,为HH的转置与HH乘积的逆,初始化时,P0=(H0TH0)1P_0=(H^T_0H_0)^{-1}
    其更新方式为:
    Pk=(Pk11+HkTHk)=Pk1Pk1HkT(I+HkHkT)1HkPk1 \begin{aligned} P_k & =(P^{-1}_{k-1}+H^T_kH_k)\\ & =P_{k-1}-P_{k-1}H^T_k(I+H_kH^T_k)^{-1}H_kP_{k-1} \end{aligned}
    如果用标准的ELM进行学习,除了每次需要对已有的样本进行重新学习,这浪费了很多计算资源,而且需要记录下之前的样本的特征,当样本量增加到一定程度的时候,学习机都没来得及学习更新一批样本就来了,那学习机就根本学不下去了。但OS-ELM完成学习后由于无需对已有样本做后续工作,所以不需要记录下样本的特征,可以说节省了许多内存。

    FOS-ELM

    带遗忘机制的OS-ELM和OS-ELM之间的区别在于引入遗忘机制,用以消除过期数据对预测的影响。遗忘机制要求我们需要记录学习机内样本。FOS-ELM要求初始化时设定一个样本量,当超过这个量,学习机就会启动遗忘机制。如果未启动遗忘机制的话,FOS-ELM的β\beta的更新方式和OS-ELM一样。如果启动了遗忘机制,设待删除的样本为第ll批,对工作矩阵PkP_k有:
    Pk=(i=kl+1kHiTHi+HkTHk)1=(Pk11+HkTHkHklTHkl)1 \begin{aligned} P_k&=(\sum\limits_{i=k-l+1}^{k}H^T_iH_i+H^T_{k}H_{k})^{-1}\\ &=(P^{-1}_{k-1}+H^T_kH_{k}-H^T_{k-l}H_{k-l})^{-1} \end{aligned}
    那么β\beta的更新方式为:
    βk=Pk(Pk1βk+[HklHk]T[TklTk])=Pk((Pk1[HklHk]T[TklTk])βk1+[HklHk]T[TklTk])=βk1+Pk[HklHk]T([TklTk][HklHk]βk1) \begin{aligned} \beta^{k} & =P_{k}(P^{-1}_k\beta^{k}+\begin{bmatrix}-H_{k-l} \\H_{k}\end{bmatrix} ^{T}\begin{bmatrix}T_{k-l} \\T_{k}\end{bmatrix})\\ &=P_k((P^{-1}_k-\begin{bmatrix}-H_{k-l} \\H_{k}\end{bmatrix} ^{T}\begin{bmatrix}T_{k-l} \\T_{k}\end{bmatrix})\beta^{k-1}+\begin{bmatrix}-H_{k-l} \\H_{k}\end{bmatrix} ^{T}\begin{bmatrix}T_{k-l} \\T_{k}\end{bmatrix})\\ &=\beta^{k-1}+P_{k}\begin{bmatrix}-H_{k-l} \\H_{k}\end{bmatrix} ^{T}(\begin{bmatrix}T_{k-l} \\T_{k}\end{bmatrix}-\begin{bmatrix}H_{k-l} \\H_{k}\end{bmatrix}\beta^{k-1}) \end{aligned}

    代码

    以上就是三个算法最主要的一些公式,接下来模型的实现就直接上代码吧。同时为了开发的方便,我把三个模型写成了继承关系,其中RELM为OS-ELM的父类,OS-ELM为FOS-ELM的父类。

    import numpy as np
    from sklearn.preprocessing import OneHotEncoder
    
    
    class RELM_HiddenLayer:
    
        """
            正则化的极限学习机
            :param x: 初始化学习机时的训练集属性X
            :param num: 学习机隐层节点数
            :param C: 正则化系数的倒数
        """
    
        def __init__(self, x, num, C=10):
            row = x.shape[0]
            columns = x.shape[1]
            rnd = np.random.RandomState()
            # 权重w
            self.w = rnd.uniform(-1, 1, (columns, num))
            # 偏置b
            self.b = np.zeros([row, num], dtype=float)
            for i in range(num):
                rand_b = rnd.uniform(-0.4, 0.4)
                for j in range(row):
                    self.b[j, i] = rand_b
            self.H0 = np.matrix(self.softplus(np.dot(x, self.w) + self.b))
            self.C = C
            self.P = (self.H0.H * self.H0 + len(x) / self.C).I
    
        @staticmethod
        def sigmoid(x):
            """
                激活函数sigmoid
                :param x: 训练集中的X
                :return: 激活值
            """
            return 1.0 / (1 + np.exp(-x))
    
        @staticmethod
        def softplus(x):
            """
                激活函数 softplus
                :param x: 训练集中的X
                :return: 激活值
            """
            return np.log(1 + np.exp(x))
    
        @staticmethod
        def tanh(x):
            """
                激活函数tanh
                :param x: 训练集中的X
                :return: 激活值
            """
            return (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))
    
        # 回归问题 训练
        def regressor_train(self, T):
            """
                初始化了学习机后需要传入对应标签T
                :param T: 对应属性X的标签T
                :return: 隐层输出权值beta
            """
            all_m = np.dot(self.P, self.H0.H)
            self.beta = np.dot(all_m, T)
            return self.beta
    
        # 回归问题 测试
        def regressor_test(self, test_x):
            """
                传入待预测的属性X并进行预测获得预测值
                :param test_x:被预测标签的属性X
                :return: 被预测标签的预测值T
            """
            b_row = test_x.shape[0]
            h = self.softplus(np.dot(test_x, self.w) + self.b[:b_row, :])
            result = np.dot(h, self.beta)
            return result
    
        # 分类问题 训练
        def classifisor_train(self, T):
            """
                初始化了学习机后需要传入对应标签T
                :param T: 对应属性X的标签T
                :return: 隐层输出权值beta
            """
            if len(T.shape) > 1:
                pass
            else:
                self.en_one = OneHotEncoder()
                T = self.en_one.fit_transform(T.reshape(-1, 1)).toarray()
                pass
            all_m = np.dot(self.P, self.H0.H)
            self.beta = np.dot(all_m, T)
            return self.beta
            pass
    
        # 分类问题 测试
        def classifisor_test(self, test_x):
            """
                传入待预测的属性X并进行预测获得预测值
                :param test_x:被预测标签的属性X
                :return: 被预测标签的预测值T
            """
            b_row = test_x.shape[0]
            h = self.softplus(np.dot(test_x, self.w) + self.b[:b_row, :])
            result = np.dot(h, self.beta)
            result = [item.tolist().index(max(item.tolist())) for item in result]
            return result
            pass
    
    
    class OS_DELM_HiddenLayer(RELM_HiddenLayer):
        """
            正则化的在线学习的极限学习机
            :param x: 初始化学习机时的训练集属性X
            :param num: 学习机隐层节点数
            :param C: 正则化系数的倒数
        """
    
        def __init__(self, x, num, C=10):
            super(OS_DELM_HiddenLayer, self).__init__(x, num, C=C)
    
        # 回归问题 在线学习
        def online_regressor_study(self, x, t):
            """
                在线学习模块
                :param x: 待学习训练集的属性X
                :param t: 待学习训练集的标签Y
            """
            if len(x.shape) == 1:
                x.reshape(1, -1)
            b_row = x.shape[0]
            H_k = np.matrix(self.softplus(np.dot(x, self.w) + self.b[:b_row, :]))
            self.P = np.linalg.pinv(self.P.I + H_k.H * H_k + b_row / self.C)
            self.beta = self.beta + self.P * H_k.H * (t - H_k * self.beta)
    
        # 分类问题 在线学习
        def online_classifisor_study(self, x, t):
            """
                在线学习模块
                :param x: 待学习训练集的属性X
                :param t: 待学习训练集的标签Y
            """
            if len(t.shape) > 1:
                pass
            else:
                t = self.en_one.transform(t.reshape(-1, 1)).toarray()
                pass
            self.online_regressor_study(x, t)
            pass
    
    
    class FOS_DELM_HiddenLayer(OS_DELM_HiddenLayer):
        """
            :param x: 初始化学习机时的训练集属性X
            :param num: 学习机隐层节点数
            :param C: 正则化系数的倒数
            带遗忘机制的正则化的在线学习极限学习机
        """
    
        def __init__(self, x, num, C=10):
            super(FOS_DELM_HiddenLayer, self).__init__(x, num, C=C)
    
        def regressor_train(self, T):
            """
                这里之所以重写train方法是因为启动遗忘机制时需要用到将要被删除的标签的值
                :param T: 对应属性X的标签T
                :return: 隐层输出权值beta
            """
            self.T = T
            return super(FOS_DELM_HiddenLayer, self).regressor_train(T)
    
        def online_regressor_study(self, x, t):
            """
                在线学习模块,这里在线学习直接启动了遗忘机制
                :param x: 待学习训练集的属性X
                :param t: 待学习训练集的标签Y
            """
            self.more_than_k(x, t)
    
        def less_than_k(self, x, t):
            """
                在线学习模块,当学习机内部样本数量还没超过阈值时,依然使用在线学习的方式
                :param x: 待学习训练集的属性X
                :param t: 待学习训练集的标签Y
            """
            super(FOS_DELM_HiddenLayer, self).online_regressor_study(x, t)
    
        def more_than_k(self, x, t):
            """
                在线学习模块,当学习机内部样本数量超过阈值时,启动遗忘机制
                :param x: 待学习训练集的属性X
                :param t: 待学习训练集的标签Y
            """
            b_row = x.shape[0]
            if len(x.shape) == 1:
                b_row = 1
            H_k = np.matrix(self.softplus(np.dot(x, self.w) + self.b[:b_row, :]))
            T_lost = self.T[0: b_row]
            H_lost = self.H0[0: b_row]
            P_k = np.linalg.pinv(self.P + H_k.H * H_k - H_lost.H * H_lost + b_row / self.C)
            mid2 = np.transpose(np.row_stack((-H_lost, H_k)))
            mid3 = np.row_stack((T_lost, t))
            self.beta = self.beta + P_k * mid2 * (mid3 - np.row_stack((H_lost, H_k)) * self.beta)
            self.P = P_k
            self.H0 = np.row_stack((self.H0[b_row:], H_k))
            self.T = np.row_stack((self.T[b_row:], t))
            pass
    

    在这里我预先写了三个激活函数,通过对比发现softplus函数的精度是最高的,如果有需要其实是可以将激活函数替换成其他函数的。

    总结

    以上就是3个ELM的实现。说真的,一开始做这个课题的时候拼命在网上找看OS-ELM的实现一直没找到,其实是很烦的。但是烦过以后自己动手一点点实现它其实是很有成就感的。ELM做股价预测来说,预测的精度和现有的很多模型的精度是相当的,大概也是在0.55左右。ELM属于我的毕设的第一部分,它将作为我的交易Agent的值函数逼近器。下一部分将会写毕设的第二部分强化学习(RL)的一些实现,应该会尽可能在上班前完成的,加油!!!

    展开全文
  • 极限学习机matlab程序

    2018-10-11 09:24:57
    极限学习机matlab程序。程序里包括样本训练、测试、精度、隐层神经元个数、激活函数选取。
  • 极限学习机改进算法

    2016-10-30 21:18:49
    用于预测和分类的极限学习机改进算法
  • 简单易学的机器学习算法——极限学习机(ELM)

    万次阅读 多人点赞 2014-04-24 11:56:51
    极限学习机(Extreme Learning Machine) ELM

    一、极限学习机的概念

           极限学习机(Extreme Learning Machine) ELM,是由黄广斌提出来的求解单隐层神经网络的算法。

           ELM最大的特点是对于传统的神经网络,尤其是单隐层前馈神经网络(SLFNs),在保证学习精度的前提下比传统的学习算法速度更快。

    二、极限学习机的原理

    ELM是一种新型的快速学习算法,对于单隐层神经网络,ELM可以随机初始化输入权重和偏置并得到相应的输出权重。


    (选自黄广斌老师的PPT)

    对于一个单隐层神经网络(见Figure 1),假设有个任意的样本,其中。对于一个有个隐层节点的单隐层神经网络可以表示为


    其中,为激活函数,为输入权重,为输出权重,是第个隐层单元的偏置。表示的内积。


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


    即存在,使得


    可以矩阵表示为


    其中,是隐层节点的输出,为输出权重,为期望输出。




    为了能够训练单隐层神经网络,我们希望得到,使得


    其中,,这等价于最小化损失函数


    传统的一些基于梯度下降法的算法,可以用来求解这样的问题,但是基本的基于梯度的学习算法需要在迭代的过程中调整所有参数。而在ELM算法中, 一旦输入权重和隐层的偏置被随机确定,隐层的输出矩阵就被唯一确定。训练单隐层神经网络可以转化为求解一个线性系统。并且输出权重可以被确定


    其中,是矩阵的Moore-Penrose广义逆。且可证明求得的解的范数是最小的并且唯一。

    三、实验

        我们使用简单易学的机器学习算法——Logistic回归》中的实验数据。

    原始数据集
    我们采用统计错误率的方式来评价实验的效果,其中错误率公式为:

    对于这样一个简单的问题,
    MATLAB代码
    主程序
    %% 主函数,二分类问题
    
    %导入数据集
    A = load('testSet.txt');
    
    data = A(:,1:2);%特征
    label = A(:,3);%标签
    
    [N,n] = size(data);
    
    L = 100;%隐层节点个数
    m = 2;%要分的类别数
    
    %--初始化权重和偏置矩阵
    W = rand(n,L)*2-1;
    b_1 = rand(1,L);
    ind = ones(N,1);
    b = b_1(ind,:);%扩充成N*L的矩阵
    
    tempH = data*W+b;
    H = g(tempH);%得到H
    
    %对输出做处理
    temp_T=zeros(N,m);
    for i = 1:N
        if label(i,:) == 0
            temp_T(i,1) = 1;
        else 
            temp_T(i,2) = 1;
        end    
    end
    T = temp_T*2-1;
    
    outputWeight = pinv(H)*T;
    
    %--画出图形
    x_1 = data(:,1);  
    x_2 = data(:,2);  
    hold on  
    for i = 1 : N  
        if label(i,:) == 0  
            plot(x_1(i,:),x_2(i,:),'.g');  
        else  
            plot(x_1(i,:),x_2(i,:),'.r');  
        end  
    end
    
    output = H * outputWeight;
    %---计算错误率
    tempCorrect=0;
    for i = 1:N
        [maxNum,index] = max(output(i,:));
        index = index-1;
        if index == label(i,:);
            tempCorrect = tempCorrect+1;
        end
    end
    
    errorRate = 1-tempCorrect./N;
    

    激活函数
    function [ H ] = g( X )
        H = 1 ./ (1 + exp(-X));
    end
    

    黄老师提供的极限学习机的代码:点击打开链接




    展开全文
  • ELM的回归拟合——基于近红外光谱的汽油辛烷值预测,用于极限学习机的算法实现,帮助大家更好地学习和使用极限学习机
  • elm极限学习机.rar

    2019-09-01 21:02:36
    极限学习机Matlab代码,有训练集函数,预测函数,和一个适用范例,全方位指导elm学习算法。
  • 为了进一步提高极限学习机的学习性能,将并行学习的思想引入单层极限学习机,并提出了基于并行学习的多层极限学习机模型。实验结果表明,该模型比传统的单层极限学习机、多层极限学习机以及传统基于误差反向学习的...
  • 这是一个在MATLAB上面可以运行的极限学习机算法实例,文件中,包含了多个极限学习机样例,ELM说白了就是另一种神经网络,其作用相似,效果又不同,比如其离散型更强等,建议直接修改接口,方便调试
  • 该资源是增量式极限学习机MATLAB实现方式。包含6个子文件。
  • 极限学习机程序+数据

    2018-05-15 16:51:33
    极限学习机完整算法在matlab中的实现,内含数据集。。

空空如也

1 2 3 4 5 ... 20
收藏数 530
精华内容 212
关键字:

极限学习机