def email_certificates():
if not Controller.certificates_generated:
messagebox.showerror(
"Operational Error",
"Certificates not generated yet."
)
Controller.logger.info("email_certificates() called before generate_certificates()")
return
target_dir = View.target_dir_entry.get()
email_config = View.email_config_entry.get()
mailing_list = View.mailing_list_entry.get()
email_config = format_config(email_config)
try:
mailer = Mailer(target_dir, email_config, mailing_list)
mailer.read_id_email()
mailer.send_all_emails()
messagebox.showinfo(
"Mailer Info",
"Emails dispatched successfully. Check your sent box."
)
Controller.logger.info("Emails dispatched successfully")
except Exception as exp:
exception = ''.join(traceback.format_exception(etype=type(exp), value=exp, tb=exp.__traceback__))
Controller.logger.info("mailer failed due to the following reason")
Controller.logger.info(exception)
messagebox.showerror("Unknown exception in mailer", exception)
def load_patient(subj, tmpl):
df = pd.read_csv(format_config(tmpl, {
"subject": subj,
}),
sep="\t",
header=0)
df = df.apply(lambda x: pd.to_numeric(x, errors='coerce'))
ROIs = [
"#" + str(y) for y in sorted([int(x[1:]) for x in df.keys().tolist()])
]
functional = np.nan_to_num(df[ROIs].as_matrix().T).tolist()
functional = preprocessing.scale(functional, axis=1)
functional = compute_connectivity(functional)
functional = functional.astype(np.float32)
return subj, functional.tolist()
def prepare_folds(hdf5, folds, pheno, derivatives, experiment):
exps = hdf5.require_group("experiments")
ids = pheno["FILE_ID"]
for derivative in derivatives:
exp = exps.require_group(
format_config(experiment, {
"derivative": derivative,
}))
exp.attrs["derivative"] = derivative
skf = StratifiedKFold(n_splits=folds, shuffle=True)
for i, (train_index,
test_index) in enumerate(skf.split(ids, pheno["STRAT"])):
train_index, valid_index = train_test_split(train_index,
test_size=0.33)
fold = exp.require_group(str(i))
fold["train"] = ids[train_index].tolist()
fold["valid"] = ids[valid_index].tolist()
fold["test"] = ids[test_index].tolist()
def nn_results(hdf5, experiment, code_size_1, code_size_2, code_size_3):
exp_storage = hdf5["experiments"]['cc200_whole']
experiment = "cc200_whole"
print exp_storage
n_classes = 2
results = []
list = ['']
list2 = []
for fold in exp_storage:
experiment_cv = format_config("{experiment}_{fold}", {
"experiment": experiment,
"fold": fold,
})
print "experiment_cv"
print fold
X_train, y_train, \
X_valid, y_valid, \
X_test, y_test,test_pid = load_fold(hdf5["patients"], exp_storage, fold)
list.append(test_pid)
print "X_train"
print X_train.shape
y_test = np.array([to_softmax(n_classes, y) for y in y_test])
ae1_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt",
{
"experiment": experiment_cv,
})
ae2_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt",
{
"experiment": experiment_cv,
})
ae3_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt",
{
"experiment": experiment_cv,
})
nn_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_mlp.ckpt", {
"experiment": experiment_cv,
})
try:
model = nn(X_test.shape[1], n_classes, [
{
"size": 2500,
"actv": tf.nn.tanh
},
{
"size": 1250,
"actv": tf.nn.tanh
},
{
"size": 625,
"actv": tf.nn.tanh
},
])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(model["params"])
print "savernn_model_path"
print nn_model_path
saver.restore(sess, nn_model_path)
output = sess.run(model["output"],
feed_dict={
model["input"]: X_test,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
model["dropouts"][2]: 1.0,
})
np.set_printoptions(suppress=True)
y_score = output[:, 1]
print "y_score"
print y_score
y_pred = np.argmax(output, axis=1)
print "y_pred"
print y_pred
print "output"
hang = output.shape[0]
lie = output.shape[1]
print hang
print lie
for tt in range(hang):
for xx in range(lie):
output[tt][xx] = round(output[tt][xx], 4)
output[tt][xx] = str(output[tt][xx])
aa = output[:, 0]
print type(aa)
list2.append(output)
list.append(y_pred)
print "-------------------------------------"
y_true = np.argmax(y_test, axis=1)
list.append(y_true)
print "y_true"
print y_true
auc_score = roc_auc_score(y_true, y_score)
print auc_score
[[TN, FP], [FN,
TP]] = confusion_matrix(y_true,
y_pred,
labels=[0,
1]).astype(float)
accuracy = (TP + TN) / (TP + TN + FP + FN)
print(TP)
print(TN)
print(FP)
print(FN)
specificity = TN / (FP + TN)
precision = TP / (TP + FP)
sensivity = recall = TP / (TP + FN)
fscore = 2 * TP / (2 * TP + FP + FN)
results.append([
accuracy, precision, recall, fscore, sensivity,
specificity, auc_score
])
finally:
reset()
workbook = xlwt.Workbook(encoding='utf-8')
booksheet = workbook.add_sheet('Sheet 1', cell_overwrite_ok=True)
wb = xlwt.Workbook(encoding='utf-8')
worksheet = wb.add_sheet('Sheet 1', cell_overwrite_ok=True)
DATA = list
print list2
for i, row in enumerate(DATA):
for j, col in enumerate(row):
booksheet.write(j, i, col)
# workbook.save('./data/dos_tichu_2500_1250_625_xlst.xls')
return [experiment] + np.mean(results, axis=0).tolist()
hdf5 = hdf5_handler("./data/abide_cc200_tichu.hdf5", "a")
valid_derivatives = ["cc200", "aal", "ez", "ho", "tt", "dosenbach160"]
derivatives = [
derivative for derivative in arguments["<derivative>"]
if derivative in valid_derivatives
]
experiments = []
for derivative in derivatives:
config = {"derivative": derivative}
if arguments["--whole"]:
experiments += [format_config("{derivative}_whole", config)],
if arguments["--male"]:
experiments += [format_config("{derivative}_male", config)]
if arguments["--threshold"]:
experiments += [format_config("{derivative}_threshold", config)]
if arguments["--leave-site-out"]:
for site in pheno["SITE_ID"].unique():
site_config = {"site": site}
experiments += [
format_config("{derivative}_leavesiteout-{site}", config,
site_config)
]
def run_nn(hdf5, experiment, code_size_1, code_size_2):
# tf.disable_v2_behavior()
exp_storage = hdf5["experiments"][experiment]
for fold in exp_storage:
experiment_cv = format_config("{experiment}_{fold}", {
"experiment": experiment,
"fold": fold,
})
X_train, y_train, \
X_valid, y_valid, \
X_test, y_test = load_fold(hdf5["patients"], exp_storage, fold)
ae1_model_path = format_config(
"./data/models/{experiment}_autoencoder-1.ckpt", {
"experiment": experiment_cv,
})
ae2_model_path = format_config(
"./data/models/{experiment}_autoencoder-2.ckpt", {
"experiment": experiment_cv,
})
nn_model_path = format_config("./data/models/{experiment}_mlp.ckpt", {
"experiment": experiment_cv,
})
reset()
# Run first autoencoder
run_autoencoder1(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=ae1_model_path,
code_size=code_size_1)
reset()
# Run second autoencoder
run_autoencoder2(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=ae2_model_path,
prev_model_path=ae1_model_path,
prev_code_size=code_size_1,
code_size=code_size_2)
reset()
# Run multilayer NN with pre-trained autoencoders
run_finetuning(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=nn_model_path,
prev_model_1_path=ae1_model_path,
prev_model_2_path=ae2_model_path,
code_size_1=code_size_1,
code_size_2=code_size_2)
pheno_male = pheno[pheno["SEX"] == "M"]
prepare_folds(hdf5,
folds,
pheno_male,
derivatives,
experiment="{derivative}_male")
if arguments["--threshold"]:
print
print "Preparing thresholded dataset"
pheno_thresh = pheno[pheno["MEAN_FD"] <= 0.2]
prepare_folds(hdf5,
folds,
pheno_thresh,
derivatives,
experiment="{derivative}_threshold")
if arguments["--leave-site-out"]:
print
print "Preparing leave-site-out dataset"
for site in pheno["SITE_ID"].unique():
pheno_without_site = pheno[pheno["SITE_ID"] != site]
prepare_folds(hdf5,
folds,
pheno_without_site,
derivatives,
experiment=format_config(
"{derivative}_leavesiteout-{site}", {
"site": site,
}))
def run_autoencoder2(experiment,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path,
prev_model_path,
code_size=1250,
prev_code_size=2500):
if os.path.isfile(model_path) or \
os.path.isfile(model_path + ".meta"):
return
prev_model = ae(
X_train.shape[1],
prev_code_size,
corruption=0.0, # Disable corruption for conversion
enc=tf.nn.tanh,
dec=None)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(prev_model["params"],
write_version=tf.train.SaverDef.V2)
if os.path.isfile(prev_model_path):
saver.restore(sess, prev_model_path)
X_train = sess.run(prev_model["encode"],
feed_dict={prev_model["input"]: X_train})
X_valid = sess.run(prev_model["encode"],
feed_dict={prev_model["input"]: X_valid})
X_test = sess.run(prev_model["encode"],
feed_dict={prev_model["input"]: X_test})
del prev_model
reset()
learning_rate = 0.0001
corruption = 0.9
ae_enc = tf.nn.tanh
ae_dec = None
training_iters = 2000
batch_size = 10
n_classes = 2
model = ae(prev_code_size,
code_size,
corruption=corruption,
enc=ae_enc,
dec=ae_dec)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(
model["cost"])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(model["params"],
write_version=tf.train.SaverDef.V2)
prev_costs = np.array([9999999999] * 3)
for epoch in range(training_iters):
batches = range(len(X_train) / batch_size)
costs = np.zeros((len(batches), 3))
for ib in batches:
from_i = ib * batch_size
to_i = (ib + 1) * batch_size
batch_xs, batch_ys = X_train[from_i:to_i], y_train[from_i:to_i]
_, cost_train = sess.run([optimizer, model["cost"]],
feed_dict={model["input"]: batch_xs})
cost_valid = sess.run(model["cost"],
feed_dict={model["input"]: X_valid})
cost_test = sess.run(model["cost"],
feed_dict={model["input"]: X_test})
costs[ib] = [cost_train, cost_valid, cost_test]
costs = costs.mean(axis=0)
cost_train, cost_valid, cost_test = costs
print format_config(
"Exp={experiment}, Model=ae2, Iter={epoch:5d}, Cost={cost_train:.6f} {cost_valid:.6f} {cost_test:.6f}",
{
"experiment": experiment,
"epoch": epoch,
"cost_train": cost_train,
"cost_valid": cost_valid,
"cost_test": cost_test,
}),
if cost_valid < prev_costs[1]:
print "Saving better model"
saver.save(sess, model_path)
prev_costs = costs
else:
print
def run_nn(hdf5, experiment, code_size_1, code_size_2, code_size_3):
exp_storage = hdf5["experiments"]["cc200_whole"]
#exp_storage = hdf5["experiments"]["aal_whole"]
#exp_storage = hdf5["experiments"]["dosenbach160_whole"]
for fold in exp_storage:
experiment_cv = format_config("{experiment}_{fold}", {
"experiment": experiment,
"fold": fold,
})
X_train, y_train, \
X_valid, y_valid, \
X_test, y_test,test_pid = load_fold(hdf5["patients"], exp_storage, fold)
ae1_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt",
{
"experiment": experiment_cv,
})
ae2_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt",
{
"experiment": experiment_cv,
})
ae3_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt",
{
"experiment": experiment_cv,
})
nn_model_path = format_config(
"./data/cc200_tichu_2500_1250_625/{experiment}_mlp.ckpt", {
"experiment": experiment_cv,
})
# ae1_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", {
# "experiment": experiment_cv,
# })
# ae2_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", {
# "experiment": experiment_cv,
# })
# ae3_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", {
# "experiment": experiment_cv,
# })
# nn_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_mlp.ckpt", {
# "experiment": experiment_cv,
# })
# ae1_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", {
# "experiment": experiment_cv,
# })
# ae2_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", {
# "experiment": experiment_cv,
# })
# ae3_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", {
# "experiment": experiment_cv,
# })
# nn_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_mlp.ckpt", {
# "experiment": experiment_cv,
# })
reset()
# Run first autoencoder
run_autoencoder1(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=ae1_model_path,
code_size=code_size_1)
reset()
# Run second autoencoder
run_autoencoder2(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=ae2_model_path,
prev_model_path=ae1_model_path,
prev_code_size=code_size_1,
code_size=code_size_2)
reset()
run_autoencoder3(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=ae3_model_path,
prev_model_path=ae2_model_path,
prev_code_size=code_size_2,
code_size=code_size_3)
reset()
# Run multilayer NN with pre-trained autoencoders
run_finetuning(experiment_cv,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path=nn_model_path,
prev_model_1_path=ae1_model_path,
prev_model_2_path=ae2_model_path,
prev_model_3_path=ae3_model_path,
code_size_1=code_size_1,
code_size_2=code_size_2,
code_size_3=code_size_3)
def run_finetuning(experiment,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path,
prev_model_1_path,
prev_model_2_path,
prev_model_3_path,
code_size_1=2500,
code_size_2=1250,
code_size_3=625):
learning_rate = 0.0005
dropout_1 = 0.6
dropout_2 = 0.8
dropout_3 = 0.6
initial_momentum = 0.1
final_momentum = 0.9 # Increase momentum along epochs to avoid fluctiations
saturate_momentum = 100
training_iters = 100
start_saving_at = 20
batch_size = 10
n_classes = 2
if os.path.isfile(model_path) or \
os.path.isfile(model_path + ".meta"):
return
y_train = np.array([to_softmax(n_classes, y) for y in y_train])
y_valid = np.array([to_softmax(n_classes, y) for y in y_valid])
y_test = np.array([to_softmax(n_classes, y) for y in y_test])
ae1 = load_ae_encoder(X_train.shape[1], code_size_1, prev_model_1_path)
ae2 = load_ae_encoder(code_size_1, code_size_2, prev_model_2_path)
ae3 = load_ae_encoder(code_size_2, code_size_3, prev_model_3_path)
model = nn(X_train.shape[1], n_classes, [
{
"size": code_size_1,
"actv": tf.nn.tanh
},
{
"size": code_size_2,
"actv": tf.nn.tanh
},
{
"size": code_size_3,
"actv": tf.nn.tanh
},
], [
{
"W": ae1["W_enc"],
"b": ae1["b_enc"]
},
{
"W": ae2["W_enc"],
"b": ae2["b_enc"]
},
{
"W": ae3["W_enc"],
"b": ae3["b_enc"]
},
])
model["momentum"] = tf.placeholder("float32")
optimizer = tf.train.MomentumOptimizer(
learning_rate, model["momentum"]).minimize(model["cost"])
# Compute accuracies
correct_prediction = tf.equal(tf.argmax(model["output"], 1),
tf.argmax(model["expected"], 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
# Define model saver
saver = tf.train.Saver(model["params"],
write_version=tf.train.SaverDef.V2)
prev_costs = np.array([9999999999] * 3)
prev_accs = np.array([0.0] * 3)
# Iterate Epochs
for epoch in range(training_iters):
batches = range(len(X_train) / batch_size)
costs = np.zeros((len(batches), 3))
accs = np.zeros((len(batches), 3))
# Compute momentum saturation
alpha = float(epoch) / float(saturate_momentum)
if alpha < 0.:
alpha = 0.
if alpha > 1.:
alpha = 1.
momentum = initial_momentum * (1 - alpha) + alpha * final_momentum
for ib in batches:
from_i = ib * batch_size
to_i = (ib + 1) * batch_size
batch_xs, batch_ys = X_train[from_i:to_i], y_train[from_i:to_i]
_, cost_train, acc_train = sess.run(
[optimizer, model["cost"], accuracy],
feed_dict={
model["input"]: batch_xs,
model["expected"]: batch_ys,
model["dropouts"][0]: dropout_1,
model["dropouts"][1]: dropout_2,
model["dropouts"][2]: dropout_3,
model["momentum"]: momentum,
})
cost_valid, acc_valid = sess.run(
[model["cost"], accuracy],
feed_dict={
model["input"]: X_valid,
model["expected"]: y_valid,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
model["dropouts"][2]: 1.0,
})
cost_test, acc_test = sess.run(
[model["cost"], accuracy],
feed_dict={
model["input"]: X_test,
model["expected"]: y_test,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
model["dropouts"][2]: 1.0,
})
costs[ib] = [cost_train, cost_valid, cost_test]
accs[ib] = [acc_train, acc_valid, acc_test]
costs = costs.mean(axis=0)
cost_train, cost_valid, cost_test = costs
accs = accs.mean(axis=0)
acc_train, acc_valid, acc_test = accs
print format_config(
"Exp={experiment}, Model=mlp, Iter={epoch:5d}, Acc={acc_train:.6f} {acc_valid:.6f} {acc_test:.6f}, Momentum={momentum:.6f}",
{
"experiment": experiment,
"epoch": epoch,
"acc_train": acc_train,
"acc_valid": acc_valid,
"acc_test": acc_test,
"momentum": momentum,
}),
if acc_valid > prev_accs[1] and epoch > start_saving_at:
print "Saving better model"
saver.save(sess, model_path)
prev_accs = accs
prev_costs = costs
else:
print "123"
def run_autoencoder1(experiment,
X_train,
y_train,
X_valid,
y_valid,
X_test,
y_test,
model_path,
code_size=2500):
learning_rate = 0.0001
sparse = True # Add sparsity penalty
sparse_p = 0.2
sparse_coeff = 0.5
corruption = 0.3 # Data corruption ratio for denoising
ae_enc = tf.nn.tanh # Tangent hyperbolic
ae_dec = None # Linear activation
training_iters = 700
batch_size = 100
n_classes = 2
if os.path.isfile(model_path) or \
os.path.isfile(model_path + ".meta"):
return
model = ae(X_train.shape[1],
code_size,
corruption=corruption,
enc=ae_enc,
dec=ae_dec)
if sparse:
model["cost"] += sparsity_penalty(model["encode"], sparse_p,
sparse_coeff)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(
model["cost"])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(model["params"],
write_version=tf.train.SaverDef.V2)
prev_costs = np.array([9999999999] * 3)
for epoch in range(training_iters):
batches = range(len(X_train) / batch_size)
costs = np.zeros((len(batches), 3))
for ib in batches:
from_i = ib * batch_size
to_i = (ib + 1) * batch_size
batch_xs, batch_ys = X_train[from_i:to_i], y_train[from_i:to_i]
_, cost_train = sess.run([optimizer, model["cost"]],
feed_dict={model["input"]: batch_xs})
cost_valid = sess.run(model["cost"],
feed_dict={model["input"]: X_valid})
cost_test = sess.run(model["cost"],
feed_dict={model["input"]: X_test})
costs[ib] = [cost_train, cost_valid, cost_test]
costs = costs.mean(axis=0)
cost_train, cost_valid, cost_test = costs
print format_config(
"Exp={experiment}, Model=ae1, Iter={epoch:5d}, Cost={cost_train:.6f} {cost_valid:.6f} {cost_test:.6f}",
{
"experiment": experiment,
"epoch": epoch,
"cost_train": cost_train,
"cost_valid": cost_valid,
"cost_test": cost_test,
}),
if cost_valid < prev_costs[1]:
print "Saving better model"
saver.save(sess, model_path)
prev_costs = costs
else:
print
def nn_results(hdf5, experiment, code_size_1, code_size_2):
exp_storage = hdf5["experiments"][experiment]
n_classes = 2
results = []
for fold in exp_storage:
experiment_cv = format_config("{experiment}_{fold}", {
"experiment": experiment,
"fold": fold,
})
X_train, y_train, \
X_valid, y_valid, \
X_test, y_test = load_fold(hdf5["patients"], exp_storage, fold)
y_test = np.array([to_softmax(n_classes, y) for y in y_test])
ae1_model_path = format_config(
"./data/models/{experiment}_autoencoder-1.ckpt", {
"experiment": experiment_cv,
})
ae2_model_path = format_config(
"./data/models/{experiment}_autoencoder-2.ckpt", {
"experiment": experiment_cv,
})
nn_model_path = format_config("./data/models/{experiment}_mlp.ckpt", {
"experiment": experiment_cv,
})
try:
model = nn(X_test.shape[1], n_classes, [
{
"size": 1000,
"actv": tf.nn.tanh
},
{
"size": 600,
"actv": tf.nn.tanh
},
])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(model["params"])
saver.restore(sess, nn_model_path)
output = sess.run(model["output"],
feed_dict={
model["input"]: X_test,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
})
print(output)
y_pred = np.argmax(output, axis=1)
y_true = np.argmax(y_test, axis=1)
[[TN, FP], [FN,
TP]] = confusion_matrix(y_true,
y_pred,
labels=[0,
1]).astype(float)
accuracy = (TP + TN) / (TP + TN + FP + FN)
specificity = TN / (FP + TN)
precision = TP / (TP + FP)
sensivity = recall = TP / (TP + FN)
fscore = 2 * TP / (2 * TP + FP + FN)
results.append([
accuracy, precision, recall, fscore, sensivity, specificity
])
finally:
reset()
return [experiment] + np.mean(results, axis=0).tolist()
def reduce(config, folds, model_path, data_path, id_path):
n_classes = 2
fold_data = []
for fold in range(1, folds + 1):
config = config.copy()
config["fold"] = fold
fold_model_path = format_config(model_path, config)
train_path = format_config(data_path, config, {"datatype": "train"})
valid_path = format_config(data_path, config, {"datatype": "valid"})
test_path = format_config(data_path, config, {"datatype": "test"})
train_id_path = format_config(id_path, config, {"datatype": "train"})
valid_id_path = format_config(id_path, config, {"datatype": "valid"})
test_id_path = format_config(id_path, config, {"datatype": "test"})
train_data = np.loadtxt(train_path, delimiter=",")
train_X, train_y = train_data[:, 1:], train_data[:, 0]
valid_data = np.loadtxt(valid_path, delimiter=",")
valid_X, valid_y = valid_data[:, 1:], valid_data[:, 0]
train_ids = np.genfromtxt(train_id_path, dtype="str")
valid_ids = np.genfromtxt(valid_id_path, dtype="str")
train_X = np.concatenate([train_X, valid_X])
train_y = np.concatenate([train_y, valid_y])
train_ids = np.concatenate([train_ids, valid_ids])
test_data = np.loadtxt(test_path, delimiter=",")
test_X, test_y = test_data[:, 1:], test_data[:, 0]
test_ids = np.genfromtxt(test_id_path, dtype="str")
model = nn(test_X.shape[1], n_classes, [
{
"size": 1000,
"actv": tf.nn.tanh
},
{
"size": 600,
"actv": tf.nn.tanh
},
])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
saver = tf.train.Saver(model["params"])
saver.restore(sess, fold_model_path)
train_X = sess.run(model["actvs"][1],
feed_dict={
model["input"]: train_X,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
})
test_X = sess.run(model["actvs"][1],
feed_dict={
model["input"]: test_X,
model["dropouts"][0]: 1.0,
model["dropouts"][1]: 1.0,
})
X = np.concatenate([train_X, test_X])
y = np.concatenate([train_y, test_y]).astype(int)
ids = np.concatenate([train_ids, test_ids])
datatype = np.concatenate(
[np.ones(train_y.shape),
np.zeros(test_y.shape)]).astype(int)
fold_data.append({
"X": X,
"y": y,
"ids": ids,
"datatype": datatype,
"config": config
})
LOG_DIR = './tensorboard/'
glob_sess = tf.InteractiveSession()
summary_writer = tf.summary.FileWriter(LOG_DIR)
projector_config = projector.ProjectorConfig()
embeddings = []
for data in fold_data:
X = data["X"]
y = data["y"]
ids = data["ids"]
datatype = data["datatype"]
config = data["config"]
embedding_tensor = format_config("embedding_{fold}", config)
embedding_var = tf.Variable(X, trainable=False, name=embedding_tensor)
embedding_var.initializer.run()
embeddings.append(embedding_var)
embedding = projector_config.embeddings.add()
embedding.tensor_name = embedding_tensor
embedding.metadata_path = os.path.join(
LOG_DIR, format_config("metadata_{fold}.tsv", config))
names = ["ASD", "TC"]
dt = ["Test", "Train"]
with open(embedding.metadata_path, "w") as metadata_file:
metadata_file.write("ID\tSite\tClass\tDatatype\n")
for i, subject in enumerate(ids):
site = "_".join(subject.split("_")[:-1])
metadata_file.write(
"%s\t%s\t%s\t%s\n" %
(subject, site, names[y[i]], dt[datatype[i]]))
saver = tf.train.Saver(embeddings)
projector.visualize_embeddings(summary_writer, projector_config)
saver.save(glob_sess, os.path.join(LOG_DIR, "embeddings.ckpt"))
glob_sess.close()
