def plot_sine_figures(project_dir, time_tag, model_name):
# make the save folder
save_folder = project_dir / f'figures/{model_name}'
try:
os.makedirs(save_folder)
except FileExistsError:
pass
# load previously trained model
device = torch.device('cpu')
conf = OmegaConf.load(project_dir / f'runs/sine/{model_name}/conf.yaml')
h_sizes = OmegaConf.to_container(conf.hidden_sizes)
model = MLPModel(dim_y=1, dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l,
hidden_sizes_encoder=h_sizes,
hidden_sizes_ode_net=h_sizes,
hidden_sizes_decoder=h_sizes, t0=-0.1, device=device)
model_weights = torch.load(project_dir / f'runs/sine/{model_name}/seed_0/model.pth',
map_location=device)
model.load_state_dict(model_weights)
# create a sine dataset
dataset = SineData()
dataloader = DataLoader(dataset, batch_size=conf.batch_size, drop_last=True)
t, y = next(iter(dataloader))
t_context, y_context, t_extra, y_extra, _, _ = get_split(t, y, test_context_size=conf.test_context_size)
with torch.no_grad():
plot_sine_img(model, 0, t, y, t_context, y_context, t_extra, save_folder, time_tag)
plot_sine_img(model, 1, t, y, t_context, y_context, t_extra, save_folder, time_tag)
plot_sine_img(model, 2, t, y, t_context, y_context, t_extra, save_folder, time_tag)
plot_sine_img(model, 3, t, y, t_context, y_context, t_extra, save_folder, time_tag)
plot_sine_img(model, 4, t, y, t_context, y_context, t_extra, save_folder, time_tag)
def main():
parser = build_parser()
options = parser.parse_args()
batch_size=options.batch_size
#train_names=utils.train_names
# train_set = utils.get_train()
# val_set = utils.val_n
model = Resnet()
model.cuda()
model = torch.nn.DataParallel(model)
###########################
#train_set,val_set = train_test_split(train_names, test_size=0.2, random_state=2050)
train_set,val_set=utils.get_split()
train_set = utils.get_train(train_set)
train_datasest=ProteinDataset(dirpath=utils.TRAIN,fnames=train_set)
train_loader = DataLoader(train_datasest, batch_size=batch_size, shuffle=True,num_workers=4)
val_dataset = ProteinDataset(dirpath=utils.TRAIN,fnames=val_set)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
train(model, options.epochs, train_loader,val_loader,'sgdr_rgb.pkl')
def get_train_val_generators(fold):
tr_keys, te_keys = get_split(fold, split_seed)
train_data = {i: dataset[i] for i in tr_keys}
val_data = {i: dataset[i] for i in te_keys}
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
INPUT_PATCH_SIZE,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(0., 350.),
sigma=(14., 17.),
do_rotation=True,
a_x=(0, 2. * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.7, 1.3),
seeds=workers_seeds) # new se has no brain mask
data_gen_validation = BatchGenerator(val_data,
BATCH_SIZE,
num_batches=None,
seed=False,
PATCH_SIZE=INPUT_PATCH_SIZE)
val_transforms = []
val_transforms.append(
ConvertSegToOnehotTransform(range(4), 0, 'seg_onehot'))
data_gen_validation = MultiThreadedAugmenter(data_gen_validation,
Compose(val_transforms), 1, 2,
[0])
return data_gen_train, data_gen_validation
def run(config_file, fold=0):
cf = imp.load_source('cf', config_file)
print fold
dataset_root = cf.dataset_root
# this is seeded, will be identical each time
train_keys, test_keys = get_split(fold)
val_data = load_dataset(test_keys, root_dir=dataset_root)
use_patients = val_data
experiment_name = cf.EXPERIMENT_NAME
results_folder = os.path.join(cf.results_dir, "fold%d/" % fold)
mode = 'val'
BATCH_SIZE = cf.BATCH_SIZE
n_repeats = cf.val_num_repeats
x_sym = T.tensor4()
nt, net, seg_layer = cf.nt, cf.net, cf.seg_layer
output_layer = seg_layer
best_epoch = 299
results_out_folder = results_folder + "ep%03.0d_MA" % (best_epoch)
if not os.path.isdir(results_out_folder):
os.mkdir(results_out_folder)
results_out_folder += "/%s_mirror" % mode
if not os.path.isdir(results_out_folder):
os.mkdir(results_out_folder)
with open(
os.path.join(results_folder, "%s_Params.pkl" % (experiment_name)),
'r') as f:
params = cPickle.load(f)
lasagne.layers.set_all_param_values(output_layer, params)
print "compiling theano functions"
output = softmax_helper(
lasagne.layers.get_output(output_layer,
x_sym,
deterministic=not cf.val_bayesian_prediction,
batch_norm_update_averages=False,
batch_norm_use_averages=False))
pred_fn = theano.function([x_sym], output)
_ = pred_fn(np.random.random((BATCH_SIZE, 1, 384, 352)).astype(np.float32))
run_validation(
pred_fn,
results_out_folder,
use_patients,
BATCH_SIZE=BATCH_SIZE,
n_repeats=n_repeats,
save_segmentation=cf.val_save_segmentation,
plot_segmentation=cf.val_plot_segmentation,
min_size=cf.val_min_size,
do_mirroring=cf.val_do_mirroring,
input_img_must_be_divisible_by=cf.val_input_img_must_be_divisible_by,
preprocess_fn=cf.val_preprocess_fn)
def get_data(cfgs,
is_training=True,
return_infos=False,
split_name='train',
use_multitask_loss=False):
data_loader = utils.get_split(cfgs.tf_records_folder,
is_training=is_training,
task=cfgs.task,
split_name=split_name,
feature_names=cfgs.use_data,
batch_size=cfgs.batch_size,
return_infos=return_infos,
targets=cfgs.targets,
use_multitask_loss=use_multitask_loss)
return data_loader
def plot_rotnist_figures(project_dir, time_tag, model_name):
# make the save folder
save_folder = project_dir / f'figures/{model_name}'
try:
os.makedirs(save_folder)
except FileExistsError:
pass
# load previously trained model
device = torch.device('cpu')
epoch = 140
conf = OmegaConf.load(project_dir / f'runs/rotnist/{model_name}/conf.yaml')
h_sizes = OmegaConf.to_container(conf.hidden_sizes)
model = ConvNetModel(dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l,
hidden_sizes_ode_net=h_sizes, t0=-0.1, device=device)
model_weights = torch.load(project_dir / f'runs/rotnist/{model_name}/seed_0/model_ep{epoch}.pth',
map_location=device)
model.load_state_dict(model_weights)
# load RotNIST dataset, and get the test samples
dataset_mnist = RotNISTDataset(data_dir=str(project_dir / 'data'))
len_test = 10
dataset_test = dataset_mnist[len(dataset_mnist) - len_test:]
dataloader_test = DataLoader(dataset_test, batch_size=10, shuffle=False, drop_last=True)
t_all, y_all = next(iter(dataloader_test))
t_context, y_context, _, _, t_target_initial, y_target = get_split(t_all, y_all, context_range=(7, 8),
extra_target_range=(9, 10))
# Create a set of target points corresponding to entire [x_min, x_max] range
extrapolation = 5
t_min, t_max = 0., 1.5 # for the rotnist dataset
t_target = torch.linspace(t_min, t_max + extrapolation / 10, 16 + extrapolation)
t_target = t_target.view(1, -1, 1).repeat(t_context.shape[0], 1, 1)
t_target_rounded = torch.round(t_target * 10 ** 3) / (10 ** 3)
# get prediction on test samples, and plot the images for 2 examples
p_y_pred, _, _ = model(t_context, y_context, t_target)
mu = p_y_pred.loc.detach()
_, T, _ = t_target.shape
plot_rotnist_img(0, mu, T, t_target_rounded, t_target_initial, y_target, t_context, y_context, save_folder,
time_tag)
plot_rotnist_img(9, mu, T, t_target_rounded, t_target_initial, y_target, t_context, y_context, save_folder,
time_tag)
def run(config_file, fold=0):
cf = imp.load_source('cf', config_file)
print ('fold:',fold)
# this is seeded, will be identical each time
train_keys, test_keys = get_split(0)
print('test keys: {}'.format(test_keys))
experiment_name = cf.EXPERIMENT_NAME
results_folder = os.path.join(cf.results_dir, "fold%d/"%fold)
dataset_root_raw = paths.path_mms_vendorB_2d
BATCH_SIZE = cf.BATCH_SIZE
n_repeats = cf.val_num_repeats
x_sym = cf.x_sym
nt, net, seg_layer = cf.nt_bn, cf.net_bn, cf.seg_layer_bn
output_layer = seg_layer
test_out_folder = cf.test_out_folder
if not os.path.isdir(test_out_folder):
os.mkdir(test_out_folder)
test_out_folder = os.path.join(test_out_folder, "fold%d"%fold)
if not os.path.isdir(test_out_folder):
os.mkdir(test_out_folder)
with open(os.path.join("../",results_folder, "%s_Params.pkl" % (experiment_name)), 'rb') as f:
params = cPickle.load(f)
lasagne.layers.set_all_param_values(output_layer, params) # load net's params
print ("compiling theano functions")
output = softmax_helper(lasagne.layers.get_output(output_layer, x_sym, deterministic=not cf.val_bayesian_prediction,
batch_norm_update_averages=False, batch_norm_use_averages=False))
pred_fn = theano.function([x_sym], output)
_ = pred_fn(np.random.random((BATCH_SIZE, 1, 16, 16)).astype(np.float32))
# print(_.shape)
predict_test(pred_fn, test_out_folder, test_keys, dataset_root_raw, BATCH_SIZE=BATCH_SIZE,
n_repeats=n_repeats, min_size=cf.min_size,
input_img_must_be_divisible_by=cf.val_input_img_must_be_divisible_by, do_mirroring=cf.val_do_mirroring,
target_spacing=list(cf.target_spacing), preprocess_fn=preprocess)
def run(config_file, fold=0):
cf = imp.load_source('cf', config_file)
print('fold:', fold)
dataset_root = cf.dataset_root_mmsB
print('train path: {}'.format(dataset_root))
# ==================================================================================================================
BATCH_SIZE = cf.BATCH_SIZE
INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE
num_classes = cf.num_classes
EXPERIMENT_NAME = cf.EXPERIMENT_NAME
results_dir = os.path.join(cf.results_dir, "fold%d/" % fold)
if not os.path.isdir(results_dir):
os.mkdir(results_dir)
n_epochs = cf.n_epochs
lr_decay = cf.lr_decay
base_lr = cf.base_lr
n_batches_per_epoch = cf.n_batches_per_epoch # 100
n_test_batches = cf.n_test_batches # 10
n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch # 10
num_workers = cf.num_workers
workers_seeds = cf.workers_seeds
print('basiclr: {},lr-decay: {}'.format(cf.base_lr, cf.lr_decay))
# ==================================================================================================================
# this is seeded, will be identical each time
train_keys, test_keys = get_split(fold)
print('train_keys:', train_keys)
print('val_keys:', test_keys)
train_data = load_dataset(train_keys, root_dir=dataset_root)
val_data = load_dataset(test_keys, root_dir=dataset_root)
x_sym = cf.x_sym
seg_sym = cf.seg_sym
nt, net, seg_layer = cf.nt_bn, cf.net_bn, cf.seg_layer_bn
output_layer_for_loss = net
# draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png'))
data_gen_validation = BatchGenerator_2D(val_data,
BATCH_SIZE,
num_batches=None,
seed=False,
PATCH_SIZE=INPUT_PATCH_SIZE)
# No data augmentation in valuation
data_gen_validation = MultiThreadedAugmenter(
data_gen_validation,
ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"), 1, 2,
[0])
# add some weight decay
l2_loss = lasagne.regularization.regularize_network_params(
output_layer_for_loss, lasagne.regularization.l2) * cf.weight_decay
# the distinction between prediction_train and test is important only if we enable dropout
prediction_train = lasagne.layers.get_output(
output_layer_for_loss,
x_sym,
deterministic=False,
batch_norm_update_averages=False,
batch_norm_use_averages=False)
loss_vec = -weight_soft_dice(prediction_train, seg_sym)
loss = loss_vec.mean()
loss += l2_loss
acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1),
seg_sym.argmax(-1)),
dtype=theano.config.floatX)
prediction_test = lasagne.layers.get_output(
output_layer_for_loss,
x_sym,
deterministic=True,
batch_norm_update_averages=False,
batch_norm_use_averages=False)
loss_val = -soft_dice(prediction_test, seg_sym)
loss_val = loss_val.mean()
loss_val += l2_loss
acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)),
dtype=theano.config.floatX)
# learning rate has to be a shared variable because we decrease it with every epoch
params = lasagne.layers.get_all_params(output_layer_for_loss,
trainable=True)
learning_rate = theano.shared(base_lr)
updates = lasagne.updates.adam(T.grad(loss, params),
params,
learning_rate=learning_rate,
beta1=0.9,
beta2=0.999)
dc = hard_dice(prediction_test, seg_sym.argmax(1), num_classes)
train_fn = theano.function([x_sym, seg_sym], [loss, acc_train, loss_vec],
updates=updates)
val_fn = theano.function([x_sym, seg_sym], [loss_val, acc, dc])
dice_scores = None
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(100., 350.),
sigma=(14., 17.),
do_rotation=True,
a_x=(0, 2. * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.7, 1.3),
seeds=workers_seeds) # new se has no brain mask
all_training_losses = []
all_validation_losses = []
all_validation_accuracies = []
all_training_accuracies = []
all_val_dice_scores = []
epoch = 0
val_min = 0
while epoch < n_epochs:
if epoch == 100:
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(0., 250.),
sigma=(14., 17.),
do_rotation=True,
a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.75, 1.25),
seeds=workers_seeds) # new se has no brain mask
if epoch == 125:
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(0., 150.),
sigma=(14., 17.),
do_rotation=True,
a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.8, 1.2),
seeds=workers_seeds) # new se has no brain mask
epoch_start_time = time.time()
learning_rate.set_value(np.float32(base_lr * lr_decay**epoch))
print("epoch: ", epoch, " learning rate: ", learning_rate.get_value())
train_loss = 0
train_acc_tmp = 0
train_loss_tmp = 0
batch_ctr = 0
for data_dict in data_gen_train:
# first call "__iter__(self)" in class BatchGenerator_2D for iter
# And then call "__next__()" in class BatchGenerator_2D for looping
# As a result, it will generate a random batch data every time, much probably different
data = data_dict["data"].astype(np.float32)
# print(data.shape) (2,1,352,352) where batchsize = 2
seg = data_dict["seg_onehot"].astype(np.float32).transpose(
0, 2, 3, 1).reshape((-1, num_classes))
if batch_ctr != 0 and batch_ctr % int(
np.floor(
n_batches_per_epoch / n_feedbacks_per_epoch)) == 0:
print("number of batches: ", batch_ctr, "/",
n_batches_per_epoch)
print("training_loss since last update: ", \
train_loss_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch)), " train accuracy: ", \
train_acc_tmp / np.floor(n_batches_per_epoch / n_feedbacks_per_epoch))
"""
n_batches_per_epoch: How many batches in an epoch, 100 here.
n_feedbacks_per_epoch: How many feedbacks are given in an epoch, 10 here,it means in an epoch we will
calculate loss 10 times.
"""
all_training_losses.append(
train_loss_tmp / np.floor(n_batches_per_epoch /
(n_feedbacks_per_epoch))
) # for showing and saving result .png
all_training_accuracies.append(
train_acc_tmp / np.floor(n_batches_per_epoch /
(n_feedbacks_per_epoch)))
train_loss_tmp = 0
train_acc_tmp = 0
if len(all_val_dice_scores) > 0:
dice_scores = np.concatenate(all_val_dice_scores,
axis=0).reshape(
(-1, num_classes))
plotProgress(all_training_losses,
all_training_accuracies,
all_validation_losses,
all_validation_accuracies,
os.path.join(results_dir,
"%s.png" % EXPERIMENT_NAME),
n_feedbacks_per_epoch,
val_dice_scores=dice_scores,
dice_labels=["0", "1", "2", "3"])
if batch_ctr > (n_batches_per_epoch - 1):
break
loss_vec, acc, l = train_fn(data, seg) # type: Array
loss = loss_vec.mean()
train_loss += loss
train_loss_tmp += loss
train_acc_tmp += acc
batch_ctr += 1
# if batch_ctr > (n_batches_per_epoch-1):
# break
train_loss /= n_batches_per_epoch
print("training loss average on epoch: ", train_loss)
val_loss = 0
accuracies = []
valid_batch_ctr = 0
all_dice = []
for data_dict in data_gen_validation:
data = data_dict["data"].astype(
np.float32
) # print(data.shape) (2,1,352,352) where batchsize = 2
seg = data_dict["seg_onehot"].astype(np.float32).transpose(
0, 2, 3, 1).reshape(
(-1, num_classes
)) # (2,4,352,352) --> (2,353,353,4)-->(2*352*352,4)
w = np.zeros(num_classes, dtype=np.float32) # [0, 0, 0, 0]
w[np.unique(seg.argmax(-1))] = 1
loss, acc, dice = val_fn(data, seg)
dice[w == 0] = 2
# if there are some class was not be classified, abandon it when calculate mean of dice
all_dice.append(dice)
val_loss += loss
accuracies.append(acc)
valid_batch_ctr += 1
if valid_batch_ctr > (n_test_batches - 1):
break
# Making a valuation every epoch
# n_test_batches(here is 10) batches in a valuation
all_dice = np.vstack(all_dice)
dice_means = np.zeros(num_classes)
for i in range(num_classes):
dice_means[i] = all_dice[all_dice[:, i] != 2, i].mean()
val_loss /= n_test_batches
print("val loss: ", val_loss)
print("val acc: ", np.mean(accuracies), "\n")
print("val dice: ", dice_means)
print("This epoch took %f sec" % (time.time() - epoch_start_time))
all_val_dice_scores.append(dice_means)
all_validation_losses.append(val_loss)
all_validation_accuracies.append(np.mean(accuracies))
dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape(
(-1, num_classes))
plotProgress(all_training_losses,
all_training_accuracies,
all_validation_losses,
all_validation_accuracies,
os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME),
n_feedbacks_per_epoch,
val_dice_scores=dice_scores,
dice_labels=["0", "1", "2", "3"])
mul_except_background = np.array([[0], [1], [1], [1]])
mean_123 = (np.dot(dice_means, mul_except_background)) / 3
if mean_123 > val_min:
print(
'========================================================================='
)
print(
'epoch {} val123mean_min change to {:.3f} ,updating saved net params......'
.format(epoch, mean_123.item()))
print(
'========================================================================='
)
val_min = (np.dot(dice_means, mul_except_background)) / 3
with open(
os.path.join(results_dir,
"%s_Params.pkl" % (EXPERIMENT_NAME)),
'wb') as f:
cPickle.dump(
lasagne.layers.get_all_param_values(output_layer_for_loss),
f)
with open(
os.path.join(results_dir,
"%s_allLossesNAccur.pkl" % (EXPERIMENT_NAME)),
'wb') as f:
cPickle.dump([
all_training_losses, all_training_accuracies,
all_validation_losses, all_validation_accuracies,
all_val_dice_scores
], f)
epoch += 1
import pickle
import os
import re
from utils import get_longest_shot, pic_norm, get_split
if __name__ == "__main__":
splits_dir = "./data/HMDB_splits"
pics_dir = "./data/HMDB_main_frame"
train_split = get_split(splits_dir, r"1")
dev_split = get_split(splits_dir, r"2")
search_split = get_split(splits_dir, r"2")
corpus_split = get_split(splits_dir, r"[02]")
train_set = {}
train_set["xs"] = []
train_set["ys"] = []
train_set["path"] = []
for label, type, name in train_split:
base_dir = pics_dir + "/" + type + "/" + name
pics = get_longest_shot(base_dir)
for pic in pics:
train_set["path"].append(pic)
train_set["xs"].append(pic_norm(pic, (96, 72)))
train_set["ys"].append(label)
dev_set = {}
dev_set["xs"] = []
dev_set["ys"] = []
dev_set["path"] = []
for label, type, name in dev_split:
def run(config_file, fold=0):
cf = imp.load_source('cf', config_file)
print fold
dataset_root = cf.dataset_root
# ==================================================================================================================
BATCH_SIZE = cf.BATCH_SIZE
INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE
num_classes = cf.num_classes
EXPERIMENT_NAME = cf.EXPERIMENT_NAME
results_dir = os.path.join(cf.results_dir, "fold%d/" % fold)
if not os.path.isdir(results_dir):
os.mkdir(results_dir)
n_epochs = cf.n_epochs
lr_decay = cf.lr_decay
base_lr = cf.base_lr
n_batches_per_epoch = cf.n_batches_per_epoch
n_test_batches = cf.n_test_batches
n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch
num_workers = cf.num_workers
workers_seeds = cf.workers_seeds
# ==================================================================================================================
# this is seeded, will be identical each time
train_keys, test_keys = get_split(fold)
train_data = load_dataset(train_keys, root_dir=dataset_root)
val_data = load_dataset(test_keys, root_dir=dataset_root)
x_sym = cf.x_sym
seg_sym = cf.seg_sym
nt, net, seg_layer = cf.nt, cf.net, cf.seg_layer
output_layer_for_loss = net
#draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png'))
data_gen_validation = BatchGenerator_2D(val_data,
BATCH_SIZE,
num_batches=None,
seed=False,
PATCH_SIZE=INPUT_PATCH_SIZE)
data_gen_validation = MultiThreadedAugmenter(
data_gen_validation,
ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"), 1, 2,
[0])
# add some weight decay
l2_loss = lasagne.regularization.regularize_network_params(
output_layer_for_loss, lasagne.regularization.l2) * cf.weight_decay
# the distinction between prediction_train and test is important only if we enable dropout
prediction_train = lasagne.layers.get_output(
output_layer_for_loss,
x_sym,
deterministic=False,
batch_norm_update_averages=False,
batch_norm_use_averages=False)
loss_vec = -soft_dice(prediction_train, seg_sym)
loss = loss_vec.mean()
loss += l2_loss
acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1),
seg_sym.argmax(-1)),
dtype=theano.config.floatX)
prediction_test = lasagne.layers.get_output(
output_layer_for_loss,
x_sym,
deterministic=True,
batch_norm_update_averages=False,
batch_norm_use_averages=False)
loss_val = -soft_dice(prediction_test, seg_sym)
loss_val = loss_val.mean()
loss_val += l2_loss
acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)),
dtype=theano.config.floatX)
# learning rate has to be a shared variable because we decrease it with every epoch
params = lasagne.layers.get_all_params(output_layer_for_loss,
trainable=True)
learning_rate = theano.shared(base_lr)
updates = lasagne.updates.adam(T.grad(loss, params),
params,
learning_rate=learning_rate,
beta1=0.9,
beta2=0.999)
dc = hard_dice(prediction_test, seg_sym.argmax(1), num_classes)
train_fn = theano.function([x_sym, seg_sym], [loss, acc_train, loss_vec],
updates=updates)
val_fn = theano.function([x_sym, seg_sym], [loss_val, acc, dc])
dice_scores = None
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(100., 350.),
sigma=(14., 17.),
do_rotation=True,
a_x=(0, 2. * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.7, 1.3),
seeds=workers_seeds) # new se has no brain mask
all_training_losses = []
all_validation_losses = []
all_validation_accuracies = []
all_training_accuracies = []
all_val_dice_scores = []
epoch = 0
while epoch < n_epochs:
if epoch == 100:
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(0., 250.),
sigma=(14., 17.),
do_rotation=True,
a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.75, 1.25),
seeds=workers_seeds) # new se has no brain mask
if epoch == 125:
data_gen_train = create_data_gen_train(
train_data,
BATCH_SIZE,
num_classes,
num_workers=num_workers,
do_elastic_transform=True,
alpha=(0., 150.),
sigma=(14., 17.),
do_rotation=True,
a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001),
do_scale=True,
scale_range=(0.8, 1.2),
seeds=workers_seeds) # new se has no brain mask
epoch_start_time = time.time()
learning_rate.set_value(np.float32(base_lr * lr_decay**epoch))
print "epoch: ", epoch, " learning rate: ", learning_rate.get_value()
train_loss = 0
train_acc_tmp = 0
train_loss_tmp = 0
batch_ctr = 0
for data_dict in data_gen_train:
data = data_dict["data"].astype(np.float32)
seg = data_dict["seg_onehot"].astype(np.float32).transpose(
0, 2, 3, 1).reshape((-1, num_classes))
if batch_ctr != 0 and batch_ctr % int(
np.floor(
n_batches_per_epoch / n_feedbacks_per_epoch)) == 0:
print "number of batches: ", batch_ctr, "/", n_batches_per_epoch
print "training_loss since last update: ", \
train_loss_tmp/np.floor(n_batches_per_epoch/(n_feedbacks_per_epoch-1)), " train accuracy: ", \
train_acc_tmp/np.floor(n_batches_per_epoch/n_feedbacks_per_epoch)
all_training_losses.append(
train_loss_tmp / np.floor(n_batches_per_epoch /
(n_feedbacks_per_epoch - 1)))
all_training_accuracies.append(
train_acc_tmp / np.floor(n_batches_per_epoch /
(n_feedbacks_per_epoch - 1)))
train_loss_tmp = 0
train_acc_tmp = 0
if len(all_val_dice_scores) > 0:
dice_scores = np.concatenate(all_val_dice_scores,
axis=0).reshape(
(-1, num_classes))
plotProgress(all_training_losses,
all_training_accuracies,
all_validation_losses,
all_validation_accuracies,
os.path.join(results_dir,
"%s.png" % EXPERIMENT_NAME),
n_feedbacks_per_epoch,
val_dice_scores=dice_scores,
dice_labels=["brain", "1", "2", "3", "4", "5"])
loss_vec, acc, l = train_fn(data, seg)
loss = loss_vec.mean()
train_loss += loss
train_loss_tmp += loss
train_acc_tmp += acc
batch_ctr += 1
if batch_ctr > (n_batches_per_epoch - 1):
break
train_loss /= n_batches_per_epoch
print "training loss average on epoch: ", train_loss
val_loss = 0
accuracies = []
valid_batch_ctr = 0
all_dice = []
for data_dict in data_gen_validation:
data = data_dict["data"].astype(np.float32)
seg = data_dict["seg_onehot"].astype(np.float32).transpose(
0, 2, 3, 1).reshape((-1, num_classes))
w = np.zeros(num_classes, dtype=np.float32)
w[np.unique(seg.argmax(-1))] = 1
loss, acc, dice = val_fn(data, seg)
dice[w == 0] = 2
all_dice.append(dice)
val_loss += loss
accuracies.append(acc)
valid_batch_ctr += 1
if valid_batch_ctr > (n_test_batches - 1):
break
all_dice = np.vstack(all_dice)
dice_means = np.zeros(num_classes)
for i in range(num_classes):
dice_means[i] = all_dice[all_dice[:, i] != 2, i].mean()
val_loss /= n_test_batches
print "val loss: ", val_loss
print "val acc: ", np.mean(accuracies), "\n"
print "val dice: ", dice_means
print "This epoch took %f sec" % (time.time() - epoch_start_time)
all_val_dice_scores.append(dice_means)
all_validation_losses.append(val_loss)
all_validation_accuracies.append(np.mean(accuracies))
dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape(
(-1, num_classes))
plotProgress(all_training_losses,
all_training_accuracies,
all_validation_losses,
all_validation_accuracies,
os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME),
n_feedbacks_per_epoch,
val_dice_scores=dice_scores,
dice_labels=["brain", "1", "2", "3", "4", "5"])
with open(
os.path.join(results_dir, "%s_Params.pkl" % (EXPERIMENT_NAME)),
'w') as f:
cPickle.dump(
lasagne.layers.get_all_param_values(output_layer_for_loss), f)
with open(
os.path.join(results_dir,
"%s_allLossesNAccur.pkl" % (EXPERIMENT_NAME)),
'w') as f:
cPickle.dump([
all_training_losses, all_training_accuracies,
all_validation_losses, all_validation_accuracies,
all_val_dice_scores
], f)
epoch += 1
def main(dataset: str,
experiment_name: str = typer.Argument("test"),
sample: int = typer.Option(0),
epochs: int = typer.Option(5000),
max_steps_per_episode: int = typer.Option(1),
num_counterfactuals: int = typer.Option(10),
fp_length: int = typer.Option(1024),
fp_radius: int = typer.Option(2),
lr: float = typer.Option(1e-4),
polyak: float = typer.Option(0.995),
gamma: float = typer.Option(0.95),
discount: float = typer.Option(0.9),
replay_buffer_size: int = typer.Option(10000),
batch_size: int = typer.Option(1),
update_interval: int = typer.Option(1),
allow_no_modification: bool = typer.Option(False),
allow_removal: bool = typer.Option(True),
allow_node_addition: bool = typer.Option(True),
allow_edge_addition: bool = typer.Option(True),
allow_bonds_between_rings: bool = typer.Option(True),
seed: int = typer.Option(random.randint(0, 2**12))
):
general_params = {
# General-purpose params
'discount_factor': discount,
'allow_removal': allow_removal,
'allow_no_modification': allow_no_modification,
'allow_bonds_between_rings': allow_bonds_between_rings,
'allow_node_addition': allow_node_addition,
'allow_edge_addition': allow_edge_addition,
'allowed_ring_sizes': set([5, 6]),
'max_steps': max_steps_per_episode,
'fp_len': fp_length,
'fp_rad': fp_radius
}
dataset = dataset.lower()
if dataset == 'tox21':
meg = tox21
elif dataset == 'esol':
meg = esol
torch.manual_seed(seed)
base_path = f'./runs/{dataset.lower()}/{experiment_name}'
meg(general_params,
base_path,
SummaryWriter(f'{base_path}/plots'),
num_counterfactuals,
get_split(dataset.lower(), 'test', experiment_name)[sample],
model_to_explain=get_dgn(dataset.lower(), experiment_name),
experiment_name=experiment_name,
sample=sample,
epochs=epochs,
max_steps_per_episode=max_steps_per_episode,
fp_length=fp_length,
fp_radius=fp_radius,
lr=lr,
polyak=polyak,
gamma=gamma,
discount=discount,
replay_buffer_size=replay_buffer_size,
batch_size=batch_size,
update_interval=update_interval,
seed=seed)
def run():
if not os.path.exists(log_eval):
os.mkdir(log_eval)
#Just construct the graph from scratch again
with tf.Graph().as_default() as graph:
tf.logging.set_verbosity(tf.logging.INFO)
#Get the dataset first and load one batch of validation images and labels tensors. Set is_training as False so as to use the evaluation preprocessing
dataset = get_split('validation', dataset_dir)
images, raw_images, labels = load_batch(dataset,
batch_size=batch_size,
is_training=False)
#Create some information about the training steps
num_batches_per_epoch = dataset.num_samples / batch_size
num_steps_per_epoch = num_batches_per_epoch
#Now create the inference model but set is_training=False
with slim.arg_scope(inception_resnet_v2_arg_scope()):
logits, end_points = inception_resnet_v2(
images, num_classes=dataset.num_classes, is_training=False)
# #get all the variables to restore from the checkpoint file and create the saver function to restore
variables_to_restore = slim.get_variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
def restore_fn(sess):
return saver.restore(sess, checkpoint_file)
#Just define the metrics to track without the loss or whatsoever
predictions = tf.argmax(end_points['Predictions'], 1)
accuracy, accuracy_update = tf.contrib.metrics.streaming_accuracy(
predictions, labels)
metrics_op = tf.group(accuracy_update)
#Create the global step and an increment op for monitoring
global_step = get_or_create_global_step()
global_step_op = tf.assign(
global_step, global_step + 1
) #no apply_gradient method so manually increasing the global_step
#Create a evaluation step function
def eval_step(sess, metrics_op, global_step):
'''
Simply takes in a session, runs the metrics op and some logging information.
'''
start_time = time.time()
_, global_step_count, accuracy_value = sess.run(
[metrics_op, global_step_op, accuracy])
time_elapsed = time.time() - start_time
#Log some information
logging.info(
'Global Step %s: Streaming Accuracy: %.4f (%.2f sec/step)',
global_step_count, accuracy_value, time_elapsed)
return accuracy_value
#Define some scalar quantities to monitor
tf.summary.scalar('Validation_Accuracy', accuracy)
my_summary_op = tf.summary.merge_all()
#Get your supervisor
sv = tf.train.Supervisor(logdir=log_eval,
summary_op=None,
saver=None,
init_fn=restore_fn)
#Now we are ready to run in one session
with sv.managed_session() as sess:
for step in range(int(num_steps_per_epoch * num_epochs)):
sess.run(sv.global_step)
#print vital information every start of the epoch as always
if step % num_batches_per_epoch == 0:
logging.info('Epoch: %s/%s',
step / num_batches_per_epoch + 1, num_epochs)
logging.info('Current Streaming Accuracy: %.4f',
sess.run(accuracy))
#Compute summaries every 10 steps and continue evaluating
if step % 10 == 0:
eval_step(sess,
metrics_op=metrics_op,
global_step=sv.global_step)
summaries = sess.run(my_summary_op)
sv.summary_computed(sess, summaries)
#Otherwise just run as per normal
else:
eval_step(sess,
metrics_op=metrics_op,
global_step=sv.global_step)
#At the end of all the evaluation, show the final accuracy
logging.info('Final Streaming Accuracy: %.4f', sess.run(accuracy))
#Now we want to visualize the last batch's images just to see what our model has predicted
raw_images, labels, predictions = sess.run(
[raw_images, labels, predictions])
for i in range(10):
image, label, prediction = raw_images[i], labels[
i], predictions[i]
prediction_name, label_name = dataset.labels_to_name[
prediction], dataset.labels_to_name[label]
text = 'Prediction: %s \n Ground Truth: %s' % (prediction_name,
label_name)
img_plot = plt.imshow(image)
#Set up the plot and hide axes
plt.title(text)
img_plot.axes.get_yaxis().set_ticks([])
img_plot.axes.get_xaxis().set_ticks([])
plt.show()
logging.info(
'Model evaluation has completed! Visit TensorBoard for more information regarding your evaluation.'
)
def gnn_explainer(
dataset_name: str,
experiment_name: str,
epochs: int,
data_path: Path,
output_dir: Path,
node_feats: bool = typer.Option(False),
edge_size: float = typer.Option(0.005),
node_feat_size: float = typer.Option(1.0),
edge_ent: float = typer.Option(1.0),
node_feat_ent: float = typer.Option(0.1),
):
create_path(output_dir)
dataset_name = dataset_name.lower()
def loss_for_classification(p1, p2):
p1 = F.softmax(p1, dim=-1).detach().squeeze()
return p1[1 - p2]
def loss_for_regression(p1, p2):
return F.l1_loss(p1.squeeze(), torch.as_tensor([p2]).squeeze())
cfs = []
with open(data_path, 'r') as f:
cfs = json.load(f)
cfs = list(filter(lambda mol: mol['marker'] in ['og', 'cf'], cfs))
if dataset_name in ['tox21', 'cycliq', 'cycliq-multi']:
loss = loss_for_classification
transform = mol_to_tox21_pyg if dataset_name == 'tox21' else None
elif dataset_name in ['esol']:
loss = loss_for_regression
transform = mol_to_esol_pyg
GCNN = get_dgn(dataset_name, experiment_name)
explainer = GNNExplainer_(model=GCNN, prediction_loss=loss, epochs=epochs)
explainer.coeffs['node_feat_ent'] = node_feat_ent
explainer.coeffs['node_feat_size'] = node_feat_size
explainer.coeffs['edge_size'] = edge_size
explainer.coeffs['edge_ent'] = edge_ent
dataset = get_split(dataset_name, 'test', experiment_name)
for i, mol in enumerate(cfs):
data = transform(mol['id'])
node_feat_mask, edge_mask = explainer.explain_undirected_graph(
data.x,
data.edge_index,
prediction=mol['prediction']['for_explanation'],
node_feats=node_feats)
if dataset_name == 'tox21':
labels = {
i: x_map_tox21(e).name
for i, e in enumerate(
[x.tolist().index(1) for x in data.x.numpy()])
}
elif dataset_name == 'esol':
rdkit_mol = Chem.MolFromSmiles(mol['id'])
labels = {
i: s
for i, s in enumerate(
[x.GetSymbol() for x in rdkit_mol.GetAtoms()])
}
explainer.visualize_subgraph(data.edge_index,
edge_mask,
len(data.x),
threshold=0.5,
labels=labels)
plt.axis('off')
plt.savefig(f"{output_dir}/{i}", bbox_inches='tight')
plt.clf()
if node_feats:
plt.imshow(node_feat_mask.numpy(),
cmap='hot',
interpolation='nearest')
plt.colorbar()
plt.savefig(f"{output_dir}/{i}.map.png",
bbox_inches='tight',
transparent=True)
plt.close()
def run(config_file, fold=0):
cf = imp.load_source('cf', config_file)
print('fold:', fold)
dataset_root = cf.dataset_root_mmsB
print('train path: {}'.format(dataset_root))
# ==================================================================================================================
BATCH_SIZE = cf.BATCH_SIZE
INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE
num_classes = cf.num_classes
EXPERIMENT_NAME = cf.EXPERIMENT_NAME
results_dir = os.path.join(cf.results_dir, "fold%d/" % fold)
if not os.path.isdir(results_dir):
os.mkdir(results_dir)
n_epochs = cf.n_epochs
lr_decay = cf.lr_decay
base_lr = cf.base_lr
n_batches_per_epoch = cf.n_batches_per_epoch # 100
n_test_batches = cf.n_test_batches # 10
n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch # 10
num_workers = cf.num_workers
workers_seeds = cf.workers_seeds
print('basiclr: {},lr-decay: {}'.format(cf.base_lr, cf.lr_decay))
# ==================================================================================================================
# this is seeded, will be identical each time
train_keys, test_keys = get_split(fold)
print('train_keys:', train_keys)
print('val_keys:', test_keys)
train_data = load_dataset(train_keys, root_dir=dataset_root)
val_data = load_dataset(test_keys, root_dir=dataset_root)
x_sym = cf.x_sym
seg_sym = T.tensor4()
R_mask = VAE(1, x_sym, BATCH_SIZE, 'same', (None, None), 1, lasagne.nonlinearities.leaky_rectify)
output_layer_for_loss = R_mask
# draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png'))
data_gen_validation = BatchGenerator_2D(val_data, BATCH_SIZE, num_batches=None, seed=False,
PATCH_SIZE=INPUT_PATCH_SIZE)
# No data augmentation in valuation
data_gen_validation = MultiThreadedAugmenter(data_gen_validation,
ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"),
1, 2, [0])
# add some weight decay
# l2_loss = lasagne.regularization.regularize_network_params(output_layer_for_loss,
# lasagne.regularization.l2) * cf.weight_decay
# the distinction between prediction_train and test is important only if we enable dropout
prediction_train = lasagne.layers.get_output(output_layer_for_loss, x_sym, deterministic=False,
batch_norm_update_averages=False, batch_norm_use_averages=False)
loss_vec = F_loss(prediction_train, seg_sym)
loss = loss_vec.mean()
# acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX)
prediction_test = lasagne.layers.get_output(output_layer_for_loss, x_sym, deterministic=True,
batch_norm_update_averages=False, batch_norm_use_averages=False)
prediction_test = T.round(prediction_test, mode='half_to_even')
loss_val = F_loss(prediction_test, seg_sym)
loss_val = loss_val.mean()
# acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX)
# learning rate has to be a shared variable because we decrease it with every epoch
params = lasagne.layers.get_all_params(output_layer_for_loss, trainable=True)
learning_rate = theano.shared(base_lr)
updates = lasagne.updates.adam(T.grad(loss, params), params, learning_rate=learning_rate, beta1=0.9, beta2=0.999)
train_fn = theano.function([x_sym, seg_sym], [loss], updates=updates)
val_fn = theano.function([x_sym, seg_sym], [loss_val])
dice_scores = None
data_gen_train = create_data_gen_train(train_data, BATCH_SIZE,
num_classes, num_workers=num_workers,
do_elastic_transform=True, alpha=(100., 350.), sigma=(14., 17.),
do_rotation=True, a_x=(0, 2. * np.pi), a_y=(-0.000001, 0.00001),
a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.7, 1.3),
seeds=workers_seeds) # new se has no brain mask
all_training_losses = []
all_validation_losses = []
all_validation_accuracies = []
all_training_accuracies = []
all_val_dice_scores = []
epoch = 0
val_min = 0
while epoch < n_epochs:
if epoch == 100:
data_gen_train = create_data_gen_train(train_data, BATCH_SIZE,
num_classes, num_workers=num_workers,
do_elastic_transform=True, alpha=(0., 250.), sigma=(14., 17.),
do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001),
do_scale=True, scale_range=(0.75, 1.25),
seeds=workers_seeds) # new se has no brain mask
if epoch == 125:
data_gen_train = create_data_gen_train(train_data, BATCH_SIZE,
num_classes, num_workers=num_workers,
do_elastic_transform=True, alpha=(0., 150.), sigma=(14., 17.),
do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi),
a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001),
do_scale=True, scale_range=(0.8, 1.2),
seeds=workers_seeds) # new se has no brain mask
# learning_rate.set_value(np.float32(base_lr * lr_decay ** epoch))
print("epoch: ", epoch, " learning rate: ", learning_rate.get_value())
train_loss = 0
batch_ctr = 0
for data_dict in data_gen_train:
# first call "__iter__(self)" in class BatchGenerator_2D for iter
# And then call "__next__()" in class BatchGenerator_2D for looping
# As a result, it will generate a random batch data every time, much probably different
seg = data_dict["seg_onehot"].astype(np.float32)
seg = np.argmax(seg,1)
seg = seg[:,np.newaxis,...].astype(np.float32)
if batch_ctr > (n_batches_per_epoch - 1):
break
loss = train_fn(seg, seg) # type:numpy.narray
# print('batch loss:',loss[0])
train_loss += loss[0].item()
batch_ctr += 1
train_loss /= n_batches_per_epoch
print("training loss average on epoch: ", train_loss)
val_loss = 0
valid_batch_ctr = 0
for data_dict in data_gen_validation:
seg = data_dict["seg_onehot"].astype(np.float32)
seg = np.argmax(seg, 1)
seg = seg[:, np.newaxis, ...].astype(np.float32)
loss = val_fn(seg, seg)
val_loss += loss[0].item()
valid_batch_ctr += 1
if valid_batch_ctr > (n_test_batches - 1):
break
val_loss /= n_test_batches
print('val_loss:',val_loss)
with open(os.path.join(results_dir, "%s_Params.pkl" % (EXPERIMENT_NAME)), 'wb') as f:
cPickle.dump(lasagne.layers.get_all_param_values(output_layer_for_loss), f)
# Making a valuation every epoch
# n_test_batches(here is 10) batches in a valuation
epoch += 1
# force the number of filters to be square
n = int(np.ceil(np.sqrt(data.shape[0])))
padding = (((0, n**2 - data.shape[0]), (0, 1),
(0, 1)) + # add some space between filters
((0, 0), ) * (data.ndim - 3))
# don't pad the last dimension (if there is one)
# pad with ones (white)
data = np.pad(data, padding, mode='constant', constant_values=1)
# tile the filters into an image
data = data.reshape((n, n) + data.shape[1:]).transpose(
(0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))
data = data.reshape((n * data.shape[1], n * data.shape[3]) +
data.shape[4:])
plt.imshow(data)
plt.axis('off')
fn = miniplaces_net(get_split('train'), train=True).name
log_dir = None
proto_fn = fn
param_fn = os.path.join(log_dir, 'place_net_iter_50000.caffemodel')
net = caffe.Net(proto_fn, param_fn, caffe.TEST)
filters = net.params['conv1'][0].data
vis_square(filters.transpose(0, 2, 3, 1))
def train(conf, project_dir: Path, run_dir: Path) -> torch.nn.Module:
writer = SummaryWriter(str(run_dir))
save_hparams(conf, writer)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
if conf.dataset == 'sine':
# dataset of time-series
dataset_train = SineData()
dataloader_train = DataLoader(dataset_train,
batch_size=conf.batch_size,
drop_last=True)
dataset_test = SineData()
dataloader_test = DataLoader(dataset_test,
batch_size=conf.batch_size,
shuffle=False,
drop_last=True)
h_sizes = OmegaConf.to_container(
conf.hidden_sizes) # OmegaConf object to list
model = MLPModel(dim_y=1,
dim_r=conf.dim_r,
dim_z_prime=conf.dim_z_prime,
dim_l=conf.dim_l,
hidden_sizes_encoder=h_sizes,
hidden_sizes_ode_net=h_sizes,
hidden_sizes_decoder=h_sizes,
t0=dataset_train.t0,
device=device)
elif conf.dataset == 'sinefreq':
# dataset of frequency varying sinus time-series
dataset_train = FreqSineData(amplitude_range=(0.5, 1.),
shift_range=(-.5, .5),
freq_range=(1.0, 2.0),
num_samples=5000)
dataloader_train = DataLoader(dataset_train,
batch_size=conf.batch_size,
drop_last=True)
dataset_test = FreqSineData(amplitude_range=(0.5, 1.),
shift_range=(-.5, .5),
freq_range=(1.0, 2.0),
num_samples=1000)
dataloader_test = DataLoader(dataset_test,
batch_size=conf.batch_size,
shuffle=False,
drop_last=True)
h_sizes = OmegaConf.to_container(
conf.hidden_sizes) # OmegaConf object to list
model = MLPModel(dim_y=1,
dim_r=conf.dim_r,
dim_z_prime=conf.dim_z_prime,
dim_l=conf.dim_l,
hidden_sizes_encoder=h_sizes,
hidden_sizes_ode_net=h_sizes,
hidden_sizes_decoder=h_sizes,
t0=dataset_train.t0,
device=device)
elif conf.dataset == 'noisysine':
sigma = conf.sigma
# dataset of noisy sinus time-series
dataset_train = NoisySineData(sigma,
shift_range=(-0.1, .1),
freq_range=(1.9, 2.0),
num_samples=1000)
dataloader_train = DataLoader(dataset_train,
batch_size=conf.batch_size,
drop_last=True)
dataset_test = NoisySineData(sigma,
shift_range=(-0.1, .1),
freq_range=(1.9, 2.0),
num_samples=1000)
dataloader_test = DataLoader(dataset_test,
batch_size=conf.batch_size,
shuffle=False,
drop_last=True)
h_sizes = OmegaConf.to_container(
conf.hidden_sizes) # OmegaConf object to list
model = MLPModel(dim_y=1,
dim_r=conf.dim_r,
dim_z_prime=conf.dim_z_prime,
dim_l=conf.dim_l,
hidden_sizes_encoder=h_sizes,
hidden_sizes_ode_net=h_sizes,
hidden_sizes_decoder=h_sizes,
t0=dataset_train.t0,
device=device)
elif conf.dataset == 'rotnist':
# dataset of Rotating MNIST (in the literature)
dataset_mnist = RotNISTDataset(data_dir=str(project_dir / 'data'))
len_test = 10
dataset_train = dataset_mnist[:len(dataset_mnist) - len_test]
dataset_test = dataset_mnist[len(dataset_mnist) - len_test:]
dataloader_train = DataLoader(dataset_train,
batch_size=conf.batch_size,
drop_last=True)
dataloader_test = DataLoader(dataset_test,
batch_size=conf.batch_size,
shuffle=False,
drop_last=True)
h_sizes = OmegaConf.to_container(conf.hidden_sizes)
model = ConvNetModel(dim_r=conf.dim_r,
dim_z_prime=conf.dim_z_prime,
dim_l=conf.dim_l,
hidden_sizes_ode_net=h_sizes,
t0=dataset_mnist.t0,
device=device)
else:
raise ValueError(f'Dataset {conf.dataset} not recognized')
model = model.to(device)
optimizer = torch.optim.RMSprop(model.parameters(), lr=conf.lr)
context_range = OmegaConf.to_container(conf.context_range)
extra_target_range = OmegaConf.to_container(conf.extra_target_range)
global_train_step = 0
global_test_step = 0
for epoch in tqdm(range(conf.epochs)):
mse_train_list = []
mse_test_list = []
with torch.no_grad():
for step, (t, y) in enumerate(dataloader_test):
t, y = t.to(device), y.to(device)
t_context, y_context, t_extra, y_extra, _, _ = get_split(
t, y, test_context_size=conf.test_context_size)
p_y, _, _ = model(
t_context, y_context, t_extra
) # for testing, we only need predictions at t_extra
output = p_y.loc
mse_test = F.mse_loss(output, y_extra)
# log test results
writer.add_scalar('mse_test', mse_test.item(),
global_test_step)
mse_test_list.append(mse_test.item())
if step == 0 and epoch % 2 == 0:
if conf.dataset in ['sine', 'sinefreq', 'noisysine']:
log_sine_plot(writer, model, t, y, t_context,
y_context, t_extra, epoch)
elif conf.dataset == 'rotnist':
log_rotnist_plot2(writer, model, t, y, epoch, 'test')
global_test_step += 1
for (t, y) in dataloader_train:
t, y = t.to(device), y.to(device)
(t_context, y_context, t_extra, y_extra, t_target,
y_target) = get_split(t,
y,
context_range=context_range,
extra_target_range=extra_target_range)
p_y, q_z_T, q_z_C = model(t_context,
y_context,
t_target,
y_target=y_target)
log_p = p_y.log_prob(y_target).sum(dim=(1, 2)).mean(
dim=0) # mean on batch dim, sum on time dim/y dim
output = p_y.loc
mse_train = F.mse_loss(output, y_target)
# mean on batch dim, sum on z dim (equivalent to kl_div of the multivariate normal)
kl_div = kl_divergence(q_z_C, q_z_T).sum(dim=1).mean(dim=0)
loss = -log_p + kl_div
optimizer.zero_grad()
loss.backward()
optimizer.step()
# log training metrics
writer.add_scalar('kl_div', kl_div.item(), global_train_step)
writer.add_scalar('log_p', log_p.item(), global_train_step)
writer.add_scalar('train_loss', loss.item(), global_train_step)
writer.add_scalar('mse_train', mse_train.item(), global_train_step)
mse_train_list.append(mse_train.item())
global_train_step += 1
# log test/train mse epoch-wise to match the paper's figures
writer.add_scalar('mse_train_epoch', np.mean(mse_train_list), epoch)
writer.add_scalar('mse_test_epoch', np.mean(mse_test_list), epoch)
if epoch % conf.checkpoint_freq == 0 and epoch > 0:
torch.save(model.state_dict(), run_dir / f'model_ep{epoch}.pth')
torch.save(model.state_dict(), run_dir / f'model.pth')
return model
this operation aims to recover the res_2d[tpe] to original shape(raw.shape)
"""
# all_softmax += [softmax_3d[None], softmax_2d[None]]
# predicted_seg = postprocess_prediction(np.vstack(all_softmax).mean(0).argmax(0))
predicted_seg = postprocess_prediction(softmax_2d.argmax(0))
itk_seg = sitk.GetImageFromArray(predicted_seg.astype(np.uint8))
# itk_seg.CopyInformation(raw_itk)
sitk.WriteImage(
itk_seg,
os.path.join(
output_folder,
"patient%03.0d_%s.nii.gz" % (patient, tpe.upper())))
if __name__ == "__main__":
# import argparse
# parser = argparse.ArgumentParser()
# parser.add_argument("-c2d", help="config file for 2d network", type=str, default=CONFIG_FILE_2D)
# # parser.add_argument("-c3d", help="config file for 3d network", type=str)
# parser.add_argument("-o", help="output folder", type=str, default='./submit_MMS_file')
# args = parser.parse_args()
# run(args.c2d, args.o)
pred_path = '/home/laisong/github/submit_MMS_file'
label_path = '/home/laisong/MMs2020/MMS_ED_ES/label'
train_keys, test_keys = get_split(0)
vendor_path = paths.path_mms_vendorAandB_2d
dice = test_dice(pred_path, label_path, test_keys, vendor_path)
print(dice)
def run(config_file_2d, output_folder):
cf_2d = imp.load_source("cf_2d", config_file_2d)
# cf_3d = imp.load_source("cf_3d", config_file_3d)
dataset_base_dir = cf_2d.dataset_root_test
# results_folder_3D = os.path.join(cf_3d.results_dir, "test_predictions/")
results_folder_2D = cf_2d.test_out_folder
f = open('/home/laisong/ACDC2017/mms_vendorB_2d_train/patient_info.pkl',
'rb')
patient_info = cPickle.load(f) # 读出文件的数据个数
if not os.path.isdir(output_folder): # if folder not exist, create it
os.mkdir(output_folder)
def resize_softmax_pred(softmax_output, new_shape, order=3):
reshaped = np.zeros([len(softmax_output)] + list(new_shape),
dtype=float)
for i in range(len(softmax_output)):
reshaped[i] = resize(softmax_output[i].astype(float),
new_shape,
order,
mode="constant",
cval=0,
clip=True)
return reshaped
train_keys, test_keys = get_split(0)
print(test_keys)
for patient in test_keys:
ed = 0
es = 2
for tpe in ['ed', 'es']:
raw_itk = sitk.ReadImage(
os.path.join(MMSCONFIG.MMs_TOTAL_DATA, 'Img',
patient_info[patient]['code'] + '_sa.nii.gz'))
raw = sitk.GetArrayFromImage(raw_itk)
print('raw.shape:', raw.shape[1:])
for f in range(1): # should be 5 folder totally
# res_3d = np.load(os.path.join(results_folder_3D, "fold%d" % f, "patient%03.0d_3D_net.npz" % patient))
res_2d = np.load(
os.path.join(results_folder_2D, 'fold0',
'patient%03d_2D_net.npz' % patient))
print(res_2d[tpe].shape)
# resize softmax to original image size
# softmax_3d = resize_softmax_pred(res_3d[tpe], raw.shape, 3)
softmax_2d = resize_softmax_pred(
res_2d[tpe], raw.shape[1:],
3) # softmax_2d shape(4,10,256,232)
print(softmax_2d.shape)
"""
res_2d[tpe].shape may be changed because of the transfering of spacing,
this operation aims to recover the res_2d[tpe] to original shape(raw.shape)
"""
# all_softmax += [softmax_3d[None], softmax_2d[None]]
# predicted_seg = postprocess_prediction(np.vstack(all_softmax).mean(0).argmax(0))
predicted_seg = postprocess_prediction(softmax_2d.argmax(0))
itk_seg = sitk.GetImageFromArray(predicted_seg.astype(np.uint8))
# itk_seg.CopyInformation(raw_itk)
sitk.WriteImage(
itk_seg,
os.path.join(
output_folder,
"patient%03.0d_%s.nii.gz" % (patient, tpe.upper())))
print("======= Generating Data Tuples =======")
def chunks(iterable, size):
it = iter(iterable)
chunk = list(itertools.islice(it, size))
while chunk:
yield chunk
chunk = list(itertools.islice(it, size))
data_tuples = []
for i, c in enumerate(CANDIDATES):
seqs = tokenizer.texts_to_sequences(t
for t, p in texts_by_candidate[c])
for j, seq in enumerate(seqs):
split = get_split(texts_by_candidate[c][j][1])
for chunk in chunks(seq, MAX_SEQUENCE_LEN):
if len(chunk) >= MIN_SEQUENCE_LEN:
data_tuples.append((chunk, i, split))
print(len(data_tuples), 'data tuples.')
counts = [0] * len(CANDIDATES)
for _, label, _ in data_tuples:
counts[label] += 1
for candidate, count in zip(CANDIDATES, counts):
print(candidate, "has", count, "labelled examples.")
random.shuffle(data_tuples)
