def hpELM(data, target): # new ELM method for multi output
# print("This is train data input : ", X_train)
# print("This is train data output: ", T_train)
# print("This is test data input: ", X_test)
# print("This is test data output: ", T_test)
# print("This is predict value: ", T_pred)
# print("This is real value: ", T_test)
# print("This is length of output: ", len(T_pred))
elmList = []
for j in range(100):
X_train, X_test, T_train, T_test = train_test_split(data,
target,
test_size=0.2)
elm = hpelm.ELM(
data.shape[1],
target.shape[1]) # number of data features / number of classes
elm.add_neurons(5000, "sigm")
elm.train(X_train, T_train, 'r')
T_pred = elm.predict(X_test)
print("This is error: ", elm.error(T_test, T_pred))
sum_mean = 0
T_pred_List = []
T_test_List = []
for x in np.nditer(T_pred):
T_pred_List.append(x)
for y in np.nditer(T_test):
T_test_List.append(y)
for i in range(len(T_pred_List)):
sum_mean += (T_pred_List[i] - T_test_List[i])**2
sum_erro = (np.sqrt(sum_mean / len(T_pred_List)))
elmList.append(sum_erro)
return elmList
def run():
X = np.loadtxt("mnist_Xts.txt")
Y = np.loadtxt("mnist_Yts.txt")
X = X[:, (X > 0).sum(axis=0) >= 5].copy() # choose features with at least 5 non-zero entrances
N, d = X.shape
V = np.random.rand(N, 2)*2 - 1
V = (V - V.mean(0)) / V.std(0)
# build initial ELM
L = 18
print "L", L
elm = hpelm.ELM(2, d)
elm.add_neurons(2, 'lin')
elm.add_neurons(L, 'sigm')
H = elm.project(V)
A = H.dot(np.linalg.pinv(np.dot(H.T, H))).dot(H.T)
I, info = elmvis(X, A, slowdown=20)
print info
scalarMap = cm.ScalarMappable(norm=colors.Normalize(vmin=0, vmax=10), cmap=plt.get_cmap('gist_rainbow'))
clr = lambda c: scalarMap.to_rgba(c)
for i in range(X.shape[0]):
plt.text(V[i,0], V[i,1], "%d"%Y[I[i]], size=8, color=clr(Y[I[i]]))
plt.xlim([-2, 2])
plt.ylim([-2, 2])
fig = plt.gcf()
fig.set_size_inches(8, 6)
plt.savefig("plot_mnist.pdf", bbox_inches="tight")
plt.show()
def late_fusion_cnn_hog_hist():
print('1')
cnn_hog_hist_train = combine_3_feature(cnn_X_train, hog_X_train,
hist_X_train)
cnn_hog_hist_val = combine_3_feature(cnn_X_val, hog_X_val, hist_X_val)
cnn_hog_hist_size = cnn_hog_hist_train.shape[1]
autoencoder = hpelm.ELM(inputs=cnn_hog_hist_size,
outputs=cnn_hog_hist_size)
autoencoder.add_neurons(hidden_num, 'sigm')
print('start')
starttime = datetime.datetime.now()
autoencoder.train(cnn_hog_hist_train, cnn_hog_hist_train)
endtime = datetime.datetime.now()
print('time:' + str((endtime - starttime).seconds))
late_fusion_cnn_hog_hist_train = autoencoder.project(cnn_hog_hist_train)
late_fusion_cnn_hog_hist_val = autoencoder.project(cnn_hog_hist_val)
predict = autoencoder.predict(cnn_hog_hist_train)
print('cnn_hog error ' + str(hidden_num) + ':' +
str(cal_error(predict, cnn_hog_hist_train)))
np.save('./data/late_fusion_cnn_hog_hist_train.npy',
late_fusion_cnn_hog_hist_train)
np.save('./data/late_fusion_cnn_hog_hist_val.npy',
late_fusion_cnn_hog_hist_val)
def classification_accuracy(folder, nn, ntype="sigm", mss="V"):
folder = os.path.join(os.path.dirname(__file__), folder)
acc = np.empty((10,))
for i in range(10): # 10 random initializations
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# create validation set
N = Xtr.shape[0]
ix = np.arange(N)
np.random.shuffle(ix)
Xvl = Xtr[ix[:N//5]]
Tvl = Ttr[ix[:N//5]]
Xtr = Xtr[ix[N//5:]]
Ttr = Ttr[ix[N//5:]]
# train ELM
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1])
elm.add_neurons(nn, ntype)
elm.train(Xtr, Ttr, "c", mss, "OP", k=3, kmax=10, Xv=Xvl, Tv=Tvl)
Yts = elm.predict(Xts)
# evaluate classification results
Tts = np.argmax(Tts, 1)
Yts = np.argmax(Yts, 1)
acc[i - 1] = float(np.sum(Yts == Tts)) / Tts.shape[0]
return acc
def regression_accuracy(folder, nn, mss="V"):
folder = os.path.join(os.path.dirname(__file__), folder)
mse = np.empty((10,))
for i in range(10): # 10 random initializations
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# create validation set
N = Xtr.shape[0]
ix = np.arange(N)
np.random.shuffle(ix)
Xvl = Xtr[ix[:N//5]]
Tvl = Ttr[ix[:N//5]]
Xtr = Xtr[ix[N//5:]]
Ttr = Ttr[ix[N//5:]]
# train ELM
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1])
elm.add_neurons(nn, "sigm")
elm.train(Xtr, Ttr, mss, "OP", k=3, Xv=Xvl, Tv=Tvl)
Yts = elm.predict(Xts)
# evaluate classification results
mse[i - 1] = np.mean((Tts - Yts) ** 2)
return mse
def runupdates():
X = np.random.rand(5000, 1000)
N, d = X.shape
V = np.random.rand(N, 2) * 2 - 1
V = (V - V.mean(0)) / V.std(0)
updates = []
i = 0
for N in range(100, 5001, 100):
elm = hpelm.ELM(2, d)
elm.add_neurons(2, 'lin')
elm.add_neurons(50, 'sigm')
H = elm.project(V[:N])
A = H.dot(np.linalg.pinv(np.dot(H.T, H))).dot(H.T)
X1 = X[:N].copy()
_, info = elmvis_c(X1, A, tol=-100, maxupdate=1000, cossim=1, silent=1)
ups_c = info['ups']
X1 = X[:N].copy()
_, info = elmvis_p(X1, A, tol=-100, maxupdate=1000, cossim=1, silent=1)
ups_p = info['ups']
X1 = X[:N].copy()
_, info = elmvis_p(X1,
A,
tol=-100,
maxupdate=1000,
batch=1,
cossim=1,
silent=1)
ups_p1 = info['ups']
X1 = X[:N].copy()
_, info = elmvis_g(X1, A, tol=-100, maxupdate=1000, cossim=1, silent=1)
ups_g = info['ups']
updates.append((ups_c, ups_p, ups_p1, ups_g))
print "%d/5000" % N
updates = np.array(updates)
N = range(100, 5001, 100)
plt.plot(N, updates[:, 0], '--r', linewidth=3, alpha=0.7)
plt.plot(N, updates[:, 1], '--k')
plt.plot(N, updates[:, 2], '-k')
plt.plot(N, updates[:, 3], '-g')
plt.ylabel("updates per second")
plt.legend(("C opt, 1% batch", "Python, 1% batch", "Python", "GPU"))
plt.title("$N$ data points with 1000 features")
plt.xlabel("$N$")
plt.xlim([0, 5000])
#plt.ylim([0, 23000000])
#plt.yticks([0, 1000000, 5000000, 10000000, 15000000, 20000000, 22000000], ["0", "1 mln.", "5 mln.", "10 mln.", "15 mln.", "20 mln.", "22 mln."])
plt.savefig("plot_ups.pdf", bbox_inches="tight")
print "done"
plt.show()
def test_RBFClassification_Iris_BetterThanNaive(self):
X = np.loadtxt("iris/iris_data.txt")
T = np.loadtxt("iris/iris_classes.txt")
elm = hpelm.ELM(4, 3)
elm.add_neurons(10, "rbf_l2")
elm.train(X, T, 'c')
Y = elm.predict(X)
err = elm.error(Y, T)
self.assertLess(err, 0.66)
def test_SigmRegression_Sine_BetterThanNaive(self):
X = np.loadtxt("sine/sine_x.txt")
T = np.loadtxt("sine/sine_t.txt")
elm = hpelm.ELM(1, 1)
elm.add_neurons(10, "sigm")
elm.train(X, T)
Y = elm.predict(X)
err = elm.error(Y, T)
self.assertLess(err, 1)
def __init__(self):
# import model
filename = "models/elm_alm04_Tx_Tn_Ra_deltaT_EnergyT_HorminTx_Tn_prev_Rs.pkl"
with open(filename, 'rb') as file:
self.model = hpelm.ELM(inputs=7, outputs=1)
self.model.load(filename)
# define required inputs
self.parameters = [
'tx', 'tn', 'ra', 'delta_t', 'energyt', 'hormin_tx', 'tx_prev',
'rs'
]
def late_fusion_hog_hist():
hog_hist_train = combine_feature(hog_X_train, hist_X_train)
hog_hist_val = combine_feature(hog_X_val, hist_X_val)
hog_hist_size = hog_hist_train.shape[1]
autoencoder = hpelm.ELM(inputs=hog_hist_size, outputs=hog_hist_size)
autoencoder.add_neurons(hidden_num, 'sigm')
autoencoder.train(hog_hist_train, hog_hist_train)
late_fusion_hog_hist_train = autoencoder.project(hog_hist_train)
late_fusion_hog_hist_val = autoencoder.project(hog_hist_val)
predict = autoencoder.predict(hog_hist_train)
print('hog_hist error ' + str(hidden_num) + ':' +
str(cal_error(predict, hog_hist_train)))
def late_fusion_cnn_hog():
cnn_hog_train = combine_feature(cnn_X_train, hog_X_train)
cnn_hog_val = combine_feature(cnn_X_val, hog_X_val)
cnn_hog_size = cnn_hog_train.shape[1]
autoencoder = hpelm.ELM(inputs=cnn_hog_size, outputs=cnn_hog_size)
autoencoder.add_neurons(hidden_num, 'sigm')
autoencoder.train(cnn_hog_train, cnn_hog_train)
late_fusion_cnn_hog_train = autoencoder.project(cnn_hog_train)
late_fusion_cnn_hog_val = autoencoder.project(cnn_hog_val)
predict = autoencoder.predict(cnn_hog_train)
print('cnn_hog error ' + str(hidden_num) + ':' +
str(cal_error(predict, cnn_hog_train)))
def test_basic_elm_single_machine(self):
"""Just run an ELM with sine function and check training MSE.
"""
n = 1000
err = 0.2
Y = np.linspace(-1, 1, num=n)
X = np.sin(16 * Y) * Y + np.random.randn(n) * err
elm = hpelm.ELM(1, 1)
elm.add_neurons(3, "sigm")
print(elm.nnet.get_B())
elm.train(X, Y)
print(elm.nnet.get_B())
Yt = elm.predict(X)
MSE = np.mean((Y - Yt) ** 2)
self.assertLess(MSE, 0.5)
def regression_accuracy(folder, nn):
folder = os.path.join(os.path.dirname(__file__), folder)
mse = np.empty((10,))
for i in range(10): # 10 random initializations
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# train ELM
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1])
elm.add_neurons(nn, "sigm")
elm.train(Xtr, Ttr, "CV", k=5)
Yts = elm.predict(Xts)
# evaluate classification results
mse[i - 1] = np.mean((Tts - Yts) ** 2)
return mse
def classification_conf(folder, nn, ntype="sigm", b=1):
folder = os.path.join(os.path.dirname(__file__), folder)
i = np.random.randint(0, 10)
print "using init number: ", i
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# train ELM
Bsize = Xtr.shape[0] / b + 1 # batch size larger than amount of data
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1], batch=Bsize)
elm.add_neurons(nn, ntype)
elm.train(Xtr, Ttr, 'c')
Yts = elm.predict(Xts)
conf = elm.confusion(Tts, Yts)
return conf
def test_adapt_elm_feature_fusion(features, Y):
result = []
for i in range(3):
weights = np.load('./data/adapt_elm/weight_' + str(i) + '.npy')
for k in range(K):
elm = hpelm.ELM(inputs=input_sizes[i], outputs=8)
elm.load('./data/adapt_elm/elm_' + str(i) + '_' + str(k))
predict = elm.predict(features[i]) * weights[k]
if i == 0 and k == 0:
result = predict
else:
result = result + predict
counter = 0.0
for r, t in zip(result, Y):
if np.argmax(r) == np.argmax(t):
counter += 1
right_rate = counter / features[0].shape[0]
print('adapt elm right rate:' + str(right_rate))
def accuracy_mc_cv(folder, nn, ntype="sigm"):
folder = os.path.join(os.path.dirname(__file__), folder)
acc = np.empty((10, ))
for i in range(10): # 10 random initializations
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# train ELM
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1])
elm.add_neurons(nn, ntype)
elm.train(Xtr, Ttr, "mc", "CV", k=5)
Yts = elm.predict(Xts)
# evaluate classification results
Tts = np.argmax(Tts, 1)
Yts = np.argmax(Yts, 1)
acc[i - 1] = float(np.sum(Yts == Tts)) / Tts.shape[0]
return acc
def elm(folder, i, nn, param):
# folder = os.path.join(os.path.dirname(__file__), folder)
# acc = np.empty((10, 3))
# get file names
Xtr = np.load(os.path.join(folder, "xtrain_%d.npy" % (i + 1)))
Xts = np.load(os.path.join(folder, "xtest_%d.npy" % (i + 1)))
Ttr = np.load(os.path.join(folder, "ytrain_%d.npy" % (i + 1)))
Tts = np.load(os.path.join(folder, "ytest_%d.npy" % (i + 1)))
# create validation set
# N = Xtr.shape[0]
# ix = np.arange(N)
# np.random.shuffle(ix)
# Xvl = Xtr[ix[:N/5]]
# Tvl = Ttr[ix[:N/5]]
# Xtr = Xtr[ix[N/5:]]
# Ttr = Ttr[ix[N/5:]]
# elm.add_neurons(Xtr.shape[1], "lin")
# W, B = hpelm.modules.rbf_param(Xtr, nn, "l2")
# elm.add_neurons(nn, "rbf_l2", W, B)
nn = min(nn, Xtr.shape[0] / 2)
t = time()
# build ELM
elm = hpelm.ELM(Xtr.shape[1], Ttr.shape[1])
elm.add_neurons(nn, "sigm")
# train ELM
elm.train(Xtr, Ttr, *param)
Yts = elm.predict(Xts)
err = elm.error(Yts, Tts)
t = time() - t
nns = [l[1] for l in elm.neurons]
return err, nns, t
def test_xor_one_neuron_solved(self):
"""ELM should be able to solve XOR problem.
"""
X = np.array([[0, 0],
[1, 1],
[1, 0],
[0, 1]])
Y = np.array([1, 1, -1, -1])
for _ in range(100): # try 100 random initializations to solve XOR problem
try:
elm = hpelm.ELM(2, 1)
elm.add_neurons(1, "sigm")
elm.train(X, Y)
Yh = elm.predict(X)
self.assertGreater(Yh[0], 0)
self.assertGreater(Yh[1], 0)
self.assertLess(Y[2], 0)
self.assertLess(Y[3], 0)
nn = sum([n[0] for n in elm.nnet.neurons])
self.assertEqual(nn, 1) # one neuron in the ELM
return
except AssertionError:
pass
self.fail("Cannot train 1 neuron to solve XOR problem in 100 re-initializations")
def __init__(self,
model,
xtrain_shape=7,
ytrain_shape=1,
hidden_layer_neurons=5,
activation='sigm',
max_iter=200,
normalize=False,
fit_intercept=True,
alpha=1.0,
solver='auto',
W=None,
pca=None):
self.model_type = model
if model in ['ELM']:
self.model = hpelm.ELM(xtrain_shape, ytrain_shape)
self.model.add_neurons(hidden_layer_neurons, activation)
elif model in ['MLR']:
self.model = LinearRegression(fit_intercept=fit_intercept)
elif model in ['EM']:
self.model = EnsembleMean()
else:
print('invalid model type {}'.format(model))
mae = mean_absolute_error(Y1, r1)
fpr, tpr, thresholds = metrics.roc_curve(Y1, r1,pos_label=2)
auc = metrics.auc(fpr, tpr)
print(metrics.classification_report(Y1, r1))
print(metrics.confusion_matrix(Y1, r1))
print("\n")
result.write("%1.5f" % accuracy + "\t%1.3f" % precision + "\t%1.3f"%recall + "\t%1.3f" % f1 +"\t%1.5f" % mse +"\t%1.5f" % mae +"\t%1.5f" % auc)
result.write("\n")
np.savetxt('data/result/sigmultiother.txt', (fpr,tpr,thresholds), fmt='%10.3f')
print "sigmoid with MSE"
elm = hpelm.ELM(41, 23)
elm.add_neurons(10, "sigm")
elm.train(X, Y)
r2 = elm.predict(X1)
print(str(elm))
result1.write(str(elm))
result1.write("\n")
r2=r2.argmax(1)
accuracy = accuracy_score(Y1, r2)
print(accuracy)
recall = recall_score(Y1, r2, average="weighted")
precision = precision_score(Y1, r2 , average="weighted")
f1 = f1_score(Y1, r2 , average="weighted")
def runswaps():
X = np.random.rand(1000, 10000)
N, d = X.shape
V = np.random.rand(N, 2) * 2 - 1
V = (V - V.mean(0)) / V.std(0)
swaps = []
i = 0
for d in range(20, 1001, 20):
elm = hpelm.ELM(2, d)
elm.add_neurons(2, 'lin')
elm.add_neurons(20, 'sigm')
H = elm.project(V)
A = H.dot(np.linalg.pinv(np.dot(H.T, H))).dot(H.T)
X1 = X[:, :d].copy()
_, info = elmvis_c(X1,
A,
tol=100,
maxiter=10000,
maxstall=10000,
silent=1)
ips_c = info['ips']
X1 = X[:, :d].copy()
_, info = elmvis_p(X1,
A,
tol=100,
maxiter=10000,
maxstall=10000,
silent=1)
ips_p = info['ips']
X1 = X[:, :d].copy()
_, info = elmvis_g(X1,
A,
tol=100,
maxiter=10000,
maxstall=10000,
silent=1)
ips_g = info['ips']
swaps.append((ips_c, ips_p, ips_g))
print d
swaps = np.array(swaps)
d = range(20, 1001, 20)
plt.plot(d, swaps[:, 0], '--r', linewidth=3, alpha=0.7)
plt.plot(d, swaps[:, 1], '--k')
plt.plot(d, swaps[:, 2], '--g')
plt.ylabel("swaps per second")
plt.legend(("C optimized", "Python", "GPU"))
plt.title("1000 data points with $d$ features")
plt.xlabel("$d$")
plt.xlim([0, 1000])
#plt.ylim([0, 23000000])
#plt.yticks([0, 1000000, 5000000, 10000000, 15000000, 20000000, 22000000], ["0", "1 mln.", "5 mln.", "10 mln.", "15 mln.", "20 mln.", "22 mln."])
plt.savefig("plot_ips.pdf", bbox_inches="tight")
print "done"
plt.show()
pY = os.path.join(curdir, "../dataset_tests/iris/maltrte/class.txt") pT = os.path.join(curdir, "../dataset_tests/iris/maltrte/test.txt") X = np.loadtxt(pX) Y = np.loadtxt(pY) T = np.loadtxt(pT) print(type(X)) print "sigmoid with multi class error" elm = ELM(1804, 9) elm.add_neurons(150, "sigm") elm.train(X, Y, "c") Yh = elm.predict(X) print "sigmoid with MSE" elm = hpelm.ELM(1804, 9) elm.add_neurons(150, "sigm") elm.train(X, Y) Y1 = elm.predict(X) err = elm.error(Y1, Y) print err print "rbf_12 with multi class error" elm = hpelm.ELM(1804, 9) elm.add_neurons(150, "rbf_l2") elm.train(X, Y, 'c') Y1 = elm.predict(X) err = elm.error(Y1, Y) print err print "rbf_11 with multi class error"
import hpelm
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
df = pd.read_csv('BELM/sample_data.csv', header=None)
output = np.array(df[df.columns[-1]])
data = np.array(df.iloc[:, :-1])
X_train, X_test, Y_train, Y_test = train_test_split(data,
output,
test_size=0.3)
Y_train = Y_train.reshape(-1, 1)
elm_gpu = hpelm.ELM(X_train.shape[1],
Y_train.shape[1],
precision="single",
accelerator="GPU")
elm_gpu.add_neurons(10, 'sigm')
elm_gpu.train(X_train, Y_train)
P = elm_gpu.predict(X_test)
e = elm_gpu.error(Y_test, P)
print("Error: ", e)
def __init__(self, isEmpty, sequenceLength, numClasses, dimension,
numHiddenNodes):
self.model = hpelm.ELM(inputs=sequenceLength * dimension,
outputs=numClasses,
classification="c")
self.model.add_neurons(number=numHiddenNodes, func="tanh")
recall = recall_score(Y1, r1, average="weighted")
precision = precision_score(Y1, r1 , average="weighted")
f1 = f1_score(Y1, r1 , average="weighted")
mse = mean_squared_error(Y1, r1)
mae = mean_absolute_error(Y1, r1)
result.write("%1.5f" % accuracy + "\t%1.3f" % precision + "\t%1.3f"%recall + "\t%1.3f" % f1 +"\t%1.5f" % mse +"\t%1.5f" % mae)
result.write("\n")
np.savetxt('data/result/sigmultiother.txt', (fpr,tpr,thresholds), fmt='%10.3f')
print "sigmoid with MSE"
elm = hpelm.ELM(41, 41)
elm.add_neurons(5, "sigm")
elm.train(X, Y)
r2 = elm.predict(X1)
result1.write(str(elm))
result1.write("\n")
r2=r2.max(1)
accuracy = accuracy_score(Y1, r2)
recall = recall_score(Y1, r2, average="weighted")
precision = precision_score(Y1, r2 , average="weighted")
f1 = f1_score(Y1, r2 , average="weighted")
mse = mean_squared_error(Y1, r2)
mae = mean_absolute_error(Y1, r2)
fpr, tpr, thresholds = metrics.roc_curve(Y1, r2,pos_label=9)
auc = metrics.auc(fpr, tpr)
f1 = f1_score(Y1, r1, average="weighted")
mse = mean_squared_error(Y1, r1)
mae = mean_absolute_error(Y1, r1)
fpr, tpr, thresholds = metrics.roc_curve(Y1, r1, pos_label=9)
auc = metrics.auc(fpr, tpr)
result.write("%1.5f" % accuracy + "\t%1.3f" % precision + "\t%1.3f" % recall +
"\t%1.3f" % f1 + "\t%1.5f" % mse + "\t%1.5f" % mae +
"\t%1.5f" % auc)
result.write("\n")
np.savetxt('data/result/sigmultiother.txt', (fpr, tpr, thresholds),
fmt='%10.3f')
print "sigmoid with MSE"
elm = hpelm.ELM(243, 8)
elm.add_neurons(40, "sigm")
elm.train(X, Y)
r2 = elm.predict(X1)
result1.write(str(elm))
result1.write("\n")
r2 = r2.argmax(1)
accuracy = accuracy_score(Y1, r2)
recall = recall_score(Y1, r2, average="weighted")
precision = precision_score(Y1, r2, average="weighted")
f1 = f1_score(Y1, r2, average="weighted")
mse = mean_squared_error(Y1, r2)
mae = mean_absolute_error(Y1, r2)
fpr, tpr, thresholds = metrics.roc_curve(Y1, r2, pos_label=9)
auc = metrics.auc(fpr, tpr)
mae = mean_absolute_error(Y1, r1)
fpr, tpr, thresholds = metrics.roc_curve(Y1, r1,pos_label=2)
auc = metrics.auc(fpr, tpr)
print(recall)
print(metrics.classification_report(Y1, r1))
print(metrics.confusion_matrix(Y1, r1))
print("\n")
result.write("%1.5f" % accuracy + "\t%1.3f" % precision + "\t%1.3f"%recall + "\t%1.3f" % f1 +"\t%1.5f" % mse +"\t%1.5f" % mae +"\t%1.5f" % auc)
result.write("\n")
np.savetxt('data/result1/sigmultiother.txt', (fpr,tpr,thresholds), fmt='%10.3f')
print "sigmoid with MSE"
elm = hpelm.ELM(42, 2)
elm.add_neurons(32, "sigm")
elm.train(X, Y)
r2 = elm.predict(X)
print(str(elm))
result1.write(str(elm))
result1.write("\n")
r2=r2.argmax(1)
accuracy = accuracy_score(Y1, r2)
print(accuracy)
recall = recall_score(Y1, r2, average="weighted")
precision = precision_score(Y1, r2 , average="weighted")
f1 = f1_score(Y1, r2 , average="weighted")
#X = np.genfromtxt(pX, dtype= None,delimiter=" ") X = np.loadtxt(pX) Y = np.loadtxt(pY) print(type(X)) print "sigmoid with multi class error" elm = ELM(1804, 10) elm.add_neurons(150, "sigm") elm.train(X, Y, "c") Yh = elm.predict(X) print Yh acc = float(np.sum(Y.argmax(1) == Yh.argmax(1))) / Y.shape[0] print "malware dataset training error: %.1f%%" % (100 - acc * 100) print "sigmoid with MSE" elm = hpelm.ELM(1804, 10) elm.add_neurons(150, "sigm") elm.train(X, Y) Y1 = elm.predict(X) err = elm.error(Y1, Y) print err print "rbf_12 with multi class error" elm = hpelm.ELM(1804, 10) elm.add_neurons(150, "rbf_l2") elm.train(X, Y, 'c') Y1 = elm.predict(X) err = elm.error(Y1, Y) print err print "rbf_11 with multi class error"
