def make_classifiers():
names = [
"ELM(10,tanh)", "ELM(10,tanh,LR)", "ELM(10,sinsq)", "ELM(10,tribas)",
"ELM(hardlim)", "ELM(20,rbf(0.1))"
]
nh = 10
# pass user defined transfer func
sinsq = (lambda x: np.power(np.sin(x), 2.0))
srhl_sinsq = MLPRandomLayer(n_hidden=nh, activation_func=sinsq)
# use internal transfer funcs
srhl_tanh = MLPRandomLayer(n_hidden=nh, activation_func='tanh')
srhl_tribas = MLPRandomLayer(n_hidden=nh, activation_func='tribas')
srhl_hardlim = MLPRandomLayer(n_hidden=nh, activation_func='hardlim')
# use gaussian RBF
srhl_rbf = RBFRandomLayer(n_hidden=nh * 2, rbf_width=0.1, random_state=0)
log_reg = LogisticRegression()
classifiers = [
GenELMClassifier(hidden_layer=srhl_tanh),
GenELMClassifier(hidden_layer=srhl_tanh, regressor=log_reg),
GenELMClassifier(hidden_layer=srhl_sinsq),
GenELMClassifier(hidden_layer=srhl_tribas),
GenELMClassifier(hidden_layer=srhl_hardlim),
GenELMClassifier(hidden_layer=srhl_rbf)
]
return names, classifiers
def trainELMClassifier(trainData, trainLabels, testData):
print("\nTraining ELM Classifier...")
trainData = np.asarray(trainData)
trainLabels = np.asarray(trainLabels)
print(trainData.shape)
print(trainLabels.shape)
# create initialize elm activation functions
nh = 100
activation = 'tanh'
if activation == 'rbf':
act_layer = RBFRandomLayer(n_hidden=nh,
random_state=0,
rbf_width=0.001)
elif activation == 'tanh':
act_layer = MLPRandomLayer(n_hidden=nh, activation_func='tanh')
elif activation == 'tribas':
act_layer = MLPRandomLayer(n_hidden=nh, activation_func='tribas')
elif activation == 'hardlim':
act_layer = MLPRandomLayer(n_hidden=nh, activation_func='hardlim')
# initialize ELM Classifier
elm = GenELMClassifier(hidden_layer=act_layer)
t0 = time()
elm.fit(trainData, trainLabels)
print("\nTraining finished in %0.3fs \n" % (time() - t0))
t0 = time()
predictedLabels = elm.predict(testData)
print("\nTesting finished in %0.3fs" % (time() - t0))
t0 = time()
confidence_scores = elm.decision_function(testData)
print("\nTesting finished in %0.3fs" % (time() - t0))
print("\nPredicted Labels")
print("----------------------------------")
print(predictedLabels)
print("\nConfidence Scores")
print("----------------------------------")
print(confidence_scores)
params = {
'nh': nh,
'af': activation,
}
return confidence_scores, predictedLabels, params
def __init__(self,
hidden_layer=MLPRandomLayer(random_state=0),
regressor=None):
super(GenELMRegressor, self).__init__(hidden_layer, regressor)
self.coefs_ = None
self.fitted_ = False
self.hidden_activations_ = None
def __init__(self,
hidden_layer=MLPRandomLayer(random_state=0),
binarizer=LabelBinarizer(-1, 1),
regressor=None):
super(GenELMClassifier, self).__init__(hidden_layer, regressor)
self.binarizer = binarizer
self.classes_ = None
self.genelm_regressor_ = GenELMRegressor(hidden_layer, regressor)
def make_classifiers():
names = [ #"ELM(tanh)",
# "ELM(tanh,LR)",
# "ELM(sinsq)",
#"ELM(sigmoid)",
# "ELM(sine)",
# "ELM(inv_tribas)",
# "ELM(softlim)",
# "ELM(gaussian)",
# "ELM(multiquadric)",
# "ELM(inv_multiquadric)",
#"ELM(tribas)",
# "ELM(hardlim)",
#"Basic ELM(hardlim)",
#"ELM(rbf(0.1))",
# "LR",
#"LDA",9
#"KNN",
#"DT",
#"NB",
#"RDF",
"SVM(linear)",
#"SVM(rbf)",
#"SVM(sigmoid)",
#"SVM(poly)"
]
# # Hidden nodes
nh = 2000
#
# pass user defined transfer func
sinsq = (lambda x: np.power(np.sin(x), 2.0))
srhl_sinsq = MLPRandomLayer(n_hidden=nh, activation_func=sinsq)
# use internal transfer funcs
srhl_tanh = MLPRandomLayer(n_hidden=nh, activation_func='tanh')
# use tribas
srhl_tribas = MLPRandomLayer(n_hidden=nh, activation_func='tribas')
# use hardlim
srhl_hardlim = MLPRandomLayer(n_hidden=nh, activation_func='hardlim')
# use gaussian RBF
srhl_rbf = RBFRandomLayer(n_hidden=nh * 2, rbf_width=0.1, random_state=0)
# use sigmoid
srhl_sigmoid = MLPRandomLayer(n_hidden=nh, activation_func='sigmoid')
# use sine
srhl_sine = MLPRandomLayer(n_hidden=nh, activation_func='sine')
# use inv_tribas
srhl_inv_tribas = MLPRandomLayer(n_hidden=nh, activation_func='inv_tribas')
# use softlim
srhl_softlim = MLPRandomLayer(n_hidden=nh, activation_func='softlim')
# use gaussian
srhl_gaussian = MLPRandomLayer(n_hidden=nh, activation_func='gaussian')
# use multiquadric
srhl_multiquadric = MLPRandomLayer(n_hidden=nh, activation_func='multiquadric')
# use inv_multiquadric
srhl_inv_multiquadric = MLPRandomLayer(n_hidden=nh, activation_func='inv_multiquadric')
log_reg = LogisticRegression()
classifiers = [ # GenELMClassifier(hidden_layer=srhl_tanh),
#GenELMClassifier(hidden_layer=srhl_tanh, regressor=log_reg),
#GenELMClassifier(hidden_layer=srhl_sinsq),
#GenELMClassifier(hidden_layer=srhl_sigmoid),
#GenELMClassifier(hidden_layer=srhl_sine),
#GenELMClassifier(hidden_layer=srhl_inv_tribas),
#GenELMClassifier(hidden_layer=srhl_softlim),
#GenELMClassifier(hidden_layer=srhl_gaussian),
#GenELMClassifier(hidden_layer=srhl_multiquadric),
#GenELMClassifier(hidden_layer=srhl_inv_multiquadric),
#GenELMClassifier(hidden_layer=srhl_tribas),
#GenELMClassifier(hidden_layer=srhl_hardlim),
#ELMClassifier(activation_func="hardlim",alpha=1,n_hidden=nh),
#GenELMClassifier(hidden_layer=srhl_rbf),
#LogisticRegression(),
#LinearDiscriminantAnalysis(),
#KNeighborsClassifier(),
#DecisionTreeClassifier(),
#GaussianNB(),
#RandomForestClassifier(n_estimators=5),
#SVC(kernel="rbf", gamma=0.01, C=10),
SVC(kernel="linear", C=1),
#SVC(kernel='rbf',C=10,gamma=0.01)
#SVC(kernel="poly", gamma=2)
]
return names, classifiers
n_splits = 20
sKF = StratifiedKFold(n_splits=n_splits, shuffle=False)
i = 0
stop_train = False
num_epochs = 10
for train_index, test_index in sKF.split(std_X, y):
i += 1
x_train = std_X[train_index]
y_train = y[train_index]
x_test = std_X[test_index]
y_test = y[test_index]
#-------------------------------------------------------------------------------
grbf = GRBFRandomLayer(n_hidden=500, grbf_lambda=0.0001)
act = MLPRandomLayer(n_hidden=500, activation_func='sigmoid')
rbf = RBFRandomLayer(n_hidden=290,
rbf_width=0.0001,
activation_func='sigmoid')
clf = GenELMClassifier(hidden_layer=rbf)
clf.fit(x_train, y_train.ravel())
y_pre = clf.predict(x_test)
y_score = clf.decision_function(x_test)
fpr, tpr, thresholds = roc_curve(y_test, y_score)
tprs.append(tpr)
fprs.append(fpr)
roc_auc = auc(fpr, tpr)
tn, fp, fn, tp = confusion_matrix(y_test, y_pre).ravel()
test_acc = (tn + tp) / (tn + fp + fn + tp)
test_Sn = tp / (fn + tp)
plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
# <codecell>
rbf_rhl = RBFRandomLayer(n_hidden=100, random_state=0, rbf_width=0.01)
elmc_rbf = GenELMClassifier(hidden_layer=rbf_rhl)
elmc_rbf.fit(dgx_train, dgy_train)
print elmc_rbf.score(dgx_train, dgy_train), elmc_rbf.score(dgx_test, dgy_test)
def powtanh_xfer(activations, power=1.0):
return pow(np.tanh(activations), power)
tanh_rhl = MLPRandomLayer(n_hidden=100,
activation_func=powtanh_xfer,
activation_args={'power': 3.0})
elmc_tanh = GenELMClassifier(hidden_layer=tanh_rhl)
elmc_tanh.fit(dgx_train, dgy_train)
print elmc_tanh.score(dgx_train,
dgy_train), elmc_tanh.score(dgx_test, dgy_test)
# <codecell>
rbf_rhl = RBFRandomLayer(n_hidden=100, rbf_width=0.01)
tr, ts = res_dist(dgx,
dgy,
GenELMClassifier(hidden_layer=rbf_rhl),
n_runs=100,
random_state=0)
from sklearn import preprocessing
import warnings
dataset_name = ['caltech', 'feret', 'ORL', 'Indianface']
features = [
'npymodel/caltech_data.npy', 'npymodel/feret_data.npy',
'npymodel/ORL_data.npy', 'npymodel/Indianface_data.npy'
]
lables = [
'npymodel/caltech_lable.npy', 'npymodel/feret_lable.npy',
'npymodel/ORL_lable.npy', 'npymodel/Indianface_lable.npy'
]
srhl_sigmoid = MLPRandomLayer(n_hidden=2000, activation_func='sigmoid')
srhl_gaussian = MLPRandomLayer(n_hidden=2000, activation_func='gaussian')
names = [
"ELM(sigmoid)",
#"ELM(gaussian)",
"SVM(linear)",
#'SVM(rbf)',
"LR"
]
classifiers = [
GenELMClassifier(hidden_layer=srhl_sigmoid),
# GenELMClassifier(hidden_layer=srhl_gaussian),
SVC(kernel='linear', C=1),
#SVC(kernel='rbf',C=10,gamma=0.01),
__author__ = 'ozgurcatak'
from mrjob.job import MRJob
import random, numpy as np, sys, os, uuid, errno, time
from elm import GenELMClassifier
from random_layer import RBFRandomLayer, MLPRandomLayer
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import classification_report, accuracy_score, precision_score, recall_score, f1_score
from sklearn.externals import joblib
M = 2
nh = 5
T = 5
srhl_tanh = MLPRandomLayer(n_hidden=nh, activation_func='tanh')
srhl_rbf = RBFRandomLayer(n_hidden=nh*2, rbf_width=0.1, random_state=0)
srhl_tribas = MLPRandomLayer(n_hidden=nh, activation_func='tribas')
srhl_hardlim = MLPRandomLayer(n_hidden=nh, activation_func='hardlim')
# clf = GenELMClassifier(hidden_layer=srhl_tanh)
clf = GenELMClassifier(hidden_layer=srhl_rbf)
# clf = GenELMClassifier(hidden_layer=srhl_tribas)
# clf = GenELMClassifier(hidden_layer=srhl_hardlim)
class ELMTraining(MRJob):
def mapper(self, _, line):
k = random.randint(1,M)
yield k, (line)
print("Rights: " + str(rights))
print("Wrongs:" + str(wrongs))
print("Score: " + str(rights / (rights + wrongs) * 100) + "%")
print("\n")
#####ELM with MLP Random Layer#####
from random_layer import MLPRandomLayer
from elm import GenELMClassifier as classifier
def powtanh_xfer(activations, power=1.0):
return pow(np.tanh(activations), power)
model = classifier(hidden_layer=MLPRandomLayer(n_hidden=100,
activation_func=powtanh_xfer,
activation_args={'power': 3.0}))
model.fit(trainX, trainy)
dump(model, 'ELMMLPModel.bin')
print(
"##########Testing person identification with ELM with MLP Random Layer model##########"
)
predictions = model.predict(testX)
rights, wrongs = 0, 0
for prediction, actual in zip(predictions, testy):
if prediction == actual:
if showIndividualPredictions:
print(prediction)
print("Correct!")
