class MLELM(ELM):
"""
Multi Layer Extreme Learning Machine
"""
def __init__(self, *, hidden_neurons=None, a=1, random_state=None):
super().__init__(hidden_neurons=hidden_neurons,
a=a,
random_state=random_state)
self.betas = []
self.elm = None
self.out_num = None
def __calc_hidden_layer(self, X):
"""
Args:
X np.array input feature vector
"""
for beta in self.betas:
X = np.dot(beta, X.T).T
return X
def fit(self, X, y):
if self.hidden_neurons is None:
self.hidden_neurons = 2 * X.shape[1]
self.out_num = max(y)
X = self._add_bias(X)
for hid_num in self.hidden_neurons[:-1]:
_X = self.__calc_hidden_layer(X)
W = self._random_state.uniform(-1., 1., (hid_num, _X.shape[1]))
H = np.linalg.pinv(self._sigmoid(np.dot(W, _X.T)))
beta = np.dot(H.T, _X)
self.betas.append(beta)
_X = self.__calc_hidden_layer(X)
self.elm = ELM(hidden_neurons=self.hidden_neurons[-1])
self.elm.fit(_X, y)
return self
def predict(self, X):
X = self.__calc_hidden_layer(self._add_bias(X))
return self.elm.predict(X)
class MLELM(ELM):
"""
Multi Layer Extreme Learning Machine
"""
def __init__(self, hidden_units, a=1):
self.hidden_units = hidden_units
self.betas = []
self.a = a
def __calc_hidden_layer(self, X):
"""
Args:
X np.array input feature vector
"""
for beta in self.betas:
X = np.dot(beta, X.T).T
return X
def fit(self, X, y):
self.out_num = max(y)
X = self._add_bias(X)
for hid_num in self.hidden_units[:-1]:
_X = self.__calc_hidden_layer(X)
np.random.seed()
W = np.random.uniform(-1., 1.,
(hid_num, _X.shape[1]))
_H = np.linalg.pinv(self._sigmoid(np.dot(W, _X.T)))
beta = np.dot(_H.T, _X)
self.betas.append(beta)
_X = self.__calc_hidden_layer(X)
self.elm = ELM(hid_num=self.hidden_units[-1])
self.elm.fit(_X, y)
return self
def predict(self, X):
X = self.__calc_hidden_layer(self._add_bias(X))
return self.elm.predict(X)
class MLELM(ELM):
"""
Multi Layer Extreme Learning Machine
"""
def __init__(self, hidden_units, a=1):
self.hidden_units = hidden_units
self.betas = []
self.a = a
def __calc_hidden_layer(self, X):
"""
Args:
X np.array input feature vector
"""
for beta in self.betas:
X = np.dot(beta, X.T).T
return X
def fit(self, X, y):
self.out_num = max(y)
X = self._add_bias(X)
for hid_num in self.hidden_units[:-1]:
_X = self.__calc_hidden_layer(X)
np.random.seed()
W = np.random.uniform(-1., 1.,
(hid_num, _X.shape[1]))
_H = np.linalg.pinv(self._sigmoid(np.dot(W, _X.T)))
beta = np.dot(_H.T, _X)
self.betas.append(beta)
_X = self.__calc_hidden_layer(X)
self.elm = ELM(hid_num=self.hidden_units[-1])
self.elm.fit(_X, y)
return self
def predict(self, X):
X = self.__calc_hidden_layer(self._add_bias(X))
return self.elm.predict(X)
data = []
best = [[], 0]
for i in range(iters):
CVO = KFold(n_splits=n_folds, shuffle=True)
acc_values = []
for train_index, test_index in CVO.split(X):
X_train, X_test = X[train_index], X[test_index]
Y_train, Y_test = Y[train_index], Y[test_index]
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
elm = ELM(hidden_units=20, activation="log")
#elm = ELM(hidden_units = 20, activation="tan")
elm.fit(X_train, Y_train)
Y_hat = elm.predict(X_test)
Y_hat = np.round(Y_hat)
acc_values.append(
np.sum(
np.where(
np.argmax(Y_hat, axis=1) == np.argmax(Y_test, axis=1), 1,
0)) / len(Y_test))
if acc_values[-1] > best[1]:
best[0] = confusion_matrix(np.argmax(Y_test, axis=1),
np.argmax(Y_hat, axis=1))
best[1] = acc_values[-1]
accuracy[i] = np.mean(acc_values)
print("Accuracy", np.mean(accuracy))
print("Standard Deviation (accuracy)", np.std(accuracy, axis=0))
def main(args):
# ===============================
# Load dataset
# ===============================
n_classes = 10
(x_train, t_train), (x_test, t_test) = mnist.load_data()
# ===============================
# Preprocess
# ===============================
x_train = x_train.astype(np.float32) / 255.
x_train = x_train.reshape(-1, 28**2)
x_test = x_test.astype(np.float32) / 255.
x_test = x_test.reshape(-1, 28**2)
t_train = to_categorical(t_train, n_classes).astype(np.float32)
t_test = to_categorical(t_test, n_classes).astype(np.float32)
# ===============================
# Instantiate ELM
# ===============================
model = ELM(
n_input_nodes=28**2,
n_hidden_nodes=args.n_hidden_nodes,
n_output_nodes=n_classes,
loss=args.loss,
activation=args.activation,
name='elm',
)
# ===============================
# Training
# ===============================
model.fit(x_train, t_train)
train_loss, train_acc = model.evaluate(x_train,
t_train,
metrics=['loss', 'accuracy'])
print('train_loss: %f' % train_loss)
print('train_acc: %f' % train_acc)
# ===============================
# Validation
# ===============================
val_loss, val_acc = model.evaluate(x_test,
t_test,
metrics=['loss', 'accuracy'])
print('val_loss: %f' % val_loss)
print('val_acc: %f' % val_acc)
# ===============================
# Prediction
# ===============================
x = x_test[:10]
t = t_test[:10]
y = softmax(model.predict(x))
for i in range(len(y)):
print('---------- prediction %d ----------' % (i + 1))
class_pred = np.argmax(y[i])
prob_pred = y[i][class_pred]
class_true = np.argmax(t[i])
print('prediction:')
print('\tclass: %d, probability: %f' % (class_pred, prob_pred))
print('\tclass (true): %d' % class_true)
# ===============================
# Save model
# ===============================
print('saving model...')
model.save('model.h5')
del model
# ===============================
# Load model
# ===============================
print('loading model...')
model = load_model('model.h5')
