文章目录
 
1. 极限学习机ELM原理介绍
1.1极限学习机的训练过程
1.2 极限学习机的预测过程
  
2. 基于极限学习机ELM标准算法的回归预测模型建立
2.1 数据说明
2.2 极限学习机的实现步骤
  
3. 模型效果
4. 参考文献
5. MATLAB代码

 
1. 极限学习机ELM原理介绍
 
极限学习机（Extreme Learning Machine, ELM）是一种单隐层前馈神经网络算法（SLFN），它的模型结构由输入层，隐含层，输出层三层组成，与人工神经网络相同，每层之间的连接是利用特征映射函数完成的，输入层的信息是通过隐含层加工处理后传递给输出层，然后输出层根据映射函数，得出计算值。
 
 
1.1极限学习机的训练过程
 
极限学习机是一种特殊的前馈神经网络，训练过程中，隐含层的权值和偏置往往是随机产生或者人为给定，不需要更新，通过计算求出输出层的权值，即完成训练过程。步骤如下：
 
设输入层有n个神经元输入端子，输出层m个神经元，隐含层有$l$个神经元。记$\omega$为输入层与隐含层间的连接权值，w相应的为$l\times n$的矩阵，权值矩阵的元素一般是[-1,1]之间的随机数。
 
$$\omega ={\left[\begin{array}{cccc}{\omega }_{11}& {\omega }_{12}& \cdots & {\beta }_{1n}\\ {\omega }_{21}& {\omega }_{22}& \cdots & {\beta }_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ {\omega }_{l1}& {\omega }_{l2}& \cdots & {\beta }_{ln}\end{array}\right]}_{l\times n}$$
 
记$b$为隐含层的偏置，对应隐含层的$l$个神经元节点，则偏置向量$b$的大小为$l\times 1$的列向量。偏置向量的元素一般是[0,1]之间的随机数。
 
$$b={\left[\begin{array}{c}{b}_1\\ b_2\\ ⋮\\ b_l\end{array}\right]}_{l\times 1}$$
 
记$\beta$为隐含层与输出层的连接权值，$\beta$大小为$l\times m$的矩阵，当输出层的神经元节点为$m=1$时，训练得到的是一个单输出的极限学习机模型。通过初始的隐含层权值$\omega$和偏置$b$，即可求解出输出层的权值矩阵$\beta$，从而得到训练好的极限学习机模型。
 
$$\beta =\left[\begin{array}{cccc}{\beta }_{11}& {\beta }_{12}& \cdots & {\beta }_{1m}\\ {\beta }_{21}& {\beta }_{22}& \cdots & {\beta }_{2m}\\ ⋮& ⋮& ⋮& ⋮\\ {\beta }_{l1}& {\beta }_{l2}& \cdots & {\beta }_{lm}\end{array}\right]$$
 
通过激活函数$G()$进行特征映射，可以得到极限学习机的输出值为：
 
$$f_L(x)=\sum _{i=1}^L{\beta }_{i}G\left({\omega }_i\cdot x_i+b_i\right)=\sum _{i=1}^L{\beta }_{i}h\left(x_i\right)$$
 
式中，$L$为样本总数，$h(x_i)$为隐含层对第$i$个样本特征的映射值。
 
设$T$为期望的输出值，从而只需要求得合适的$\beta$使得误差函数值最小或者接近于0：
 
$$\Vert \mathbf{H}\mathbf{\beta }-\mathbf{T}{\Vert }^2=0$$
 
因而，对上面的等式求逆，解出输出层的权值$\beta$，可得到一个训练好的极限学习机模型。
 
1.2 极限学习机的预测过程
 
在确定了极限学习机的隐含层权值和偏置，以及输出层的权值矩阵后，只需要根据步骤4，带入需要预测的样本特征$x$，即可获得相应的ELM仿真输出值。
 
需要注意的是，极限学习机参数的随机初始化使得ELM具有较好的泛化性，但也相应的要求极限学习机模型增加较多的节点数目来实现准确的训练。在大样本情况下，过多的节点会消耗计算资源，也可能造成过拟合。
 
2. 基于极限学习机ELM标准算法的回归预测模型建立
 
2.1 数据说明
 
采用了身体脂肪数据集进行训练和测试ELM的预测精度，数据形式如下：
 
样本序号
输入指标1
输入指标2
…
输出指标
1
-
–
–
–
2
-
–
–
–
…
-
–
–
–
n
-
–
–
–
2.2 极限学习机的实现步骤
 
步骤一：获取数据。
 
步骤二：数据预处理，一般是采用极小极大归一化，消除数据量纲和数量级影响。
 
步骤三：训练ELM模型，求出隐含层和输出层的连接权值。
 
步骤四：对训练的模型，使用测试的输入数据进行预测。
 
步骤五：对预测的值，和实际的值，进行误差分析和作图。
 
ELM的演示代码，供学习使用
 
%初始化
clear
close all
clc
warning off
rng('default')

P=randi([1 10],3,100);        %构建训练数据的输入样本
T=sum(P,1);           %构建训练数据的输出样本
P1= randi([1 10],3,10);     %构建测试数据的输入样本
T1=sum(P1,1);           %构建测试数据的输出样本

% 归一化...使用mapminmax函数即可，由于生成的数据无量纲和数量级差异，跳过

%% ELM训练过程
N=3;       %输入层的神经元节点个数
L=30;     %隐含层的神经元节点个数
M=1;     %输出层的神经元节点个数

IW=2*rand(L,N)-1;           %初始化输入层与隐含层的连接权值，范围(-1,1)
B=rand(L,1);             %初始化隐含层的偏置，范围(0,1)
tempH = IW * P + B;  %计算隐含层的输出值
h= 1./ (1 + exp(tempH ));          %使用映射函数G(x)=1/(1+exp(x))，h为隐含层对第样本特征的映射值
LW=pinv(h')*T';          %求逆，得到输出层的权值，结束训练（转置是为了让维度对应）

%% ELM预测过程
tempH1=IW*P1+B;         %计算隐含层输出值
h1= 1./ (1 + exp(tempH1 ));        %对特征作映射
ELM_OUT= (h1' * LW)';

%% 分析预测的误差
error=T1-ELM_OUT;   %误差=实际值-预测值
disp('          序号     期望值      预测值       误差')
disp([1:10
    T1
    ELM_OUT
    error]')
disp('误差平方和...')
sse=sum(error.^2)    
disp('均方误差...')
mse=mean(error.^2) 
disp('平均相对误差...')
mape=mean(abs(error)./T1)   

%作图分析预测的效果
figure
hold on
plot(1:10,T1,'bo:','linewidth',1.0)
plot(1:10,ELM_OUT,'r*-.','linewidth',1.0)
legend('期望值','预测值')
xlabel('测试样本序号')
ylabel('指标的值')

web https://blog.csdn.net/qq_45955094/article/details/116381999


 
3. 模型效果
 

 
 
4. 参考文献
 
[1]尤玲玲. 基于粒子群优化算法的极限学习机及其在降水量预测中的应用研究[D].吉林农业大学,2020.
 
5. MATLAB代码
 
1. ELM极限学习机回归预测
 
2. 遗传算法GA优化ELM极限学习机预测
 
3. 粒子群算法PSO优化ELM极限学习机预测
 
4. ELM极限学习机数据分类

  

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

  

    对于一个神经网络而言，我们完全可以把它看成一个“函数”，单从输入输出看就显得简单许多。很明显上图中，从左往右该神经网络的输入是训练样本集$\mathrm{x}$，中间有个隐藏层，从输入层到隐藏层之间是全连接，记隐藏层的输出为$H(\mathrm{x})$，那么隐藏层输出$H(\mathrm{x})$的计算公式如下。
 $$H(\mathrm{x})=\left[h_1(\mathrm{x}),\dots ,h_L(\mathrm{x})\right]\text{\hspace{1em}(2.1)}$$    隐藏层的输出是输入乘上对应权重加上偏差，再经过一个非线性函数其所有节点结果求和得到。$\mathrm{H}(\mathrm{x})=\left[h_1(\mathrm{x}),\dots ,h_L(\mathrm{x})\right]$是ELM非线性映射（隐藏层输出矩阵），$h_i(\mathrm{x})$是第$i$个隐藏层节点的输出。隐藏层节点的输出函数不是唯一的，不同的输出函数可以用于不同的隐藏层神经元。通常，在实际应用中，$h_i(\mathrm{x})$用如下的表示：
 $$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\text{\hspace{1em}(2.2)}$$    其中$g\left({\mathrm{w}}_i,b_i,\mathrm{x}\right)$（${\mathrm{w}}_i$和$b_i$是隐藏层节点参数）是激活函数，是一个满足ELM通用逼近能力定理的非线性分段连续函数，常用的有Sigmoid函数、Gaussian函数等。如我们可以使用Sigmoid函数，那么式（2.2）中的$g$函数为$$g(x)=\frac{1}{1+e^{-x}}=\frac{e^x}{e^x+1}\text{\hspace{1em}(2.3)}$$（将${\mathrm{w}}_i\mathrm{x}+{\mathrm{b}}_i$代入$x$即可），该函数图像如下图所示
 

  

    经过隐层后进入输出层，根据上面的图示和公式，那么用于“广义”的单隐藏层前馈神经网络ELM的输出是
 $$f_L(\mathrm{x})=\sum _{i=1}^L{\mathbf{\beta }}_i{h}_i(\mathrm{x})=\mathrm{H}(\mathrm{x})\mathbf{\beta }\text{\hspace{1em}(2.4)}$$其中$\mathbf{\beta }={\left[{\mathbf{\beta }}_1,\dots ,{\mathbf{\beta }}_L\right]}^T$是隐藏层（$L$个节点）与输出层（$m$个节点，$m\ge 1$）之间的输出权重。至此神经网络从输入到输出的操作就是上面公式的计算过程。需要注意的是，目前为止上面公式中的未知量有$\mathrm{w},\mathrm{b},\mathbf{\beta }$，分别是隐藏层节点上的权值、偏差及输出权值。我们知道神经网络学习（或训练）的过程就是根据训练数据来调整神经元之间的权值以及偏差，而实际上学到的东西则蕴含在连接权值和偏差之中。接下来我们就要用ELM的机理来求解这三个值（ELM训练过程）。
 
    基本上，ELM训练SLFN分为两个主要阶段：（1）随机特征映射（2）线性参数求解。
 
    第一阶段，隐藏层参数随机进行初始化，然后采用一些非线性映射作为激活函数，将输入数据映射到一个新的特征空间（称为ELM特征空间）。简单来说就是ELM隐层节点上的权值和偏差是随机产生的。随机特征映射阶段与许多现有的学习算法（如使用核函数进行特征映射的SVM、深度神经网络中使用限制玻尔兹曼机器（RBM）、用于特征学习的自动编码器/自动解码器）不同。ELM 中的非线性映射函数可以是任何非线性分段连续函数。在ELM中，隐藏层节点参数（$w$ 和$b$）根据任意连续的概率分布随机生成（与训练数据无关），而不是经过训练确定的，从而致使与传统BP神经网络相比在效率方面占很大优势。
 
    经过第一阶段$\mathrm{w},\mathrm{b}$已随机产生而确定下来，由此可根据公式（2.1）和（2.2）计算出隐藏层输出$H$。在ELM学习的第二阶段，我们只需要求解输出层的权值（$\beta$）。为了得到在训练样本集上具有良好效果的$\beta$，需要保证其训练误差最小，我们可以用$\mathrm{H}\mathbf{\beta }$（Hβ是网络的输出，如公式（2.4））与样本标签$T$求最小化平方差作为评价训练误差（目标函数），使得该目标函数最小的解就是最优解。即通过最小化近似平方差的方法对连接隐藏层和输出层的权重（$\beta$）进行求解，目标函数如下：
 $$\min \Vert \mathrm{H}\mathbf{\beta }-\mathrm{T}{\Vert }^2,\mathbf{\beta }\in {\mathbf{R}}^{L\times m}\text{\hspace{1em}(2.5)}$$其中H是隐藏层的输出矩阵，T是训练数据的目标矩阵：
 $$H=[h(x_1),...,h(x_N){]}^T=\left[\begin{array}{ccc}{h}_1(x_1)& ...& h_L(x_1)\\ & ...& \\ h_1(x_N)& ...& h_L(x_N)\end{array}\right],T=\left[\begin{array}{c}{t}_1^T\\ ...\\ t_N^T\end{array}\right]\text{\hspace{1em}(2.6)}$$通过线代和矩阵论的知识可推导得公式（2.5）的最优解为：
 $${\beta }^{\ast }={\mathrm{H}}^{†}\mathrm{T}\text{\hspace{1em}(2.7)}$$其中${\mathrm{H}}^{†}$为矩阵H的Moore–Penrose广义逆矩阵。
 
    这时问题就转化为求计算矩阵H的Moore–Penrose广义逆矩阵，该问题主要的几种方法有正交投影法、正交化法、迭代法和奇异值分解法（SVD）。当$H^{T}H$为非奇异（可逆）时可使用正交投影法，这时可得计算结果是：
 $${\mathbf{H}}^{†}={\left({\mathbf{H}}^T\mathbf{H}\right)}^{-1}{\mathbf{H}}^T$$    然而有时候在应用时会出现$H^{T}H$为奇异的（不可逆）情况，因此正交投影法并不能很好地应用到所有的情况。由于使用了搜索和迭代，正交化方法和迭代方法具有局限性。而奇异值分解（SVD）总是可以用来计算$H$的Moore–Penrose广义逆，因此用于ELM的大多数实现中。具体的求解过程涉及矩阵论的知识，而且在许多编程语言中都已封装了求解广义逆的可调用的函数，限于篇幅这里博主就不多展开了。至此训练部分全部完成，在测试时利用训练得到的结果便可预测结果。
 
    综合上面说的，对于训练单隐层前馈神经网络的极限学习机算法做出总结，算法如下所示：
 
 
 
算法：极限学习机（ELM）
 输入：
     数据集：$\left\{{\mathrm{x}}_i,{\mathrm{t}}_i|{\mathrm{x}}_i\in {\mathrm{R}}^D,{\mathrm{t}}_i\in {\mathrm{R}}^m,i=1,2,\dots ,N\right\}$
     隐层神经元数目：$L$
     激活函数：$g(.)$
 输出：
     输出权重：$\beta$
     1.随机产生输入权重$w$和隐层偏差$b$；
     2.计算隐藏层输出$\mathrm{H}=\mathrm{g}(\mathrm{x}\ast \mathbf{\omega }+\mathrm{b})$；
     3.采用式（2.7）计算输出层权重$\beta$；
 
 
    其实以上的理论尚有不足之处，根据Bartlett理论，对于达到较小的训练误差的前馈神经网络，通常其权值范数越小，网络趋向于获得更好的泛化性能。为了进一步提高传统极限学习机的稳定性和泛化能力，可以在上面目标函数中增加权值范数的约束项来重新求解输出权重，因此提出了优化等式约束的极限学习机。除此之外后来还有许多文章在原有极限学习机的理论和算法上进行了改进，这里就不多介绍了有兴趣的可以了解一下。
 
 
 
3. 算法程序实现
 
    数学中的符号语言可谓精简巧妙，其简洁之美不经间引人入胜，同时它的复杂又让人觉得自己知道的还很匮乏。作为工科的我数学基本功仅限于刚考研时的临阵磨枪，如今的研究生阶段接触了最优理论、统计分析和矩阵论的知识但自感尚不能得其万一。上面的算法推导是完成了，但不代表程序就能完整照上面的步骤实现了，毕竟理论和实际总是有差距的。
 
    其实ELM的程序代码早已开放，提供源码下载的网站：黄广斌老师的ELM资源主页，上面已经有了MATLAB、C++、python和Java的版本，使用起来也比较方便。这里博主就其中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.m或run_ELM2.m文件即可运行。文件下载链接如下：
 
 下载链接1：博文中涉及的完整程序文件（CSDN下载）
 
下载链接2：博文中涉及的完整程序文件（面包多下载）
 
【公众号获取】
     本人微信公众号已创建，扫描以下二维码并关注公众号“AI技术研究与分享”，后台回复“EF20190607”即可获取全部资源文件。
 

  

 
5. 结束语
 
    由于博主能力有限，博文中提及的方法与代码即使经过测试，也难免会有疏漏之处。希望您能热心指出其中的错误，以便下次修改时能以一个更完美更严谨的样子，呈现在大家面前。同时如果有更好的实现方法也请您不吝赐教。
 
    大家的点赞和关注是博主最大的动力，博主所有博文中的代码文件都可分享给您，如果您想要获取博文中的完整代码文件，可通过C币或积分下载，没有C币或积分的朋友可在关注、点赞博文后提供邮箱，我会在第一时间发送给您。博主后面会有更多的分享，敬请关注哦！

基于遗传算法优化极限学习机预测及其MATLAB实现-附代码
 


 
文章目录
 
基于遗传算法优化极限学习机预测及其MATLAB实现-附代码
1 极限学习机ELM原理
2 基于GA-ELM预测模型的建立
2.1 优化变量的处理
2.2 目标函数的处理
2.3 流程图设计
  
3 基于GA-ELM模型的身体脂肪预测应用
3.1 数据介绍
3.2 数据处理
3.3 GA-ELM预测算法的步骤
3.4 组合模型的参数设置
  
4 运行结果
5 MATLAB代码

 
1 极限学习机ELM原理
 
ELM预测相关理论可查看上一篇博客:  极限学习机ELM回归预测
 
简单的ELM预测代码如下:
 
%初始化
clear
close all
clc
warning off
rng('default')

P=randi([1 10],3,100);        %构建训练数据的输入样本
T=sum(P,1);           %构建训练数据的输出样本
P1= randi([1 10],3,10);     %构建测试数据的输入样本
T1=sum(P1,1);           %构建测试数据的输出样本

% 归一化...使用mapminmax函数即可，由于生成的数据无量纲和数量级差异，跳过

%% ELM训练过程
N=3;       %输入层的神经元节点个数
L=30;     %隐含层的神经元节点个数
M=1;     %输出层的神经元节点个数

IW=2*rand(L,N)-1;           %初始化输入层与隐含层的连接权值，范围(-1,1)
B=rand(L,1);             %初始化隐含层的偏置，范围(0,1)
tempH = IW * P + B;  %计算隐含层的输出值
h= 1./ (1 + exp(tempH ));          %使用映射函数G(x)=1/(1+exp(x))，h为隐含层对第样本特征的映射值
LW=pinv(h')*T';          %求逆，得到输出层的权值，结束训练（转置是为了让维度对应）

%% ELM预测过程
tempH1=IW*P1+B;         %计算隐含层输出值
h1= 1./ (1 + exp(tempH1 ));        %对特征作映射
ELM_OUT= (h1' * LW)';

%% 分析预测的误差
error=T1-ELM_OUT;   %误差=实际值-预测值
disp('          序号     期望值      预测值       误差')
disp([1:10
    T1
    ELM_OUT
    error]')
disp('误差平方和...')
sse=sum(error.^2)    
disp('均方误差...')
mse=mean(error.^2) 
disp('平均相对误差...')
mape=mean(abs(error)./T1)   

%作图分析预测的效果
figure
hold on
plot(1:10,T1,'bo:','linewidth',1.0)
plot(1:10,ELM_OUT,'r*-.','linewidth',1.0)
legend('期望值','预测值')
xlabel('测试样本序号')
ylabel('指标的值')


 
2 基于GA-ELM预测模型的建立
 
在理论与代码的实现过程中，注意到存在两个随机变量: 输入层与隐含层的连接权值IW，以及隐含层的阈值B.
 
IW=2*rand(L,N)-1;           %随机初始化权值，服从(-1,1)均匀分布
B=rand(L,1);             %随机初始化阈值，服从(0,1)均匀分布

 
针对ELM 随机产生的输入层权值和隐含层阈值导致网络不稳定的问题，采用遗传算法对极限学习机的权值和阈值进行优化，从而降低预测误差值，改善网络性能，得以提升ELM预测精度。
 
2.1 优化变量的处理
 
设极限学习机的输入层神经元节点数目为 $n$, 隐含层节点数目为 $l$,
 
输入层与隐含层的连接权值为 $\omega$:
 
$$\omega ={\left[\begin{array}{cccc}{\omega }_{11}& {\omega }_{12}& \cdots & {\beta }_{1n}\\ {\omega }_{21}& {\omega }_{22}& \cdots & {\beta }_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ {\omega }_{l1}& {\omega }_{l2}& \cdots & {\beta }_{ln}\end{array}\right]}_{l\times n}$$
 
隐含层的阈值为 $b$:
 
$$b={\left[\begin{array}{c}{b}_1\\ b_2\\ ⋮\\ b_l\end{array}\right]}_{l\times 1}$$
 
式中，$\omega 、b$分别为矩阵和列向量。使用遗传算法等智能算法求解时，对于优化变量，采用向量型编码个体位置的方法操作较为简单。此外，还有矩阵编码，二进制编码等编码方式。此处采用向量型的浮点编码。
 
做法是: 先确定$\omega$ 与 $b$中元素变量的总数: $n\times l+l$，再生成等长度的初始种群位置向量。由 $n$ 个个体组成的父代可表示如下:
 
$$X=\left[\begin{array}{cccc}{x}_1^1& x_1^2& \dots & x_1^d\\ x_2^1& x_2^2& \dots & x_2^d\\ \dots & \dots & \dots & \cdots \\ x_n^1& x_n^2& \dots & x_n^d\end{array}\right]$$
 
式中, d是变量维度, 且 $d=n\times l+l$.
 
2.2 目标函数的处理
 
根据ELM的训练公式:
 
$$\Vert \mathbf{H}\mathbf{\beta }-\mathbf{T}{\Vert }^2=0$$
 
对上式求逆，解出输出层的权值 $\beta$，可得到一个训练好的极限学习机模型。因而当该方程可解 ($H$的逆矩阵存在) 时，得到的模型对训练样本是无误差的。GA优化目的是针对随机初始化权值阈值带来的网络预测不稳定，通过优化权值和阈值，提升预测精度。因此，将训练集与测试集整体的均方误差作为适应度函数。适应度函数值越小，表明训练越准确，且兼顾模型的预测精度更好。
 
$$F=\min \left(MS{E}_{\text{Trainingset },\text{ Testingset }}\right)$$
 
式中，TraingingSet，TestingSet，分别为训练集和测试集的样本。
 
2.3 流程图设计
 
 
3 基于GA-ELM模型的身体脂肪预测应用
 
3.1 数据介绍
 
身体脂肪数据集 bodyfatDataset 是深度学习中常用的预测数据集，对该数据集的描述如下:
 
bodyfatInputs - a 13x252 matrix defining thirteen attributes for 252
people.
  1. Age (years)
  2. Weight (lbs)
  3. Height (inches)
  4. Neck circumference (cm)
  5. Chest circumference (cm)
  6. Abdomen 2 circumference (cm)
  7. Hip circumference (cm)
  8. Thigh circumference (cm)
  9. Knee circumference (cm)
 10. Ankle circumference (cm)
 11. Biceps (extended) circumference (cm)
 12. Forearm circumference (cm)
 13. Wrist circumference (cm)

bodyfatTargets - a 1x252 matrix of associated body fat percentages,
to be estimated from the inputs.
 
整理到EXCEL中, 数据形式如下:
 
样本序号
输入指标1
输入指标2
…
输出指标
1
-
–
–
–
2
-
–
–
–
…
-
–
–
–
n
-
–
–
–
3.2 数据处理
 
由于不同变量的单位和取值范围差异较大，为了消除变量之间数量级的差别避免造成预测误差，以及方便求解，将数据进行归一化处理是实现预测前对数据常做的处理。采用MATLAB 自带归一化函数mapmin max 将所有数据都转化为［－ 1，1］之间的数据。函数调用方式如下:
 
［pn，ps］ = mapminmax( p) 

 
式中, p是输入原始数据， pn 是归一化的数据， ps是记录数据归一化操作的结构体。输出数据的归一化同理，预测完成后同样利用此函数进行反归一化，获得真实数据。
 
3.3 GA-ELM预测算法的步骤
 
初始化染色体种群编码。将极限学习机的输入层权值与隐含层阈值元素取出，并计算染色体长度。随机初始化染色体。
设置适应度函数。利用ELM对样本的预测输出误差作为适应度函数，计算初始种群中个体的适应度值。
进行选择、交叉、变异操作。采用轮盘赌选择时，对于适应度函数，由于取的是均方误差，在进化过程中，均方误差减小，因此轮盘赌设计时适应度函数需取倒数，从而选择"适应度大"的个体。
计算子代个体的适应度，并与父代个体合并，留下适应度值较好的个体构成新的子代种群。
反复迭代执行3和4步，直到迭代次数达到设定的最大值。
输出最好的染色体信息。对适应度值最好的染色体进行解码，并将解码后得到的权值和阈值赋给预测使用的ELM。
以最优的权值和阈值初始化ELM 的参数，获得最优的网络结构。最后测试网络的预测精度。
 
3.4 组合模型的参数设置
 
确定ELM的结构参数:
 
% 1. 输入层神经元节点数,
inputnum=size(input,2);  % input的行向对应输入指标个数

% 2. 输出层的神经元节点数,
outputnum=size(output,2);  % output的行向对应输出指标个数

disp('/')
disp('极限学习机ELM结构...')
disp(['输入层的节点数为：',num2str(inputnum)])
disp(['输出层的节点数为：',num2str(outputnum)])
disp(' ')
disp('隐含层节点的确定过程...')

% 3. 确定隐含层的神经元节点个数
%注意：BP神经网络确定隐含层节点的方法是：采用经验公式hiddennum=sqrt(m+n)+a，m为输入层节点个数，n为输出层节点个数，a一般取为1-10之间的整数
%在极限学习机中，该经验公式往往会失效，设置较大的范围进行隐含层节点数目的确定即可。

MSE=1e+5; %初始化最小误差
for hiddennum=20:30                      
...
%更新最佳的隐含层节点
    if minMse<MSE
        MSE=minMse;
        hiddennum_best=hiddennum;
    end
 
初始化遗传算法的参数:
 
nvars=inputnum*hiddennum_best+hiddennum_best;    %自变量个数
PopulationSize_Data=30;   %种群规模
MaxGenerations_Data=50;   %最大进化代数
CrossoverFraction_Data=0.8;  %交叉概率
MigrationFraction_Data=0.2;   %变异概率

 
4 运行结果
 
4.1 GA的进化曲线，含最优的适应度值与平均适应度
 

 4.2 GA优化ELM预测的结果与误差分析
 

 4.3 优化前后的预测曲线对比 (绿色为实测值, 红色为GA-ELM预测值, 蓝色为ELM预测值)
 
 
5 MATLAB代码
 
1. ELM极限学习机回归预测
 
2. 遗传算法GA优化ELM极限学习机预测
 
3. 粒子群算法PSO优化ELM极限学习机预测
 
4. ELM极限学习机数据分类
 
下一篇博客
 
基于粒子群算法优化的ELMAN动态递归神经网络预测-附代码