def train_test_dense_net_split(args):
filepath = check_path("weights/{}_split/weights.hdf5".format(
args['dataset']))
train_df = get_train_dataset_info(args['dataset'])
test_df = get_test_dataset_info(args['dataset'])
trn_flow, val_flow = get_training_and_validation_flow(args,
train_df,
split_size=0.10)
tst_flow = create_flow(args, test_df, batch_size=1, shuffle=False)
model = train_or_load_model(args, trn_flow, val_flow, filepath, trn_flow.n,
val_flow.n)
y_pred_prob = model.predict_generator(generator=tst_flow,
verbose=1,
steps=tst_flow.n)
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow, test_df)
metrics_dict = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes = list(zip(y_pred_prob.tolist(), y_test))
print_classifications(args, tst_flow.filenames, test_df, y_pred)
print_results(args, metrics_dict)
calculate_average_precision_ks(args, y_pred_prob_classes)
calculate_accuracy_per_class(args, y_test, y_pred)
draw_class_activation_map(args, model, test_df)
def train_test_dense_net_cv(args):
info = get_train_dataset_info(args['dataset'])
x, y, = info.iloc[:, 0].values, info.iloc[:, 1].values
metrics_dict, y_pred_prob_classes, fold_nr = defaultdict(int), [], 1
k_fold = StratifiedKFold(n_splits=args['nr_folds'],
shuffle=True,
random_state=args['random_seed'])
for train, test in k_fold.split(x, y):
filepath = "weights/{}_cv/weights_fold_{}_from_{}.hdf5"
filepath = check_path(
filepath.format(args['dataset'], fold_nr, args['nr_folds']))
train_data_frame = pd.DataFrame(data={
'filename': x[train],
'class': y[train]
})
test_data_frame = pd.DataFrame(data={
'filename': x[test],
'class': y[test]
})
trn_flow, val_flow = get_training_and_validation_flow(
args, train_data_frame)
tst_flow = create_flow(args,
test_data_frame,
batch_size=1,
shuffle=False)
model = train_or_load_model(args, trn_flow, val_flow, filepath,
trn_flow.n, val_flow.n)
y_pred_prob = model.predict_generator(generator=tst_flow,
verbose=1,
steps=tst_flow.n)
y_pred_prob, y_pred, y_test = calculate_prediction(
args, y_pred_prob, trn_flow, test_data_frame)
metrics_it = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes += list(zip(y_pred_prob.tolist(), y_test))
print_fold_results(args, metrics_it)
print_classifications(args, tst_flow.filenames, test_data_frame,
y_pred)
calculate_accuracy_per_class(args, y_test, y_pred)
draw_class_activation_map(args, model, test_data_frame)
metrics_dict = dict(
(k, metrics_dict[k] + v) for k, v in metrics_it.items())
K.clear_session()
fold_nr += 1
metrics_dict = dict(
(k, v / args['nr_folds']) for k, v in metrics_dict.items())
print_results(args, metrics_dict)
calculate_average_precision_ks(args, y_pred_prob_classes)
def train_test_attention_guided_cnn_cv(args):
info = get_train_dataset_info(args['dataset'])
x, y, = info.iloc[:, 0].values, info.iloc[:, 1].values
metrics_dict_glob, y_pred_prob_classes_glob = defaultdict(int), []
metrics_dict, y_pred_prob_classes, fl_nr = defaultdict(int), [], 1
k_fold = StratifiedKFold(n_splits=args['nr_folds'],
shuffle=True,
random_state=args['random_seed'])
# y_test_final, y_prob_final, y_pred_final = [], [], []
for train, test in k_fold.split(x, y):
train_data_frame = pd.DataFrame(data={
'filename': x[train],
'class': y[train]
})
test_data_frame = pd.DataFrame(data={
'filename': x[test],
'class': y[test]
})
first_branch_path = "weights/{}_attention_guided_global_branch_cv/weights_fold_{}_from_{}.hdf5"
first_branch_path = check_path(
first_branch_path.format(args['dataset'], fl_nr, args['nr_folds']))
second_branch_path = "weights/{}_attention_guided_local_branch_cv/weights_fold_{}_from_{}.hdf5"
second_branch_path = check_path(
second_branch_path.format(args['dataset'], fl_nr,
args['nr_folds']))
all_network_path = "weights/{}_attention_guided_all_cv/weights_fold_{}_from_{}.hdf5"
all_network_path = check_path(
all_network_path.format(args['dataset'], fl_nr, args['nr_folds']))
trn_flow_1, val_flow_1 = get_training_and_validation_flow(
args, train_data_frame)
model_global = train_or_load_model(args, trn_flow_1, val_flow_1,
first_branch_path, trn_flow_1.n,
val_flow_1.n)
tst_flow_1 = create_flow(args,
test_data_frame,
batch_size=1,
shuffle=False)
y_pred_prob = model_global.predict_generator(generator=tst_flow_1,
verbose=1,
steps=tst_flow_1.n)
y_pred_prob, y_pred, y_test = calculate_prediction(
args, y_pred_prob, trn_flow_1, test_data_frame)
metrics_it_glob = accuracy_precision_recall_fscore(
args, y_test, y_pred)
y_pred_prob_classes_glob += list(zip(y_pred_prob.tolist(), y_test))
print("Global branch results.")
print_fold_results(args, metrics_it_glob)
calculate_accuracy_per_class(args, y_test, y_pred)
test_data_frame_2 = crop_and_draw_class_activation_map(
args, model_global, test_data_frame, fl_nr)
train_data_frame_2 = crop_and_draw_class_activation_map(
args, model_global, train_data_frame, fl_nr)
trn_flow_2, val_flow_2 = get_training_and_validation_flow(
args, train_data_frame_2)
model_local = train_or_load_model(args, trn_flow_2, val_flow_2,
second_branch_path, trn_flow_2.n,
val_flow_2.n)
tst_flow_2 = create_flow(args,
test_data_frame_2,
batch_size=1,
shuffle=False)
y_pred_prob = model_local.predict_generator(generator=tst_flow_2,
verbose=1,
steps=tst_flow_2.n)
y_pred_prob, y_pred, y_test = calculate_prediction(
args, y_pred_prob, trn_flow_2, test_data_frame_2)
metrics_it = accuracy_precision_recall_fscore(args, y_test, y_pred)
print("Local branch results.")
print_fold_results(args, metrics_it)
calculate_accuracy_per_class(args, y_test, y_pred)
trn_flow_merged = merge_input_generators(trn_flow_1, trn_flow_2)
val_flow_merged = merge_input_generators(val_flow_1, val_flow_2)
tst_flow_merged = merge_input_generators(tst_flow_1, tst_flow_2)
models = {"model_global": model_global, "model_local": model_local}
model = train_or_load_model(args,
trn_flow_merged,
val_flow_merged,
all_network_path,
trn_flow_1.n,
val_flow_1.n,
branches_models=models)
y_pred_prob = model.predict_generator(generator=tst_flow_merged,
verbose=1,
steps=tst_flow_1.n)
y_pred_prob, y_pred, y_test = calculate_prediction(
args, y_pred_prob, trn_flow_1, test_data_frame)
metrics_it = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes += list(zip(y_pred_prob.tolist(), y_test))
print("Fused model results.")
print_fold_results(args, metrics_it)
print_classifications(args, tst_flow_1.filenames, test_data_frame,
y_pred)
calculate_accuracy_per_class(args, y_test, y_pred)
draw_class_activation_map(args, model, test_data_frame)
# y_pred_final += y_pred
# y_test_final += y_test.astype(int).tolist()
# y_prob_final.extend([x.tolist() for x in y_pred_prob])
metrics_dict = dict(
(k, metrics_dict[k] + v) for k, v in metrics_it.items())
metrics_dict_glob = dict(
(k, metrics_dict_glob[k] + v) for k, v in metrics_it_glob.items())
K.clear_session()
fl_nr += 1
print("Global branch results.")
metrics_dict_glob = dict(
(k, v / args['nr_folds']) for k, v in metrics_dict_glob.items())
print_results(args, metrics_dict_glob)
calculate_average_precision_ks(args, y_pred_prob_classes_glob)
# precision, recall, average_precision = dict(), dict(), dict()
# y_test_bin_final = label_binarize(y_test_final, classes=[0, 1, 2])
# y_prob_final = np.array(y_prob_final)
# for i in range(3):
# precision[i], recall[i], _ = precision_recall_curve(y_test_bin_final[:, i],
# y_prob_final[:, i])
# average_precision[i] = average_precision_score(y_test_bin_final[:, i], y_prob_final[:, i])
#
# colors = cycle(['navy', 'turquoise', 'darkorange'])
# tags = ["no flood", "water < 1m", "water > 1m"]
# lines = []
# labels = []
# for i, color in zip(range(3), colors):
# l, = plt.plot(recall[i], precision[i], color=color, lw=2)
# lines.append(l)
# labels.append('Precision-recall for {0} (area = {1:0.2f})'
# ''.format(tags[i], average_precision[i]))
#
# plt.xlim([0.0, 1.0])
# plt.ylim([0.0, 1.05])
# plt.xlabel('Recall')
# plt.ylabel('Precision')
# plt.legend(lines, labels)
# plt.savefig('prec_rec.png')
#
# print(confusion_matrix(y_test_final, y_pred_final))
print("Fused model results.")
metrics_dict = dict(
(k, v / args['nr_folds']) for k, v in metrics_dict.items())
print_results(args, metrics_dict)
calculate_average_precision_ks(args, y_pred_prob_classes)
def train_test_attention_guided_cnn_split(args):
train_df = get_train_dataset_info(args['dataset'])
test_df = get_test_dataset_info(args['dataset'])
first_branch_path = "weights/{}_attention_guided_global_branch/weights.hdf5"
first_branch_path = check_path(first_branch_path.format(args['dataset']))
second_branch_path = "weights/{}_attention_guided_local_branch/weights.hdf5"
second_branch_path = check_path(second_branch_path.format(args['dataset']))
all_network_path = "weights/{}_attention_guided_all/weights.hdf5"
all_network_path = check_path(all_network_path.format(args['dataset']))
trn_flow_1, val_flow_1 = get_training_and_validation_flow(args, train_df)
model_global = train_or_load_model(args, trn_flow_1, val_flow_1,
first_branch_path, trn_flow_1.n,
val_flow_1.n)
tst_flow_1 = create_flow(args, test_df, batch_size=1, shuffle=False)
y_pred_prob = model_global.predict_generator(generator=tst_flow_1,
verbose=1,
steps=tst_flow_1.n)
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_1, test_df)
metrics_dict = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes = list(zip(y_pred_prob.tolist(), y_test))
print("Global branch results.")
print_results(args, metrics_dict)
calculate_accuracy_per_class(args, y_test, y_pred)
calculate_average_precision_ks(args, y_pred_prob_classes)
test_data_frame_2 = crop_and_draw_class_activation_map(
args, model_global, test_df)
train_data_frame_2 = crop_and_draw_class_activation_map(
args, model_global, train_df)
trn_flow_2, val_flow_2 = get_training_and_validation_flow(
args, train_data_frame_2)
model_local = train_or_load_model(args, trn_flow_2, val_flow_2,
second_branch_path, trn_flow_2.n,
val_flow_2.n)
tst_flow_2 = create_flow(args,
test_data_frame_2,
batch_size=1,
shuffle=False)
y_pred_prob = model_local.predict_generator(generator=tst_flow_2,
verbose=1,
steps=tst_flow_2.n)
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_2,
test_data_frame_2)
metrics_dict = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes = list(zip(y_pred_prob.tolist(), y_test))
print("Local branch results.")
print_results(args, metrics_dict)
calculate_accuracy_per_class(args, y_test, y_pred)
calculate_average_precision_ks(args, y_pred_prob_classes)
trn_flow_merged = merge_input_generators(trn_flow_1, trn_flow_2)
val_flow_merged = merge_input_generators(val_flow_1, val_flow_2)
tst_flow_merged = merge_input_generators(tst_flow_1, tst_flow_2)
models = {"model_global": model_global, "model_local": model_local}
model = train_or_load_model(args,
trn_flow_merged,
val_flow_merged,
all_network_path,
trn_flow_1.n,
val_flow_1.n,
branches_models=models)
y_pred_prob = model.predict_generator(generator=tst_flow_merged,
verbose=1,
steps=tst_flow_1.n)
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_1, test_df)
metrics_dict = accuracy_precision_recall_fscore(args, y_test, y_pred)
y_pred_prob_classes = list(zip(y_pred_prob.tolist(), y_test))
print("Fused model results.")
print_results(args, metrics_dict)
print_classifications(args, tst_flow_1.filenames, test_df, y_pred)
calculate_accuracy_per_class(args, y_test, y_pred)
calculate_average_precision_ks(args, y_pred_prob_classes)
def train_test_attention_guided_cnn_split_regression(args):
train_df = get_train_dataset_info(args['dataset'])
test_df = get_test_dataset_info(args['dataset'])
first_branch_path = "weights/{}_attention_guided_global_branch/weights.hdf5"
first_branch_path = check_path(first_branch_path.format(args['dataset']))
second_branch_path = "weights/{}_attention_guided_local_branch/weights.hdf5"
second_branch_path = check_path(second_branch_path.format(args['dataset']))
all_network_path = "weights/{}_attention_guided_all/weights.hdf5"
all_network_path = check_path(all_network_path.format(args['dataset']))
trn_df_1_global = pd.DataFrame(data={
'filename': train_df['filename'].values,
'class': train_df['class'].values
})
trn_df_2_global = pd.DataFrame(
data={
'filename': train_df['filename'].values,
'class': train_df['height'].values
})
tst_df_1_global = pd.DataFrame(data={
'filename': test_df['filename'].values,
'class': test_df['class'].values
})
tst_df_2_global = pd.DataFrame(data={
'filename': test_df['filename'].values,
'class': test_df['height'].values
})
trn_flow_1_global, val_flow_1_global = get_training_and_validation_flow(
args, trn_df_1_global, class_mode="categorical", split_size=0.10)
trn_flow_2_global, val_flow_2_global = get_training_and_validation_flow(
args, trn_df_2_global, split_size=0.10)
tst_flow_1_global = create_flow(args,
tst_df_1_global,
batch_size=1,
shuffle=False)
tst_flow_2_global = create_flow(args,
tst_df_2_global,
batch_size=1,
shuffle=False)
trn_flow_global = merge_output_generators(trn_flow_1_global,
trn_flow_2_global)
val_flow_global = merge_output_generators(val_flow_1_global,
val_flow_2_global)
tst_flow_global = merge_output_generators(tst_flow_1_global,
tst_flow_2_global)
model_global = train_or_load_model(args,
trn_flow_global,
val_flow_global,
first_branch_path,
trn_flow_1_global.n,
val_flow_1_global.n,
branch="global")
y_pred_prob = model_global.predict_generator(generator=tst_flow_global,
verbose=1,
steps=tst_flow_1_global.n)[1]
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_global,
tst_df_2_global)
metrics_dict = accuracy_precision_recall_fscore(
args, y_test, y_pred, y_test2=tst_df_1_global['class'].values)
print("Global branch results.")
print_results(args, metrics_dict)
calculate_accuracy_per_class(args, y_test, y_pred)
tst_local_df = crop_and_draw_class_activation_map(args, model_global,
test_df)
trn_local_df = crop_and_draw_class_activation_map(args, model_global,
train_df)
tst_local_df_1 = pd.DataFrame(
data={
'filename': tst_local_df['filename'].values,
'class': tst_local_df['class'].values
})
tst_local_df_2 = pd.DataFrame(
data={
'filename': tst_local_df['filename'].values,
'class': tst_local_df['height'].values
})
trn_local_df_1 = pd.DataFrame(
data={
'filename': trn_local_df['filename'].values,
'class': trn_local_df['class'].values
})
trn_local_df_2 = pd.DataFrame(
data={
'filename': trn_local_df['filename'].values,
'class': trn_local_df['height'].values
})
trn_flow_1_local, val_flow_1_local = get_training_and_validation_flow(
args, trn_local_df_1, class_mode="categorical", split_size=0.10)
trn_flow_2_local, val_flow_2_local = get_training_and_validation_flow(
args, trn_local_df_2, split_size=0.10)
tst_flow_1_local = create_flow(args,
tst_local_df_1,
batch_size=1,
shuffle=False)
tst_flow_2_local = create_flow(args,
tst_local_df_2,
batch_size=1,
shuffle=False)
trn_flow_local = merge_output_generators(trn_flow_1_local,
trn_flow_2_local)
val_flow_local = merge_output_generators(val_flow_1_local,
val_flow_2_local)
tst_flow_local = merge_output_generators(tst_flow_1_local,
tst_flow_2_local)
model_local = train_or_load_model(args,
trn_flow_local,
val_flow_local,
second_branch_path,
trn_flow_2_local.n,
val_flow_2_local.n,
branch="local")
y_pred_prob = model_local.predict_generator(generator=tst_flow_local,
verbose=1,
steps=tst_flow_2_local.n)[1]
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_2_local,
tst_local_df_2)
metrics_dict = accuracy_precision_recall_fscore(
args, y_test, y_pred, y_test2=tst_local_df_1['class'].values)
print("Local branch results.")
print_results(args, metrics_dict)
calculate_accuracy_per_class(args, y_test, y_pred)
trn_flow_merged = merge_all_generators(trn_flow_1_global, trn_flow_2_local)
val_flow_merged = merge_all_generators(val_flow_1_global, val_flow_2_local)
tst_flow_merged = merge_all_generators(tst_flow_1_global, tst_flow_2_local)
models = {"model_global": model_global, "model_local": model_local}
model = train_or_load_model(args,
trn_flow_merged,
val_flow_merged,
all_network_path,
trn_flow_1_local.n,
val_flow_1_local.n,
branches_models=models)
y_pred_prob = model.predict_generator(generator=tst_flow_merged,
verbose=1,
steps=tst_flow_1_local.n)[1]
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow_1_global,
tst_df_2_global)
metrics_dict = accuracy_precision_recall_fscore(
args, y_test, y_pred, y_test2=tst_df_1_global['class'].values)
print("Fused model results.")
print_results(args, metrics_dict)
print_classifications(args, tst_flow_1_global.filenames, test_df, y_pred)
calculate_accuracy_per_class(args, y_test, y_pred)
def train_test_dense_net_split_regression(args):
filepath = check_path("weights/{}_split/weights.hdf5".format(
args['dataset']))
train_df = get_train_dataset_info(args['dataset'])
test_df = get_test_dataset_info(args['dataset'])
trn_df_1 = pd.DataFrame(data={
'filename': train_df['filename'].values,
'class': train_df['class'].values
})
trn_df_2 = pd.DataFrame(
data={
'filename': train_df['filename'].values,
'class': train_df['height'].values
})
test_data_frame_1 = pd.DataFrame(data={
'filename': test_df['filename'].values,
'class': test_df['class'].values
})
test_data_frame_2 = pd.DataFrame(data={
'filename': test_df['filename'].values,
'class': test_df['height'].values
})
trn_flow_1, val_flow_1 = get_training_and_validation_flow(
args, trn_df_1, class_mode="categorical", split_size=0.10)
trn_flow_2, val_flow_2 = get_training_and_validation_flow(args,
trn_df_2,
split_size=0.10)
tst_flow_1 = create_flow(args,
test_data_frame_1,
batch_size=1,
shuffle=False)
tst_flow_2 = create_flow(args,
test_data_frame_2,
batch_size=1,
shuffle=False)
trn_flow = merge_output_generators(trn_flow_1, trn_flow_2)
val_flow = merge_output_generators(val_flow_1, val_flow_2)
tst_flow = merge_output_generators(tst_flow_1, tst_flow_2)
model = train_or_load_model(args,
trn_flow,
val_flow,
filepath,
trn_flow_1.n,
val_flow_1.n,
branch="global")
y_pred_prob = model.predict_generator(generator=tst_flow,
verbose=1,
steps=tst_flow_1.n)[1]
y_pred_prob, y_pred, y_test = calculate_prediction(args, y_pred_prob,
trn_flow,
test_data_frame_2)
metrics_dict = accuracy_precision_recall_fscore(
args, y_test, y_pred, y_test2=test_data_frame_1['class'].values)
print_classifications(args, tst_flow_1.filenames, test_data_frame_2,
y_pred)
print_results(args, metrics_dict)