def main():
sys.path.insert(0, '/home/osboxes/DeepLearningResearch/Classification')
import keras_models
epochs = 16
batch_size = 10
neurons = 50
optimizer = 'nadam'
weight_constraint = 5
dropout_rate = .10
model = keras_models.create_one_layer()
plot_model(model, to_file='./figures/oneLayer.png', show_shapes=True)
def main():
sys.path.insert(
0,
'C:/Users/jarre/OneDrive/Documents/Research/Fall2017Git/Classification'
)
import keras_models
epochs = 16
batch_size = 10
neurons = 50
optimizer = 'nadam'
weight_constraint = 5
dropout_rate = .10
model = keras_models.create_one_layer()
plot_model(model, to_file='./figures/oneLayer.png', show_shapes=True)
def final_test(args, perm_inputs, feat_inputs, comb_inputs, labels):
'''
performs final test and validation across each train ratio on hardcoded
hyperparemeter values established by the gridsearch
'''
perm_width = int(len(perm_inputs[0]))
feat_width = int(len(feat_inputs[0]))
comb_width = int(len(comb_inputs[0]))
print('perm width: ' + str(perm_width))
input_ratios = args["input_ratio"]
models = args["model"]
size = 32
#models = {'oneLayer_comb':oneLayer_comb, 'oneLayer_perm':oneLayer_perm, \
#'oneLayer_feat':oneLayer_feat, 'dual_simple':dual_simple, 'dual_large':dual_large}
#models = ('oneLayer_comb', 'oneLayer_feat', 'oneLayer_perm', 'dual_simple', 'dual_large')
for m in models:
print(m)
data = []
for r in args["train_ratio"]:
percent = float(r) / 100
#stratified shuffle split used for cross validation
sss = StratifiedShuffleSplit(n_splits=5,
random_state=0,
test_size=1 - percent)
cm = np.zeros([2, 2], dtype=np.int64)
train_time = 0.0
test_time = 0.0
ir = 0
for train_index, test_index in sss.split(perm_inputs, labels):
perm_train, perm_test = perm_inputs[train_index], perm_inputs[
test_index]
feat_train, feat_test = feat_inputs[train_index], feat_inputs[
test_index]
comb_train, comb_test = comb_inputs[train_index], comb_inputs[
test_index]
labels_train, labels_test = labels[train_index], labels[
test_index]
if m == "oneLayer_comb":
print('oneLayer_comb')
model = create_one_layer(optimizer='nadam',
data_width=comb_width,
neurons=32)
epoch = 32
batch = 32
time0 = timeit.default_timer()
model.fit(comb_train,
labels_train,
epochs=epoch,
batch_size=batch)
time1 = timeit.default_timer()
labels_pred = model.predict(comb_test, batch_size=batch)
time2 = timeit.default_timer()
elif m == "oneLayer_perm":
print('oneLayer_perm')
model = create_one_layer(optimizer='nadam',
data_width=perm_width,
neurons=32)
batch = 32
epoch = 16
time0 = timeit.default_timer()
model.fit(perm_train,
labels_train,
epochs=epoch,
batch_size=batch)
time1 = timeit.default_timer()
print(time1 - time0)
labels_pred = model.predict(perm_test, batch_size=batch)
time2 = timeit.default_timer()
print(time2 - time1)
elif m == "oneLayer_feat":
print('oneLayer_feat')
model = create_one_layer(optimizer='nadam',
data_width=feat_width,
neurons=32)
batch = 16
epoch = 32
time0 = timeit.default_timer()
model.fit(feat_train,
labels_train,
epochs=epoch,
batch_size=batch)
time1 = timeit.default_timer()
labels_pred = model.predict(feat_test, batch_size=batch)
time2 = timeit.default_timer()
elif m == "dual_simple":
print('dual_simple')
model = create_dualInputSimple(input_ratio=.125,
neurons=32,
perm_width=perm_width,
feat_width=feat_width)
batch = 16
epoch = 32
ir = .125
print(
"args: batch=%i, epochs=%i, ir=%f, perm_width=%i, feat_width=%i"
% (batch, epoch, ir, perm_width, feat_width))
print(type(perm_width))
print(type(feat_width))
model = create_dualInputSimple(input_ratio=ir, neurons=size, \
perm_width=perm_width, feat_width=feat_width)
time0 = timeit.default_timer()
model.fit([perm_train, feat_train],
labels_train,
epochs=epoch,
batch_size=batch)
time1 = timeit.default_timer()
labels_pred = model.predict([perm_test, feat_test],
batch_size=batch)
time2 = timeit.default_timer()
elif m == "dual_large":
print('dual_large')
model = create_dualInputLarge(input_ratio=.125,
neurons=32,
perm_width=perm_width,
feat_width=feat_width)
batch = 128
epoch = 32
ir = .125
model = create_dualInputLarge(dropout_rate=.1, neurons=size,\
input_ratio=ir, perm_width=perm_width, feat_width=feat_width)
time0 = timeit.default_timer()
model.fit([perm_train, feat_train],
labels_train,
epochs=epoch,
batch_size=batch)
time1 = timeit.default_timer()
labels_pred = model.predict([perm_test, feat_test],
batch_size=batch)
time2 = timeit.default_timer()
train_time += time1 - time0
test_time += time2 - time1
labels_pred = (labels_pred > 0.5)
cm = cm + confusion_matrix(labels_test, labels_pred)
acc = calc_accuracy(cm)
prec = calc_precision(cm)
rec = calc_recall(cm)
f1 = calc_f1(prec, rec)
avg_train_time = train_time / 5
avg_test_time = test_time / 5
data.append(dict(zip(["model_name", "neurons", "train_ratio", "input_ratio", \
"epochs", "batch_size", "accuracy", "precision", "recall", "f1_score", \
"avg_train_time", "avg_test_time"], \
[m, size, r, ir, epoch, batch, acc, prec, rec, f1, avg_train_time, avg_test_time])))
print('saving results for model: ' + str(m))
save_results(data, m, model, args["save"])
def grid_search(args, perm_inputs, feat_inputs, comb_inputs, labels):
'''
The below method is a modified implementation of the gridsearch method in
KTFBinClass.py that manually iterates through all params via nested loops
this method has been created to allow for multi_input neural networks
'''
perm_width = int(len(perm_inputs[0]))
feat_width = int(len(feat_inputs[0]))
comb_width = int(len(comb_inputs[0]))
input_ratios = args["input_ratio"]
splits = args["splits"]
epochs = args["epochs"]
batch_size = args["batch_size"]
neurons = args["neurons"]
modelName = args["model"]
spits = args["splits"]
single = None
for m in modelName:
data = []
if m in ["oneLayer_perm", "oneLayer_feat", "oneLayer_comb"]:
print('single bool set')
single = True
else:
single = False
for r in args["train_ratio"]:
percent = float(r) / 100
print(percent)
sss = StratifiedShuffleSplit(n_splits=5,
random_state=0,
test_size=1 - percent)
for epoch in epochs:
for batch in batch_size:
for size in neurons:
cm = np.zeros([2, 2], dtype=np.int64)
if (single):
print ('model: ' + str(m) + ' tr: ' + str(r) + ' epochs: ' + str(epoch) + ' bs: ' \
+ str(batch) + ' n: ' + str(size))
for train_index, test_index in sss.split(
perm_inputs, labels):
perm_train, perm_test = perm_inputs[
train_index], perm_inputs[test_index]
feat_train, feat_test = feat_inputs[
train_index], feat_inputs[test_index]
comb_train, comb_test = comb_inputs[
train_index], comb_inputs[test_index]
labels_train, labels_test = labels[
train_index], labels[test_index]
if m == "oneLayer_perm":
model = create_one_layer(
optimizer='nadam',
data_width=perm_width,
neurons=size)
elif m == "oneLayer_feat":
model = create_one_layer(
optimizer='nadam',
data_width=feat_width,
neurons=size)
elif m == "oneLayer_comb":
model = create_one_layer(
optimizer='nadam',
data_width=comb_width,
neurons=size)
if m == "oneLayer_perm":
print("single_input: " + str(m))
model.fit(perm_train,
labels_train,
epochs=epoch,
batch_size=batch)
labels_pred = model.predict(
perm_test, batch_size=batch)
elif m == "oneLayer_feat":
print("single_input: " + str(m))
model.fit(feat_train,
labels_train,
epochs=epoch,
batch_size=batch)
labels_pred = model.predict(
feat_test, batch_size=batch)
elif m == "oneLayer_comb":
print("single_input: " + str(m))
model.fit(comb_train,
labels_train,
epochs=epoch,
batch_size=batch)
labels_pred = model.predict(
comb_test, batch_size=batch)
labels_pred = (labels_pred > 0.5)
cm = cm + confusion_matrix(
labels_test, labels_pred)
acc = calc_accuracy(cm)
prec = calc_precision(cm)
rec = calc_recall(cm)
f1 = calc_f1(prec, rec)
ir = 0
data.append(dict(zip(["model_name", "neurons", "train_ratio", "input_ratio", \
"epochs", "batch_size", "accuracy", "precision", "recall", "f1_score"], \
[m, size, r, ir, epoch, batch, acc, prec, rec, f1])))
else:
#else block added to include input_ratio as parameter for dual_input models
print('ENTERED ELSE - MULTI')
for ir in input_ratios:
print ('model: ' + str(m) + ' tr: ' + str(r) + ' epochs: ' + str(epoch) + ' bs: ' \
+ str(batch) + ' n: ' + str(size))
for train_index, test_index in sss.split(
perm_inputs, labels):
perm_train, perm_test = perm_inputs[
train_index], perm_inputs[test_index]
feat_train, feat_test = feat_inputs[
train_index], feat_inputs[test_index]
comb_train, comb_test = comb_inputs[
train_index], comb_inputs[test_index]
labels_train, labels_test = labels[
train_index], labels[test_index]
if m == "dual_simple":
print(
"args: batch=%i, epochs=%i, ir=%f, perm_width=%i, feat_width=%i"
% (batch, epoch, ir, perm_width,
feat_width))
model = create_dualInputSimple(input_ratio=ir, neurons=size, \
perm_width=perm_width, feat_width=feat_width)
elif m == "dual_large":
model = create_dualInputLarge(dropout_rate=.1, neurons=size,\
input_ratio=ir, perm_width=perm_width, feat_width=feat_width)
print("multi_input: " + str(m))
model.fit([perm_train, feat_train],
labels_train,
epochs=epoch,
batch_size=batch)
labels_pred = model.predict(
[perm_test, feat_test],
batch_size=batch)
labels_pred = (labels_pred > 0.5)
cm = cm + confusion_matrix(
labels_test, labels_pred)
acc = calc_accuracy(cm)
prec = calc_precision(cm)
rec = calc_recall(cm)
f1 = calc_f1(prec, rec)
data.append(dict(zip(["model_name", "neurons", "train_ratio", "input_ratio", \
"epochs", "batch_size", "accuracy", "precision", "recall", "f1_score"], \
[m, size, r, ir, epoch, batch, acc, prec, rec, f1])))
print('saving results for model: ' + str(m))
save_results(data, m, model, False)
return