def __init__(self):
super(Classifier, self).__init__()
model = AttentionEmbedMeanField
self.s2v = model(latent_dim=cmd_args.latent_dim,
output_dim=cmd_args.out_dim,
num_node_feats=cmd_args.feat_dim,
num_edge_feats=0,
multi_h_emb_weight=cmd_args.multi_h_emb_weight,
max_k=cmd_args.max_k,
dropout=cmd_args.dropout,
max_block=cmd_args.max_block,
reg=cmd_args.reg)
out_dim = cmd_args.out_dim
if out_dim == 0:
out_dim = cmd_args.latent_dim * cmd_args.multi_h_emb_weight
if cmd_args.gm == 'attention': #Note: outdim is 0 by most of case, may not need
out_dim = cmd_args.latent_dim * cmd_args.multi_h_emb_weight # multi-head=3
# self.mlp = MLPClassifier1layer(input_size=out_dim, num_class=cmd_args.num_class)
# else:
self.mlp = MLPClassifier(input_size=out_dim,
hidden_size=cmd_args.hidden,
num_class=cmd_args.num_class)
def nn(X_train, y_train, X_test, y_test, conf_matrix=False):
y_unique = len(np.unique(y_train))
model = MLPClassifier(dim_in=X_train.shape[0],
dim_out=y_unique,
dims_hid=ARG_DIMS_HID,
act_hid=ARG_ACTIVATION,
dist=ARG_WEIGHT_INIT,
dist_scale=ARG_WEIGHT_SCALE)
trainCEs, trainREs = model.train(X_train,
y_train,
alpha=ARG_ALPHA,
epochs=ARG_EPOCHS,
trace=False,
alpha_drop_each=ARG_ALPHA_DROP_EACH,
alpha_drop_rate=ARG_ALPHA_DROP_RATE)
trainCE, trainRE = model.test(X_train, y_train)
testCE, testRE = model.test(X_test, y_test)
_, y_pred = model.predict(X_test)
if conf_matrix:
# export confussion matrix
cm = confusion_matrix(y_test,
y_pred,
labels=list(char_to_int.values()))
print(cm)
file_path = os.path.join('.', 'output', 'confusion_matrix.csv')
with open(file_path, 'w') as f:
for k in char_to_int.keys():
f.write('\t{}'.format(k))
f.write('\n')
for k, row in zip(char_to_int.keys(),
range(len(char_to_int.keys()))):
f.write(k)
for i in cm[row]:
f.write('\t{}'.format(i))
f.write('\n')
plot_table(file_path, (6, 1))
#plot_dots(X_train, None, None, X_test, y_test, y_pred, save_path=os.path.join('.', 'output', 'predict.png')) # predicted
#plot_dots(X_train, None, None, X_test, y_test, None, save_path=os.path.join('.', 'output', 'test.png')) # reality
#plot_both_errors(trainCEs, trainREs, testCE, testRE, save_path=os.path.join('.', 'output', 'errors.png'))
return trainCE, testCE
def iris():
print("-------------iris----------------")
mat = Arff("../data/perceptron/iris.arff", label_count=3)
y = mat.data[:,-1]
# print(y)
lb = preprocessing.LabelBinarizer()
lb.fit(y)
y = lb.transform(y)
# split it
# data, labels, tData, tLabels = _shuffle_split(mat.data[:, :-1], y, .25)
data, tData, labels, tLabels = train_test_split(mat.data[:, :-1], y, test_size=.25)
MLPClass = MLPClassifier([2*np.shape(data)[1]], lr=0.1, shuffle=True, one_hot=True)
MLPClass.fit(data, labels, momentum=0.5, percent_verify=.25)
np.savetxt("Iris_eval.csv", MLPClass.stupidData[1:], header=reduce(MLPClass.stupidData[0]), delimiter=',')
accuracy = MLPClass.score(tData, tLabels)
print("Test Accuracy = [{:.2f}]".format(accuracy))
def basic():
print("-------------basic---------------")
x = np.array([[0,0],[0,1], [1, 1]])
y = np.array([[1],[0], [0]])
l1 = np.array([[1, 1], [1, 1], [1, 1]])
l2 = np.array([[1], [1], [1]])
w = [l1, l2]
tx = np.array([[1, 0]]) # second has a zero
ty = np.array([[1]])
# print(x)
# print(y)
pc = None
try:
pc = MLPClassifier([2], 1, shuffle=False, deterministic=10)
# print(pc)
print(pc.fit(x, y, w, 1, percent_verify=0))
print("fake score", pc.score(tx, ty))
# print(pc.fit(x, y).score(np.array([[0,0,0],[0,1,0],[1,0,0],[1,1,0]]), np.array([[0],[0],[1],[1]])))
# print(pc)
except Exception as e:
print("AN EXCEPTION OCCURRED!!!---------\n\r"*2, pc)
raise e
def vowel():
print("-------------vowel----------------")
mat = Arff("../data/vowel.arff", label_count=1)
y = mat.data[:,-1]
lb = preprocessing.LabelBinarizer()
lb.fit(y)
y = lb.transform(y)
# split it
data, tData, labels, tLabels = train_test_split(mat.data[:, :-1], y, test_size=.25)
master_window = 5
window = master_window
bssf = [np.inf, 0]
tolerance = 1e-4
findings = []
findings.append(["LR", "Epochs", "TestAccuracy", "MSE train", "MSE validate", "MSE test", "Best LR"])
for lr in range(-1, 5):
if window <= 0:
break
for step in [1, 5]:
entry = []
print((lr, step), end=",")
learn_rate = (0.1**lr)*step
MLPClass = MLPClassifier([2*np.shape(data)[1]], lr=learn_rate, shuffle=True, one_hot=True)
MLPClass.fit(data, labels, momentum=0.5, percent_verify=.25)
accuracy = MLPClass.score(tData, tLabels)
entry.append(learn_rate)
entry.append(MLPClass.getEpochCount())
entry.append(accuracy)
entry.append(MLPClass._calc_l2_err(data, labels))
entry.append(MLPClass.bssf[0])
entry.append(MLPClass._calc_l2_err(tData, tLabels))
entry.append(bssf[1])
findings.append(entry)
if accuracy < bssf[0] and abs(accuracy - bssf[0]) > tolerance:
bssf = [accuracy, learn_rate]
window = master_window
else:
window = window - 1
if window <= 0:
break
print("\n\r", findings)
np.savetxt("vowel_findings_lr.csv", findings[1:], header=reduce(findings[0]), delimiter=',')
lr = bssf[1]
window = master_window
findings = []
findings.append(["Num Nodes", "Epochs", "Train Accuracy", 'VS accuracy', 'test accuracy'])
accuracy = bssf[0]
doubler = 2
num_nodes = 1
bssf = [np.inf, 0]
while(window > 0):
num_nodes = num_nodes * doubler
print("numnodes", num_nodes)
MLPClass = MLPClassifier([num_nodes], lr=lr, shuffle=True, one_hot=True)
MLPClass.fit(data, labels, momentum=0.5, percent_verify=.25)
accuracy = MLPClass.score(tData, tLabels)
entry = []
entry.append(num_nodes)
entry.append(MLPClass.getEpochCount())
entry.append(MLPClass._calc_l2_err(data, labels))
entry.append(MLPClass.bssf[0])
entry.append(MLPClass._calc_l2_err(tData, tLabels))
findings.append(entry)
if accuracy < bssf[0] and abs(accuracy - bssf[0]) > tolerance:
bssf = [accuracy, num_nodes]
window = master_window
else:
window = window - 1
np.savetxt("vowel_findings_hid_nodes.csv", findings[1:], header=reduce(findings[0]), delimiter=',')
num_nodes = bssf[1]
window = master_window
findings = []
findings.append(["Momentum", "Epochs", "Train Accuracy", 'VS accuracy', 'test accuracy'])
momentum = 0
bssf = [np.inf, momentum]
while(window > 0):
momentum = momentum + 0.05
print("momentum", momentum)
MLPClass = MLPClassifier([num_nodes], lr=lr, shuffle=True, one_hot=True)
MLPClass.fit(data, labels, momentum=momentum, percent_verify=.25)
accuracy = MLPClass.score(tData, tLabels)
entry = []
entry.append(momentum)
entry.append(MLPClass.getEpochCount())
entry.append(MLPClass._calc_l2_err(data, labels))
entry.append(MLPClass.bssf[0])
entry.append(MLPClass._calc_l2_err(tData, tLabels))
findings.append(entry)
if accuracy < bssf[0] and abs(accuracy - bssf[0]) > tolerance:
bssf = [accuracy, momentum]
window = master_window
else:
window = window - 1
np.savetxt("vowel_findings_momentum.csv", findings[1:], header=reduce(findings[0]), delimiter=',')
import numpy as np
from mlp import MLPClassifier
# training data
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[
0,
1,
1,
0,
]])
y = np.transpose(y)
mlp = MLPClassifier() # make object
mlp.fit(X,
y,
W_h=[[0.5, 0.9], [0.4, 1.0]],
W_o=[-1.2, 1.1],
t_h=[0.8, -0.1],
t_o=[0.3]) # train model with specfic weights
# mlp.fit(X, y) # train model with random inits
# predicting
print('\n\nPrediction')
print('x1\tx2\ty')
for x in X:
print('{}\t{}\t{}'.format(x[0], x[1], mlp.predict(x)[0]))
if shuffle:
np.random.shuffle(alldata)
if spliting:
split = int(round(.75 * alllength))
print(split)
trainingset = alldata[:split]
testingset = alldata[split:]
else:
trainingset = alldata
testingset = alldata
X = trainingset[:, :y_start]
y = trainingset[:, y_start:]
mlp = MLPClassifier(solver='adam',
activation='relu',
learning_rate='constant',
momentum=.9,
early_stopping=False)
output = mlp.fit(X, y)
score = mlp.score(testingset[:, :y_start], testingset[:, y_start:])
print(score)
#mlp = MLPClassifier(lr=.1, momentum=0.5
# , shuffle=shuffle, hidden_layer_widths=None)
#print(y)
# X=[[0,0],[0,1]]
# y=[[1],[0]]
#initial_weights={'hidden':[[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] ,'output':[[0,0,0,0,0,0,0,0,0]]}
#hl, ol = mlp.fit(X, y,)
#if split:
# X1 = testingset[:, :y_start]
def main():
def show_confusion_matrix_ex(y_predicted, y_true, s):
train_y_typename = training_labels.dtype.type.__name__
if 'float' in train_y_typename or 'float' in train_y_typename:
show_confusion_matrix(n_classes, y_true, y_predicted, s)
else:
show_confusion_matrix(n_classes, mlp.to_class_index(y_true),
mlp.to_class_index(y_predicted), s)
print("Starting...")
training_images, training_labels, test_images, test_labels, n_classes = load_mnist(
)
n_train_samples = len(training_labels)
n_test_samples = len(test_labels)
# Using 10%
# n_iter = (training_images.shape[0] // n_classes) * 10 // 100
# training_images_new = []
# training_labels_new = []
# for i in range(n_classes):
# indices = np.where(training_labels == i)[0]
# np.random.shuffle(indices)
# training_images_new.append(training_images[indices[:n_iter]])
# training_labels_new.append(training_labels[indices[:n_iter]])
# training_images = np.concatenate(training_images_new)
# training_labels = np.concatenate(training_labels_new)
# n_train_samples = len(training_labels)
# n_test_samples = len(test_labels)
# print("Train samples:", n_train_samples)
# print("Test samples:", n_test_samples)
features = 1 if training_images.ndim == 1 else np.product(
training_images.shape[1:])
mlp = MLPClassifier(features, 'adadelta', 'smce')
mlp.add(Dropout(0.4))
mlp.add(
Dense(250,
activation='linear',
kernel_initializer='xnn',
bias_initializer='xnn'))
mlp.add(ReluLayer())
mlp.add(
Dense(250,
activation='linear',
kernel_initializer='xnn',
bias_initializer='xnn'))
mlp.add(ReluLayer())
mlp.add(
Dense(n_classes,
activation='linear',
kernel_initializer='xnn',
bias_initializer='xnn'))
print("Training and testing...")
time_start = perf_counter()
result = mlp.fit(training_images,
training_labels,
test_x=test_images,
test_y=test_labels,
test_folds=1,
epochs=500,
learning_rate=5,
batch_size=500,
shuffle=True,
verbose=1,
train_accuracy_goal=np.inf,
best_choice=frozenset({'test_accuracy'}))
time_stop = perf_counter()
print("Time:", time_stop - time_start, "seconds")
epochs_passed, train_loss_curve, train_accuracy_curve, test_loss_curve, test_accuracy_curve = result
if epochs_passed >= 2:
plot_loss_accuracy_curves(epochs_passed, train_loss_curve,
train_accuracy_curve, test_loss_curve,
test_accuracy_curve)
tr_losses, tr_correct_answers = mlp.evaluate(training_images,
training_labels)
print("TRAIN RESULTS")
print("Loss:", tr_losses.mean())
print("Accuracy (%):", tr_correct_answers * 100 / n_train_samples)
show_confusion_matrix_ex(training_labels,
mlp.predict_classes(training_images),
'Train. Confusion matrix')
ts_losses, ts_correct_answers = mlp.evaluate(test_images, test_labels)
print("TEST RESULTS")
print("Loss:", ts_losses.mean())
print("Accuracy (%):", ts_correct_answers * 100 / n_test_samples)
show_confusion_matrix_ex(test_labels, mlp.predict_classes(test_images),
'Test. Confusion matrix')
save_params_to_file = enter_bool(
"Do you want to save the parameters of the neural network to file?")
if save_params_to_file:
output_filename = input("Filename:")
try:
with open(output_filename, "w") as fp:
json.dump(mlp.get_parameters(), fp, cls=NpEncoder)
print("Neural network parameters were saved to", output_filename)
except OSError as error:
print(error)
activation_function = activation_mapping.get(config['activation_function'])
error_mapping = {
'mean_squared': error_functions.mean_squared, \
'mean': error_functions.mean, \
'max': error_functions.max_error, \
'cross_entropy': error_functions.cross_entropy
}
error_function = error_mapping.get(config['error_function'])
if config['problem_type'] == 'classification':
clf = MLPClassifier(num_iterations = config['iterations'], \
bias = config['bias'], \
hidden_layers = config['hidden_layers'], \
eta = config['learning_rate'], \
moment = config['moment'], \
batch_portion = config['batch_portion'], \
random_seed = config['random_seed'], \
activation_function = activation_function, \
error_function = error_function)
clf = clf.fit(X_train, y_train, \
serialize_path='training_data.joblib')
print('Classification accuracy:', clf.score(X_test, y_test))
print('Class confusion matrix:')
print(clf.confusion_matrix(X_test, y_test))
print('Plotting training dataset...')
vis.plot_classification_dataset(X_train.iloc[:, 0],
X_train.iloc[:, 1],
y_train,
