xz_batch = XZ[idx]
yz_batch = YZ[idx]
target_batch = Y_train[idx]
batch_loss = f_train(xy_batch, xz_batch, yz_batch ,target_batch) #this will do the backprop pass
cur_loss += batch_loss[0]/batch_size
for i in range(num_batches_train):
idx = range(i*batch_size, (i+1)*batch_size)
xy_batch = XY[idx]
xz_batch = XZ[idx]
yz_batch = YZ[idx]
targets_batch = Y_train[idx]
net_out = f_eval(xy_batch, xz_batch, yz_batch)
preds = np.argmax(net_out, axis=-1)
confusion_train.batch_add(targets_batch, preds)
loss += [cur_loss/len(Train)]
for img in Test:
XY, XZ, YZ, Y_test = DP.Patch_triplanar_para(img, PS)
num_samples_valid = Y_test.shape[0]
num_batches_valid = num_samples_valid // batch_size
for i in range(num_batches_valid):
idx = range(i*batch_size, (i+1)*batch_size)
xy_batch = XY[idx]
xz_batch = XZ[idx]
yz_batch = YZ[idx]
targets_batch = Y_test[idx]
net_out = f_eval(xy_batch, xz_batch, yz_batch)
preds = np.argmax(net_out, axis=-1)
max_acc = accuracy
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
else:
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
saver.restore(sess, ckpt.model_checkpoint_path)
accuracy, predictions = dev_step(x_test, y_test)
#dev_step(x_dev, y_dev, writer=dev_summary_writer)
outputs = np.argmax(predictions, axis=-1)
print(outputs.shape)
confusion_test = ConfusionMatrix(num_classes)
y_test = np.argmax(y_test, axis=-1)
print(y_test.shape)
confusion_test.batch_add(y_test, outputs)
test_accuracy = confusion_test.accuracy()
a, positive_predictive_value = confusion_test.positive_predictive_value()
b, negative_predictive_value = confusion_test.negative_predictive_value()
e, F1 = confusion_test.F1()
f, MCC = confusion_test.matthews_correlation()
cf_val = confusion_test.ret_mat()
print("FINAL TEST RESULTS")
print(confusion_test)
print(cf_val)
print(" test accuracy:\t\t{:.2f} %".format(test_accuracy * 100))
print(a)
print(b)
pad = (40-len(pm.name))*" "
print("%s \t %.5e \t %.5e \t %.5e" % (
pm.name + pad,
np.linalg.norm(gm),
np.linalg.norm(um),
np.linalg.norm(pm.get_value())
))
cost_train_lst += [cost_train]
conf_train = ConfusionMatrix(num_classes)
for i in range(x_train.shape[0] // 1000):
probs_train, _ = f_eval(x_train[i*1000:(i+1)*1000])
preds_train_flat = probs_train.reshape((-1, num_classes)).argmax(-1)
conf_train.batch_add(
y_train[i*1000:(i+1)*1000].flatten(),
preds_train_flat
)
if last_decay > args.decayinterval and epoch > args.nodecay:
last_decay = 0
old_lr = sh_lr.get_value(sh_lr)
new_lr = old_lr / args.decayfac
sh_lr.set_value(lasagne.utils.floatX(new_lr))
print("Decay lr from %f to %f" % (float(old_lr), float(new_lr)))
else:
last_decay += 1
# valid
conf_valid = ConfusionMatrix(num_classes)
for i in range(n_batches_valid):
x_batch = x_valid[i*batch_size:(i+1)*batch_size]
xz_batch = XZ[idx]
yz_batch = YZ[idx]
target_batch = np.float32(Y_train[idx].reshape(batch_size, 1))
batch_loss = f_train(xy_batch, xz_batch, yz_batch,
target_batch) #this will do the backprop pass
cur_loss += batch_loss[0] / batch_size
for i in range(num_batches_train):
idx = range(i * batch_size, (i + 1) * batch_size)
xy_batch = XY[idx]
xz_batch = XZ[idx]
yz_batch = YZ[idx]
targets_batch = np.float32(Y_train[idx].reshape(batch_size, 1))
net_out = f_eval(xy_batch, xz_batch, yz_batch)
preds = np.where(net_out > threshold, upper, lower)
confusion_train.batch_add(targets_batch.reshape(batch_size, 1),
preds)
loss += [cur_loss / len(Train)]
for img in Test:
XY, XZ, YZ, Y_test = DP.Patch_triplanar_para(img, PS)
num_samples_valid = Y_test.shape[0]
num_batches_valid = num_samples_valid // batch_size
for i in range(num_batches_valid):
idx = range(i * batch_size, (i + 1) * batch_size)
xy_batch = XY[idx]
xz_batch = XZ[idx]
yz_batch = YZ[idx]
targets_batch = np.float32(Y_test[idx].reshape(batch_size, 1))
net_out = f_eval(xy_batch, xz_batch, yz_batch)
preds = np.where(net_out > threshold, upper, lower)
AB = f_vali(xy_batch, xz_batch, yz_batch, targets_batch)
x_batch_c3d_dim[2:])
# print 'the shape of x_batch_c3d after reshape:', x_batch_c3d.shape
train_out = f_train(x_batch_c3d, y_batch,
mask_batch_c3d) # y_batch_repeat
cost_train, _ = train_out[:2]
# print 'batch_train:', i, 'cost_train:', cost_train
cost_train_lst += [cost_train]
# pdb.set_trace()
cost_eval_train, probs_train = f_eval(x_batch_c3d, y_batch,
mask_batch_c3d)
# print 'batches_train_eval:', i, 'cost_eval_train:', cost_eval_train
preds_train_flat = probs_train.reshape((-1, num_classes)).argmax(-1)
conf_train.batch_add(y_batch.flatten(), preds_train_flat)
cost_eval_train_lst += [cost_eval_train]
#########################################################
# pdb.set_trace()
cost_eval_train_lst = np.array(cost_eval_train_lst)
cost_eval_train_mean = cost_eval_train_lst.mean()
cost_train_lst = np.array(cost_train_lst)
cost_train_mean = cost_train_lst.mean()
# change learning_rate
if last_decay > args.decayinterval and epoch > args.nodecay:
last_decay = 0
old_lr = sh_lr.get_value(sh_lr)
new_lr = old_lr / args.decayfac
pad = (40-len(pm.name))*" "
print "%s \t %.5e \t %.5e \t %.5e" % (
pm.name + pad,
np.linalg.norm(gm),
np.linalg.norm(um),
np.linalg.norm(pm.get_value())
)
cost_train_lst += [cost_train]
conf_train = ConfusionMatrix(num_classes)
for i in range(x_train.shape[0] // 1000):
probs_train, _ = f_eval(x_train[i*1000:(i+1)*1000])
preds_train_flat = probs_train.reshape((-1, num_classes)).argmax(-1)
conf_train.batch_add(
y_train[i*1000:(i+1)*1000].flatten(),
preds_train_flat
)
if last_decay > args.decayinterval and epoch > args.nodecay:
last_decay = 0
old_lr = sh_lr.get_value(sh_lr)
new_lr = old_lr / args.decayfac
sh_lr.set_value(lasagne.utils.floatX(new_lr))
print "Decay lr from %f to %f" % (float(old_lr), float(new_lr))
else:
last_decay += 1
# valid
conf_valid = ConfusionMatrix(num_classes)
for i in range(batches_valid):
x_batch = x_valid[i*num_batch:(i+1)*num_batch]
# Calculate epoch time start_time = time.time() # Full pass training set train_err = 0 train_batches = 0 confusion_train = ConfusionMatrix(n_class) # Generate minibatches and train on each one of them for batch in iterate_minibatches(X_tr, y_tr, mask_tr, batch_size, shuffle=True): inputs, targets, in_masks = batch tr_err, predict = train_fn(inputs, targets, in_masks) train_err += tr_err train_batches += 1 preds = np.argmax(predict, axis=-1) confusion_train.batch_add(targets, preds) train_loss = train_err / train_batches train_accuracy = confusion_train.accuracy() cf_train = confusion_train.ret_mat() # Full pass validation set val_err = 0 val_batches = 0 confusion_valid = ConfusionMatrix(n_class) # Generate minibatches and train on each one of them for batch in iterate_minibatches(X_val, y_val, mask_val, batch_size): inputs, targets, in_masks = batch err, predict_val, alpha, context = val_fn(inputs, targets, in_masks)
print "Network"
print ffn
print "Loss", losslayer
print ""
acc = []
for epoch in range(num_epochs):
confusion = ConfusionMatrix(num_classes)
for i in range(num_batches):
idx = range(i*batch_size, (i+1)*batch_size)
x_batch = x_train[idx]
target_batch = targets_train[idx]
y_probs = ffn.forward(x_batch)
loss = losslayer.fprop(y_probs, target_batch)
delta = losslayer.bprop(y_probs, target_batch)
ffn.backward(delta)
ffn.update(learning_rate)
confusion.batch_add(target_batch.argmax(-1), y_probs.argmax(-1))
curr_acc = confusion.accuracy()
print "Epoch %i : Loss %f Train acc %f" % (epoch, loss, curr_acc)
acc += [curr_acc]
train_err = 0
train_batches = 0
confusion_train = ConfusionMatrix(num_classes)
# Generate minibatches and train on each one of them
for batch in iterate_minibatches(X_tr,
y_tr,
batch_size,
shuffle=True):
inputs, targets = batch
tr_err, predict = train_step(inputs, targets)
train_err += tr_err
train_batches += 1
preds = np.argmax(predict, axis=-1)
targets = np.argmax(targets, axis=-1)
confusion_train.batch_add(targets, preds)
train_loss = train_err / train_batches
train_accuracy = confusion_train.accuracy()
cf_train = confusion_train.ret_mat()
# Full pass validation set
val_err = 0
val_batches = 0
confusion_valid = ConfusionMatrix(num_classes)
# Generate minibatches and train on each one of them
for batch in iterate_minibatches(X_val, y_val, batch_size):
inputs, targets = batch
err, predict_val = dev_step(inputs,
targets,
