OS-ELM
OS-ELM是ELM的一个进化版本,使得ELM具有了增量学习的潜质,也就是说,我们前期通过一个批量学习,获得一个基础的β,后期
再有新的数据进来,我们就不用再将以前的数据拿来再处理一遍了,只需要将新的数据处理结果按照一定的公式添加进去,获得新的β就
可以了,这样一来大大减少了数据的处理量,使得算法不至于在越来越大规模的数据上崩溃,进入获得了无限的发展潜力,实现自我进
化。
算法推导过程:
算法推导过程:
woodbury formula公式推导如下:
公式推导如下:
该公式用在了下面代码中求解迭代β的地方(被注释掉的函数)
的地方(被注释掉的函数)
该公式用在了下面代码中求解迭代
代码实现:
from numpy import *
def sigmoid(x):
out = 1 / (1 + exp(-x))
return out
def getH(dataMat, wMat, baise):
out = dataMat * wMat
h = out + baise
H = sigmoid(h)
return H
def getT(label, num, n):
out = zeros((num, n))
for i in range(len(label)):
if label[i] > 1:
out[i][2] = 1
elif label[i] > 0:
out[i][1] = 1
else:
out[i][0] = 1
return out
def getNewT(label,n):
out = zeros((1, n))
q = int(label)
out[0][q] = 1
return out
def getBata(H, T):
K = H.T * H
bata = K.I * H.T * T
return bata,K
求迭代更新的β
求迭代更新的
下面两种实现效果相同,只不过一个是靠机器求逆,一个是通过数学公式求逆(注释掉的函数)
下面两种实现效果相同,只不过一个是靠机器求逆,一个是通过数学公式求逆(注释掉的函数)
'''
def getNewBeta(oldbeta,oldK,newH,newT):
newK = oldK - oldK*newH.T*(eye(1,1)+newH*oldK*newH.T).I*newH*oldK
newBeta = oldbeta+newK*newH.T*(newT-newH*oldbeta)
return newBeta,newK
'''
def getNewBeta(oldbeta,oldK,newH,newT):
newK = oldK+newH.T * newH
newBeta = oldbeta + newK.I * newH.T * (newT - newH * oldbeta)
return newBeta, newK
def predict(H, bata):
prediction = H * bata
return prediction
def loadData(filename):
fr = open(filename)
lines = fr.readlines()
dataArr = []
labels = []
dataTest = []
labTest = []
a = 0
for line in lines:
curr = []
words = line.strip().split('\t')
m = len(words)
for i in range(m - 1):
curr.append(float(words[i]))
if a < 500:
dataArr.append(curr)
labels.append(float(words[-1]))
else:
dataTest.append(curr)
labTest.append(float(words[-1]))
a+=1
return dataArr, labels,dataTest,labTest
def getWandB(in_size, out_size):
Weights = mat(random.rand(in_size, out_size) * 2 - 1) # -1~1
bias = mat(random.rand(1, out_size) * 2 - 1)
return Weights, bias
dataArr, labels,dataTest,labTest = loadData('testSet3.txt')
m, n = shape(dataArr)
print len(labTest)
确定权值和偏移值,一旦确定就不再更换,注意,批量处理和后期增量处理使用的权值和偏移量相同。改变的只有输出
权值β,这也是ELM为什么这么快的原因。
weight, bias = getWandB(n, 10)
T = getT(labels, m, 3)
T = T * 2 - 1
H = getH(mat(dataArr), weight, bias)
newBeta,newK = getBata(H, T)
进行输出权值β的更新迭代
for i in range(len(dataTest)):
newH = getH(mat(dataTest[i]),weight,bias)
newT = getNewT(labTest[i],3)
newT = newT * 2 - 1
newBeta,newK = getNewBeta(newBeta,newK,newH,newT)
测试准确率
errornum = 0.0
for i in range(len(dataTest)):
newH = getH(mat(dataTest[i]), weight, bias)
newT = getNewT(labTest[i], 3)
newT = newT * 2 - 1
prediction = predict(newH,newBeta)
#print newT
if argmax(prediction[0,:])!=argmax(newT[0,:]):
errornum+=1
print "accuracy rate = %f" %(1.0-errornum/500)
运行结果:
运行结果:
accuracy rate = 0.996000
当隐层神经元数量达到20时,准确率基本稳定在
当隐层神经元数量达到
时,准确率基本稳定在100%