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 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 class train_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 = new DenseMatrix(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 = new DenseMatrix(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 = new DenseMatrix(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 = new DenseMatrix(numTrainData,NumberofOutputNeurons); T.transpose(transT); } long start_time_train = System.currentTimeMillis(); BiasofHiddenNeurons = (DenseMatrix) Matrices.random(NumberofHiddenNeurons, 1); DenseMatrix tempH = new DenseMatrix(NumberofHiddenNeurons, numTrainData); InputWeight.mult(P, tempH); //DenseMatrix ind = new DenseMatrix(1, numTrainData); DenseMatrix BiasMatrix = new DenseMatrix(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 = new DenseMatrix(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 = new DenseMatrix(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 block e.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 = new DenseMatrix(NumberofInputNeurons,numTestData); ttestT.transpose(testT); ttestP.transpose(testP); long start_time_test = System.currentTimeMillis(); DenseMatrix tempH_test = new DenseMatrix(NumberofHiddenNeurons, numTestData); InputWeight.mult(testP, tempH_test); DenseMatrix BiasMatrix2 = new DenseMatrix(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 = new DenseMatrix(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 = new DenseMatrix(numTestData,NumberofHiddenNeurons); H_test.transpose(transH_test); DenseMatrix Yout = new DenseMatrix(numTestData,NumberofOutputNeurons); transH_test.mult(OutputWeight,Yout); DenseMatrix testY = new DenseMatrix(NumberofOutputNeurons,numTestData); Yout.transpose(testY); long end_time_test = System.currentTimeMillis(); TestingTime = (end_time_test - start_time_test)*1.0f/1000; //REGRESSION if(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); } //CLASSIFIER else if(Elm_Type == 1){ DenseMatrix temptestT = new DenseMatrix(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 = new DenseMatrix(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*NumberofOutputNeurons private 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 = new DenseMatrix(NumberofInputNeurons,numTestData); ttestT.transpose(testT); ttestP.transpose(testP); DenseMatrix tempH_test = new DenseMatrix(NumberofHiddenNeurons, numTestData); InputWeight.mult(testP, tempH_test); DenseMatrix BiasMatrix2 = new DenseMatrix(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 = new DenseMatrix(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 = new DenseMatrix(numTestData,NumberofHiddenNeurons); H_test.transpose(transH_test); DenseMatrix Yout = new DenseMatrix(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 block e.printStackTrace(); } numTestData = test_set.numRows(); NumberofInputNeurons = test_set.numColumns() - 1; double rsum = 0; double []actual = new double[numTestData]; double [][]data = new double[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); } } 1 介绍 我们在这提出一个基于在线极限学习机和案例推理的混合预测系统。人工神经网络(ANN)被认为是最强大和普遍的预测器，广泛的应用于诸如模式识别、拟合、分类、决策和预测等领域。它已经被证明在解决复杂的问题上是非常有效的。然而，神经网络不像其他学习策略，如决策树技术，不太常用于实际数据挖掘的问题,特别是在工业生产中，如软测量技术。这是部分由于神经网络的“黑盒”的缺点，神经网络没能力来解释自己的推理过程和推理依据，不能向用户提出必要的询问，而且当数据不充分的时候，神经网络就无法进行工作。所以需要神经网络和其他智能算法结合，弥补这个缺点。 案例推理的基本思想是：相似的问题有相似的解（类似的问题也有类似的解决方案）。经验存储在案例中，存储的案例通常包括了问题的描述部分和解决方案部分；在解决一个新问题时，把新问题的描述呈现给CBR系统，系统按照类似案件与类似的问题描述来检索。系统提交最类似的经验(解决方案部分)，然后重用来解决新的问题。CBR经过二十多年的发展，已经成为人工智能与专家系统的一种强有力的推理技术。作为一种在缺乏系统模型而具有丰富经验场合下的问题求解方法，CBR系统在故障诊断、医疗卫生、设计规划集工业过程等大量依赖经验知识的领域取得了很大的成功。但是由于案例属性权值的设定和更新问题，CBR 在复杂工业过程的建模与控制工作仍处于探索阶段，尤其对于预测回归问题，研究的更少。 不同于传统学习理论，2006年南洋理工大学Huang GB教授提出了一种新的前馈神经网络训练方法-极限学习机（ELM），能够快速的训练样本（比BP神经网络训练速度提高了数千倍），为在线学习和权值跟新奠定了基础。我们提出的基于在线极限学习机的案例推理混合系统，能够使用案例来解释神经网络，用在线学习的方法为案例检索提供案例权值和更新案例权值，为在线预测某些工业生产提供了较好的模型。 2使用在线极限学习机训练特征权值的算法 2.1 训练和更新样本特征权值（不是训练样本权值的，要记好，从新选择小题目） 在这一节中我们提出如何使用在线极限学习机确定和更新案例库属性权值。首先使用固定型极限学习机【】对给出的数据进行充分的训练，使训练的样本达到预期的误差范围内。通过训练后的网络和 昆明理工大学信息工程与自动化学院学生实验报告 （2011 —2012 学年第二学期） 一、实验目的和要求 银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 二、实验内容 1．设计进程对各类资源最大申请表示及初值确定。 2．设定系统提供资源初始状况。 3．设定每次某个进程对各类资源的申请表示。 4．编制程序，依据银行家算法，决定其申请是否得到满足。 三、实验说明 1．数据结构 假设有M个进程N类资源，则有如下数据结构： MAX[M*N] M个进程对N类资源的最大需求量 AVAILABLE[N] 系统可用资源数 ALLOCATION[M*N] M个进程已经得到N类资源的资源量 NEED[M*N] M个进程还需要N类资源的资源量 2．银行家算法 设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。 (1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。 (2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE=AVAILABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST (4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 3．安全性检查 (1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE (2)从进程集合中找到一个满足下述条件的进程， FINISH[i]=FALSE NEED<=WORK 如找到，执行(3)；否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 WORK=WORK+ALLOCATION FINISH=TRUE GO TO 2 (4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。 四、程序流程图 初始化算法流程图： Kalman_Filter(float Gyro,float Accel) { Angle+=(Gyro - Q_bias) * dt; Pdot[0]=Q_angle - PP[0][1] - PP[1][0]; Pdot[1]= - PP[1][1]; Pdot[2]= - PP[1][1]; Pdot[3]=Q_gyro; PP[0][0] += Pdot[0] * dt; PP[0][1] += Pdot[1] * dt; PP[1][0] += Pdot[2] * dt; PP[1][1] += Pdot[3] * dt; Angle_err = Accel - Angle; PCt_0 = C_0 * PP[0][0]; PCt_1 = C_0 * PP[1][0]; E = R_angle + C_0 * PCt_0; K_0 = PCt_0 / E; K_1 = PCt_1 / E; t_0 = PCt_0; t_1 = C_0 * PP[0][1]; PP[0][0] -= K_0 * t_0; PP[0][1] -= K_0 * t_1; PP[1][0] -= K_1 * t_0; PP[1][1] -= K_1 * t_1; Angle += K_0 * Angle_err; Q_bias += K_1 * Angle_err; Gyro_x = Gyro - Q_bias; } 首先是卡尔曼滤波的5个方程： -=--+（1）先验估计 X k k AX k k Bu k (|1)(1|1)() -=--+（2）协方差矩阵的预测(|1)(1|1)' P k k AP k k A Q 淮海工学院计算机工程学院实验报告书 课程名：《操作系统原理》 题目：银行家算法 班级： 学号： 姓名： 一、实验目的 银行家算法是操作系统中避免死锁的典型算法，本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。 实验环境 Turbo C 2.0/3.0或VC++6.0 实验学时 4学时，必做实验。 二、实验内容 用C语言编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情形。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。 三、实验说明 实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知（这些数值可以在程序运行时动态输入），而算法中其他数据结构的值（包括Need[i,j]、Available[j]）则需要由程序根据已知量的值计算产生。 四、实验步骤 1、理解本实验中关于两种调度算法的说明。 2、根据调度算法的说明，画出相应的程序流程图。 3、按照程序流程图，用C语言编程并实现。 五、分析与思考 1．要找出某一状态下所有可能的安全序列，程序该如何实现？ 答：要找出这个状态下的所有可能的安全序列，前提是要是使这个系统先处于安全状态，而系统的状态可通过以下来描述： 进程剩余申请数=最大申请数-占有数；可分配资源数=总数-占有数之和； 通过这个描述来算出系统是否安全，从而找出所有的安全序列。 2．银行家算法的局限性有哪些？ 卡尔曼滤波的基本原理及应用卡尔曼滤波在信号处理与系统控制领域应用广泛，目前，正越来越广泛地应用于计算机应用的各个领域。为了更好地理解卡尔曼滤波的原理与进行滤波算法的设计工作，主要从两方面对卡尔曼滤波进行阐述：基本卡尔曼滤波系统模型、滤波模型的建立以及非线性卡尔曼滤波的线性化。最后，对卡尔曼滤波的应用做了简单介绍。 卡尔曼滤波属于一种软件滤波方法，其基本思想是：以最小均方误差为最佳估计准则，采用信号与噪声的状态空间模型，利用前一时刻的估计值和当前时刻的观测值来更新对状态变量的估计，求出当前时刻的估计值，算法根据建立的系统方程和观测方程对需要处理的信号做出满足最小均方误差的估计。 最初的卡尔曼滤波算法被称为基本卡尔曼滤波算法，适用于解决随机线性离散系统的状态或参数估计问题。卡尔曼滤波器包括两个主要过程：预估与校正。预估过程主要是利用时间更新方程建立对当前状态的先验估计，及时向前推算当前状态变量和误差协方差估计的值，以便为下一个时间状态构造先验估计值；校正过程负责反馈，利用测量更新方程在预估过程的先验估计值及当前测量变量的基础上建立起对当前状态的改进的后验估计。这样的一个过程，我们称之为预估－校正过程，对应的这种估计算法称为预估－校正算法。以下给出离散卡尔曼滤波的时间更新方程和状态更新方程。 时间更新方程： 状态更新方程： 在上面式中，各量说明如下： A：作用在X k-1上的n×n 状态变换矩阵 B：作用在控制向量U k-1上的n×1 输入控制矩阵 H：m×n 观测模型矩阵，它把真实状态空间映射成观测空间 P k－：为n×n 先验估计误差协方差矩阵 P k：为n×n 后验估计误差协方差矩阵 Q：n×n 过程噪声协方差矩阵 R：m×m 过程噪声协方差矩阵 I：n×n 阶单位矩阵K k：n×m 阶矩阵，称为卡尔曼增益或混合因数 随着卡尔曼滤波理论的发展，一些实用卡尔曼滤波技术被提出来，如自适应滤波，次优滤波以及滤波发散抑制技术等逐渐得到广泛应用。其它的滤波理论也迅速发展，如线性离散系统的分解滤波（信息平方根滤波，序列平方根滤波，UD 分解滤波），鲁棒滤波（H∞波）。 非线性样条自适应滤波：这是一类新的非线性自适应滤波器，它由一个线性组合器后跟挠性无记忆功能的。涉及的自适应处理的非线性函数是基于可在学习 《银行家算法的模拟实现》 --实验报告 题目: 银行家算法的模拟实现 专业: 班级: 组员: 指导老师: 一、实验目的 死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。 二、实验内容 模拟实现银行家算法实现死锁避免。要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。 三、实验分析过程 1、整个银行家算法的思路。 先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。 1)进程一开始向系统提出最大需求量. 2)进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量. 3)若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的 剩余资源量,若不超出,则分配,否则等待 2、算法用到的主要数据结构和C语言说明。 （1）、可利用资源向量INT A V AILABLE[M] M为资源的类型。 （2）、最大需求矩阵INT MAX[N][M] N为进程的数量。 （3）、已分配矩阵INT ALLOCA TION[N][M] （4）、还需求矩阵INT NEED[N][N] （5）、申请各类资源数量int Request[x]; // （6）、工作向量int Work[x]; （7）、int Finish[y]; //表示系统是否有足够的资源分配给进程，0为否，非0为是 3、银行家算法（主程序） （1）、系统初始化。输入进程数量，资源种类，各进程已分配、还需求各资源数量，各资源可用数量等 （2）、输入用户的请求三元组（I，J，K），为进程I申请K个J类资源。 （3）、检查用户的请求是否小于还需求的数量，条件是K<=NEED[I,J]。如果条件不符则提示重新输入，即不允许索取大于需求量 （4）、检查用户的请求是否小于系统中的可利用资源数量，条件是K<=A V ALIABLE[I,J]。 如果条件不符则申请失败，阻塞该进程，重新进行进程动态资源申请（使用goto语句） （5）、进行资源的预分配，语句如下： A V ALIBLE[I][J]= A V ALIBLE[I][J]-K； ALLOCATION[I][J]= ALLOCATION[I][J]+K； NEED[I][J]=NEED[I][J]-K； 卡尔曼滤波研究综述 1 卡尔曼滤波简介 1.1卡尔曼滤波的由来 1960年卡尔曼发表了用递归方法解决离散数据线性滤波问题的论文-《A New Approach to Linear Filtering and Prediction Problems》（线性滤波与预测问题的新方法），在这篇文章里一种克服了维纳滤波缺点的新方法被提出来，这就是我们今天称之为卡尔曼滤波的方法。卡尔曼滤波应用广泛且功能强大，它可以估计信号的过去和当前状态甚至能估计将来的状态即使并不知道模型的确切性质。 其基本思想是以最小均方误差为最佳估计准则，采用信号与噪声的状态空间模型利用前一时刻的估计值和当前时刻的观测值来更新对状态变量的估计，求出当前时刻的估计值。算法根据建立的系统方程和观测方程对需要处理的信号做出满足最小均方误差的估计。 对于解决很大部分的问题，它是最优，效率最高甚至是最有用的。它的广泛应用已经超过30年，包括机器人导航，控制，传感器数据融合甚至在军事方面的雷达系统以及导弹追踪等等。近年来更被应用于计算机图像处理，例如头脸识别，图像分割，图像边缘检测等等。 1.2标准卡尔曼滤波-离散线性卡尔曼滤波 为了描述方便我们作以下假设：物理系统的状态转换过程可以描述为一个离散时间的随机过程；系统状态受控制输入的影响；系统状态及观测过程都不可避免受噪声影响；对系统状态是非直接可观测的。在以上假设前提下，得到系统的状体方程和观测方程。 X ?? 1-1 式中:X k 为状态向量,L k 为观测向量,Φk,k-1为状态转移矩阵,U k-1为控制向量,一般 不考虑,Γk,k-1,B k 为系数矩阵,Ωk-1为系统动态噪声向量,Δk 为观测噪声向量,其随机模 型为 E(Ωk ) =0;E(Δk ) =0;cov(Ωk ,Ωj ) = D Ω(k )δkj , cov(Δk ,Δj ) = D k (k )δkj ;cov(Ωk ,Δj ) =0;E(X 0) =μx(0) var(X 0) = D(X 0);cov(X 0,Ωk ) =0;cov(X 0,Δk ) =0. 1-2 卡尔曼滤波递推公式为 X ∧(k/k) = X ∧(k/k-1)+J k (L k -B k X ∧(k/k-1)), D(k/k) = (E-J k B k )D x (k/k-1), J k = D x (k/k-1)BT k [B k D x (k/k-1)]B T k +D Δ(k)]-1, X ∧ (k/k-1) =Φk ,k-1X ∧ (k-1/k-1), D x (k/k-1) =Φk ,k-1D x (k-1/k-1)ΦT k ,k-1+Γk ,k-1D Δ(k-1)ΓT k ,k-1. 1-3 2 几种最新改进型的卡尔曼滤波算法。 2.1 近似二阶扩展卡尔曼滤波 标准的卡尔曼滤波只适用于线性系统，而工程实际问题涉及的又大多是非 线性系统，于是基于非线性系统线性化的扩展卡尔曼滤波(EKF)在上世纪70年代 被提出,目前已经成为非线性系统中广泛应用的估计方法。近似二阶扩展卡尔曼 滤 波方法(AS-EKF)基于线性最小方差递推滤波框架,应用均值变换的二阶近似从 而得到非线性系统的递推滤波滤波框架 该滤波基于线性最小方差递推框架，状态X 的最小方差估计为 自适应卡尔曼滤波 卡尔曼滤波发散的原因 如果卡尔曼滤波是稳定的，随着滤波的推进，卡尔曼滤波估计的精度应该越来越高，滤波误差方差阵也应趋于稳定值或有界值。但在实际应用中，随着量测值数目的增加，由于估计误差的均值和估计误差协方差可能越来越大，使滤波逐渐失去准确估计的作用，这种现象称为卡尔曼滤波发散。 引起滤波器发散的主要原因有两点： （1）描述系统动力学特性的数学模型和噪声估计模型不准确，不能直接真实地反映物理过程，使得模型与获得的量测值不匹配而导致滤波发散。这种由于模型建立过于粗糙或失真所引起的发散称为滤波发散。 （2）由于卡尔曼滤波是递推过程，随着滤波步数的增加，舍入误差将逐渐积累。如果计算机字长不够长，这种积累误差很有可能使估计误差方差阵失去非负定性甚至失去对称性，使滤波增益矩阵逐渐失去合适的加权作用而导致发散。这种由于计算舍入误差所引起的发散称为计算发散。 针对上述卡尔曼滤波发散的原因，目前已经出现了几种有效抑制滤波发散的方法，常用的有衰减记忆滤波、限定记忆滤波、扩充状态滤波、有限下界滤波、平方根滤波、和自适应滤波等。这些方法本质上都是以牺牲滤波器的最优性为代价来抑制滤波发散，也就是说，多数都是次优滤波方法。 自适应滤波 在很多实际系统中，系统过程噪声方差矩阵Q和量测误差方差阵R事先是不知道的，有时甚至连状态转移矩阵 或量测矩阵H也不能确切建立。如果所建立的模型与实际模型不符可能回引起滤波发散。自适应滤波就是这样一种具有抑制滤波发散作用的滤波方法。在滤波过程中，自适应滤波一方面利用量测值修正预测值，同时也对未知的或不确切的系统模型参数和噪声统计参数进行估计修正。自适应滤波的方法很多，包括贝叶斯法、极大似然法、相关法与协方差匹配法，其中最基本也是最重要的是相关法，而相关法可分为输出相关法和新息相关法。 卡尔曼滤波算法实现代码 C++实现代码如下： ============================kalman.h================= =============== // kalman.h: interface for the kalman class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__IN CLUDED_) #define AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLU DED_ #if _MSC_VER > 1000 #pragma once #endif// _MSC_VER > 1000 #include kalman(int x=0,int xv=0,int y=0,int yv=0); //virtual ~kalman(); }; #endif// !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C 0__INCLUDED_) ============================kalman.cpp=============== ================= #include "kalman.h" #include 1 极限学习机 传统前馈神经网络采用梯度下降的迭代算法去调整权重参数，具有明显的缺陷： 1） 学习速度缓慢，从而计算时间代价增大； 2） 学习率难以确定且易陷入局部最小值； 3）易出现过度训练，引起泛化性能下降。 这些缺陷成为制约使用迭代算法的前馈神经网络的广泛应用的瓶颈。针对这些问题，huang 等依据摩尔-彭罗斯（MP ）广义逆矩阵理论提出了极限学习(ELM)算法，该算法仅通过一步计算即可解析求出学习网络的输出权值，同迭代算法相比，极限学习机极大地提高了网络的泛化能力和学习速度。 极限学习机的网络训练模型采用前向单隐层结构。设,,m M n 分别为网络输入层、隐含层和输出层的节点数，()g x 是隐层神经元的激活函数，i b 为阈值。设有N 个 不同样本(),i i x t ，1i N ≤≤，其中[][]1212,,...,,,,...,T T m n i i i im i i i in x x x x R t t t t R =∈=∈，则极限学习机的网络训练模型如 图1所示。 图1 极限学习机的网络训练模型 极限学习机的网络模型可用数学表达式表示如下： ()1,1,2,...,M i i i i j i g x b o j N βω=+==∑ 式中，[]12,,...,i i i mi ωωωω=表示连接网络输入层节点与第i 个隐层节点的输入权值向量；[]12,,...,T i i i in ββββ=表示连接第i 个隐层节点与网络输出层节点的输出权值向量；[]12,,...,T i i i in o o o o =表示网络输出值。 极限学习机的代价函数E 可表示为 ()1,N j j j E S o t β==-∑ 式中，(),,1,2,...,i i s b i M ω==，包含了网络输入权值及隐层节点阈值。Huang 等指出极限学习机的悬链目标就是寻求最优的S ，β，使得网络输出值与对应实际值误差最小，即()()min ,E S β。 ()()min ,E S β可进一步写为 ()()()111,,min ,min ,...,,,...,,,...,i i M M N b E S H b b x x T ωβ βωωβ=- 式中，H 表示网络关于样本的隐层输出矩阵，β表示输出权值矩阵，T 表示样本集的目标值矩阵，H ，β，T 分别定义如下： ()()()()()111111111,...,,,...,,,...,M M M M N N m N M N M g x b g x b H b b x x g x b g x b ωωωωωω?++????=????++? ? 11,T T T T M N M N N N t T t βββ??????????==???????????? 极限学习机的网络训练过程可归结为一个非线性优化问题。当网络隐层节点的激活函数无限可微时，网络的输入权值和隐层节点阈值可随机赋值，此时矩阵H 为一常数矩阵，极限学习机的学习过程可等价为求取线性系统H T β=最小 范数的最小二乘解?β ，其计算式为 ?H T β += 式中H +时矩阵H 的MP 广义逆。 2实验结果 计算机操作系统实验报告 一、实验名称：银行家算法 二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简 单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 三、问题分析与设计： 1、算法思路：先对用户提出的请求进行合法性检查，即检查请求是 否大于需要的，是否大于可利用的。若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。若安全，则分配；若不安 全，则拒绝申请，恢复到原来的状态，拒绝申请。 2、银行家算法步骤：（1）如果Requesti＜or =Need,则转向步骤(2)； 否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。 （2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。 （3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的 数值： Available=Available-Request[i]; Allocation=Allocation+Request; Need=Need-Request; (4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状 态。 3、安全性算法步骤： （1）设置两个向量 ①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation; ②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令 Finish[i]=true。 （2）从进程集合中找到一个能满足下述条件的进程： ①Finish[i]=false ②Need 武汉理工大学华夏学院课程设计报告书 课程名称：操作系统原理 题目：编程序模拟银行家算法 系名：信息工程系 专业班级：软件1121 姓名：钟伟 学号：10212812120 指导教师:苏永红 2014年 6 月13 日 武汉理工大学华夏学院信息工程系 课程设计任务书 课程名称：操作系统原理课程设计指导教师：苏永红 班级名称：软件1121 开课系、教研室：软件与信息安全 一、课程设计目的与任务 操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练，加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题 和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。 学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。 二、课程设计的内容与基本要求 1、课程设计题目 编程序模拟银行家算法 2、课程设计内容 本课程设计要求在Linux操作系统，GCC编译环境下开发。 银行家算法是避免死锁的一种重要方法，本实验要求用用c/c++语言在Linux操作系统 环境下编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 思想：将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存 资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。银行家 对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借 款后能在有限的时间内归还。用银行家算法分配资源时，测试进程对资源的最大需求量，若 现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个 进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限 的时间内得到所需资源则称系统处于安全状态。 3、设计报告撰写格式要求： 1设计题目与要求 2 设计思想 3系统结构 4 数据结构的说明和模块的算法流程图 5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明 6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况） 7 自我评价与总结 8 附录：程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释； 卡尔曼滤波算法总结-标准化文件发布号：（9556-EUATWK-MWUB-WUNN-INNUL-DDQTY-KII 2015.12.12 void Kalman_Filter(float Gyro,float Accel) { Angle+=(Gyro - Q_bias) * dt; Pdot[0]=Q_angle - PP[0][1] - PP[1][0]; Pdot[1]= - PP[1][1]; Pdot[2]= - PP[1][1]; Pdot[3]=Q_gyro; PP[0][0] += Pdot[0] * dt; PP[0][1] += Pdot[1] * dt; PP[1][0] += Pdot[2] * dt; PP[1][1] += Pdot[3] * dt; Angle_err = Accel - Angle; PCt_0 = C_0 * PP[0][0]; PCt_1 = C_0 * PP[1][0]; E = R_angle + C_0 * PCt_0; K_0 = PCt_0 / E; K_1 = PCt_1 / E; t_0 = PCt_0; t_1 = C_0 * PP[0][1]; PP[0][0] -= K_0 * t_0; PP[0][1] -= K_0 * t_1; PP[1][0] -= K_1 * t_0; PP[1][1] -= K_1 * t_1; Angle += K_0 * Angle_err; Q_bias += K_1 * Angle_err; Gyro_x = Gyro - Q_bias; } 首先是卡尔曼滤波的5个方程： (|1)(1|1)() X k k AX k k Bu k -=--+（1）先验估计 (|1)(1|1)'P k k AP k k A Q -=--+（2）协方差矩阵的预测 ()(|1)'/(|1)')Kg k P k k H HP k k H R =--+（3）计算卡尔曼增益 (|)(|1)()(()(|1))X k k X k k Kg k Z k HX k k =-+--（4）进行修正 5个式子比较抽象，现在直接用实例来说： 一、卡尔曼滤波第一个式子 对于角度来说，我们认为此时的角度可以近似认为是上一时刻的角度值加上上一时刻陀螺仪测得的角加速度值乘以时间，因为d dt θω=?，角度微分等于时间的微分乘以角速度。但是陀螺仪有个静态漂移（而且还是变化的），静态漂移就是静止了没有角速度然后陀螺仪也会输出一个值，这个值肯定是没有意义的，计算时要把它减去。 由此我们得到了当前角度的预测值Angle Angle=Angle+(Gyro - Q_bias) * dt; 其中等号左边Angle 为此时的角度，等号右边Angle 为上一时刻的角度，Gyro 为陀螺仪测的角速度的值，dt 是两次滤波之间的时间间隔，我们的运行周期是4ms 或者6ms 。 同时 Q_bias 也是一个变化的量。 但是就预测来说认为现在的漂移跟上一时刻是相同的，即 Q_bias=Q_bias 将上面两个式子写成矩阵的形式 1_0 1_0 Angle dt Angle dt Q bias Q bia o s Gyr -= + 得到上式，这个式子对应于卡尔曼滤波的第一个式子 (|1)(1|1)() X k k AX k k Bu k -=--+ (|)(|1) P k k I Kg k H P k k =--（（））（5）更新协方差阵 卡尔曼滤波简介及其算法实现代码 卡尔曼滤波算法实现代码（C，C＋＋分别实现） 卡尔曼滤波器简介 近来发现有些问题很多人都很感兴趣。所以在这里希望能尽自己能力跟大家讨论一些力所能及的算法。现在先讨论一下卡尔曼滤波器，如果时间和能力允许，我还希望能够写写其他的算法，例如遗传算法，傅立叶变换，数字滤波，神经网络，图像处理等等。 因为这里不能写复杂的数学公式，所以也只能形象的描述。希望如果哪位是这方面的专家，欢迎讨论更正。 卡尔曼滤波器– Kalman Filter 1．什么是卡尔曼滤波器 （What is the Kalman Filter?） 在学习卡尔曼滤波器之前，首先看看为什么叫“卡尔曼”。跟其他著名的理论（例如傅立叶变换，泰勒级数等等）一样，卡尔曼也是一个人的名字，而跟他们不同的是，他是个现代人！ 卡尔曼全名Rudolf Emil Kalman，匈牙利数学家，1930年出生于匈牙利首都布达佩斯。1953，1954年于麻省理工学院分别获得电机工程学士及硕士学位。1957年于哥伦比亚大学获得博士学位。我们现在要学习的卡尔曼滤波器，正是源于他的博士论文和1960年发表的论文《A New Approach to Linear Filtering and Prediction Problems》（线性滤波与预测问题的新方法）。如果对这编论文有兴趣，可以到这里的地址下载： https://www.wendangku.net/doc/ad15563517.html,/~welch/media/pdf/Kalman1960.pdf。 简单来说，卡尔曼滤波器是一个“optimal recursive data processing algorithm（最优化自回归数据处理算法）”。对于解决很大部分的问题，他是最优，效率最高甚至是最有用的。他的广泛应用已经超过30年，包括机器人导航，控制，传感器数据融合甚至在军事方面的雷达系统以及导弹追踪等等。近年来更被应用于计算机图像处理，例如头脸识别，图像分割，图像边缘检测等等。 2．卡尔曼滤波器的介绍 （Introduction to the Kalman Filter） 为了可以更加容易的理解卡尔曼滤波器，这里会应用形象的描述方法来讲解，而不是像大多数参考书那样罗列一大堆的数学公式和数学符号。但是，他的5条公式是其核心内容。结合现代的计算机，其实卡尔曼的程序相当的简单，只要你理解了他的那5条公式。 在介绍他的5条公式之前，先让我们来根据下面的例子一步一步的探索。 假设我们要研究的对象是一个房间的温度。根据你的经验判断，这个房间的温度是恒定的，也就 Kalman 滤波算法 姓名：刘金强 专业：控制理论与控制工程 学号：2007255 ◆实验目的： （1）、掌握klman 滤波实现的原理和方法 （2）、掌握状态向量预测公式的实现过程 （3）、了解Riccati 差分方程实现的过程和新息的基本性质和过程的计算 ◆实验要求： 问题： F=[a1,a2,a3],其中a1=[1.0 0 0]的转置，a2=[0.3 1.0 0]的转置，a3=[0.1 0.2 0.4]的转置，x(0)=[3,-1,2]的转置；C=[b1,b2,b3],其中b1=[0.3 0.5]的转置，b2=[1,0.4]的转置，b3=[0.8 -0.7]的转置；V1(n)=[0 0 n1(n)sin(0.1n)]的转置，V2(n)=[n2(n) n3(n)];n1(n)为均值为零，方差为1的均匀分布白噪声;n2(n),n3(n)为均值为0，方差为0.1的均匀分布白噪声,n1(n),n2(n),n3(n)相互独立，试用卡尔曼滤波器算法估计x^(n). ◆实验原理： 初始条件： 1?(1)x =E{x(1)} K(1,0)=E{[x(1)- (1)x ][x(1)- (1)H x ]},其中(1)x =E{x(1)} 输入观测向量过程： 观测向量序列={y(1),…………y(n)} 已知参数： 状态转移矩阵F(n+1,n) 观测矩阵C(n) 过程噪声向量的相关矩阵1()Q n 观测噪声向量的相关矩阵2()Q n 计算：n=1,2,3,………………. G(n)=F(n+1,n)K(n,n+1) ()H C n 12[()(,1)()()]H C n K n n C n Q n --+ Kalman 滤波器是一种线性的离散时间有限维系统。Kalman 滤波器的估计性能是：它使滤波后的状态估计误差的相关矩阵P(n)的迹最小化。这意味着，kalman 滤波器是状态向量x(n)的线性最小方差估计。 ◆实验结果： ◆程序代码： （1）主程序 简单易学的机器学习算法——极限学习机(ELM) 一、极限学习机的概念 极限学习机(Extreme Learning Machine) ELM，是由黄广斌提出来的求解单隐层神经网络的算法。 ELM最大的特点是对于传统的神经网络，尤其是单隐层前馈神经网络(SLFNs)，在保证学习精度的前提下比传统的学习算法速度更快。 二、极限学习机的原理 ELM是一种新型的快速学习算法，对于单隐层神经网络，ELM 可以随机初始化输入权重和偏置并得到相应的输出权重。 (选自黄广斌老师的PPT) 对于一个单隐层神经网络(见Figure 1)，假设有个任意的样本，其中，。对于一个有个隐层节点的单隐层神经网络可以表示为 其中，为激活函数，为输入权重，为输出权重，是第个隐层单元的偏置。表示和的内积。 单隐层神经网络学习的目标是使得输出的误差最小，可以表示为 即存在，和，使得 可以矩阵表示为 其中，是隐层节点的输出，为输出权重，为期望输出。 ， 为了能够训练单隐层神经网络，我们希望得到，和，使得 其中，，这等价于最小化损失函数 传统的一些基于梯度下降法的算法，可以用来求解这样的问题，但是基本的基于梯度的学习算法需要在迭代的过程中调整所有参数。而在ELM 算法中, 一旦输入权重和隐层的偏置被随机确定，隐层的输出矩阵就被唯一确定。训练单隐层神经网络可以转化为求解一个线性系统。并且输出权重可以被确定 其中，是矩阵的Moore-Penrose广义逆。且可证明求得的解的范数是最小的并且唯一。 三、实验 我们使用《简单易学的机器学习算法——Logistic回归》中的实验数据。 原始数据集 我们采用统计错误率的方式来评价实验的效果，其中错误率公式为： 对于这样一个简单的问题，。 MATLAB代码 主程序 [plain]view plain copy 课程设计报告课程设计名称共享资源分配与银行家算法 系（部） 专业班级 姓名 学号 指导教师 年月日 目录 一、课程设计目的和意义 (3) 二、方案设计及开发过程 (3) 1.课题设计背景 (3) 2.算法描述 (3) 3.数据结构 (4) 4.主要函数说明 (4) 5.算法流程图 (5) 三、调试记录与分析 四、运行结果及说明 (6) 1．执行结果 (6) 2．结果分析 (7) 五、课程设计总结 (8) 一、程设计目的和意义 计算机科学与技术专业学生学习完《计算机操作系统》课程后，进行的一次全面的综合训练，其目的在于加深催操作系统基础理论和基本知识的理解，加强学生的动手能力.银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法 二、方案设计及开发过程 1.课题设计背景 银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。这时系统将该进程从进程集合中将其清除。此时系统中的资源就更多了。反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。请进程等待 2.算法描述 1）如果Request[i] 是进程Pi的请求向量，如果Request[i，j]=K,表示进程Pi 需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查： 如果Requesti[j]<= Need[i,j]，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。 2）如果Requesti[j]<=Available[j],便转向步骤3，否则，表示尚无足够资源，进程Pi须等待。 3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值： Available[j]:=Available[j]-Requesti[j]; Allocation[i,j]:=Allocation[i,j]+Requesti[j]; Need[i,j]:=Need[i,j]-Requesti[j]; %与传统的学习算法不同，单隐层前馈神经网络(SLFNs)——极限学习机(ELM)对输入权值进行动态选择 %%清空环境变量 elm clc clear close all format compact rng('default') %% 导入数据 % [file,path] = uigetfile('*.xlsx','Select One or More Files', 'MultiSelect', 'on'); % filename=[path file]; filename='CPSO优化ELM实现分类\最终版本训练集.xlsx'; M=xlsread(filename); input=M(:,1:end-1); output=M(:,end); %% 数据预处理 [inputn,maps]=mapminmax(input',0,1); % 输出标签转换为one—hot标签 outputn=one_hot(output); n_samples=size(inputn,2); n=randperm(n_samples); m=floor(0.7*n_samples); Pn_train=inputn(:,n(1:m)); Tn_train=outputn(:,n(1:m)); Pn_valid=inputn(:,n(m+1:end)); Tn_valid=outputn(:,n(m+1:end)); %% 节点个数 inputnum=size(Pn_train,1);%输入层节点 hiddennum=160; %隐含层节点 type='sig';%sin %hardlim %sig%隐含层激活函数 %% tic [IW,B,LW,TF] = elmtrain(Pn_train,Tn_train,hiddennum,'sig'); TY2 = elmpredict(Pn_valid,IW,B,LW,TF); toc % 计算分类概率 prob0=prob_cal(TY2);%第一行为属于0（不滑坡）的概率第二行为属于1（滑坡）的概率，上下两个概率和为1 % 看看准确率 % 验证集分类结果 [~,J]=max(Tn_valid); [~,J1]=max(prob0); disp('优化前') accuracy=sum(J==J1)/length(J) TY2 = elmpredict(Pn_train,IW,B,LW,TF); % 计算分类概率 prob0=prob_cal(TY2);%第一行为属于0（不滑坡）的概率第二行为属于1（滑坡）的概率，上下两个概率和为1 % 看看准确率 % 验证集分类结果极限学习机
实验二 银行家算法报告
卡尔曼滤波算法总结
银行家算法-实验报告
卡尔曼滤波的基本原理及应用
《银行家算法的模拟实现》—实验报告
卡尔曼滤波研究综述
几种卡尔曼滤波算法理论
卡尔曼滤波算法(C--C++两种实现代码)
极限学习机简介
银行家算法实验报告
编程序模拟银行家算法
卡尔曼滤波算法总结
卡尔曼滤波简介及其算法实现代码
Kalman滤波算法
ELM极限学习机相关
银行家算法_实验报告
极限学习机elm代码