def run(self):
###### Create the datasets
data_path = "./datasets/report_ultimate_random/"
training_data_path = data_path + "train_2.h5"
testing_data_path = data_path + "test_2.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:100],
# img_shape=(29, 29), tile_shape=(10, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
prop_validation = 0.5 # Percentage of the testing dataset that is used for validation (early stopping)
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
ds_validation, ds_testing = ds_testing.split_datapoints_proportion(prop_validation)
# Few stats about the targets
analyse_classes(np.argmax(ds_training.outputs, axis=1))
# Scale some part of the data
s = pickle.load(open(self.path + "s.scaler", "rb"))
s.scale(ds_testing.inputs)
###### Create the network
# Load the networks
net1 = NetworkUltimateMLPWithoutCentroids()
net1.init(29, 13, 135)
net1.load_parameters(open_h5file(self.path + "net_no_centroids.net"))
net2 = NetworkUltimateMLP()
net2.init(29, 13, 134, 135)
net2.load_parameters(open_h5file(self.path + "net.net"))
###### Evaluate on testing
compute_centroids_estimate(ds_testing, net1, net2, s)
def run(self):
###### Create the datasets
data_path = "./datasets/report_ultimate_random/"
training_data_path = data_path + "train_2.h5"
testing_data_path = data_path + "test_2.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:100],
# img_shape=(29, 29), tile_shape=(10, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
prop_validation = 0.5 # Percentage of the testing dataset that is used for validation (early stopping)
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
ds_validation, ds_testing = ds_testing.split_datapoints_proportion(prop_validation)
# Few stats about the targets
analyse_classes(np.argmax(ds_training.outputs, axis=1))
# Scale some part of the data
s = pickle.load(open(self.path + "s.scaler", "rb"))
s.scale(ds_testing.inputs)
###### Create the network
# Load the networks
net1 = NetworkUltimateMLPWithoutCentroids()
net1.init(29, 13, 135)
net1.load_parameters(open_h5file(self.path + "net_no_centroids.net"))
net2 = NetworkUltimateMLP()
net2.init(29, 13, 134, 135)
net2.load_parameters(open_h5file(self.path + "net.net"))
###### Evaluate on testing
compute_centroids_estimate(ds_testing, net1, net2, s)
def run(self):
###### Create the datasets
# Testing
data_cf_test = load_config("cfg_testing_data_creation.py")
data_cf_test.general[
"file_path"] = data_cf_test.data_path + "test_temp.h5"
data_generator_test = DataGeneratorBrain()
data_generator_test.init_from_config(data_cf_test)
ds_test_temp = DatasetBrainParcellation()
vx, inputs, outputs, file_ids = data_generator_test.generate_parallel(
data_cf_test.general["n_data"])
ds_test_temp.populate(inputs, outputs, vx, file_ids)
ds_test_temp.shuffle_data()
# Training
prop_validation = 0.1
data_cf_train = load_config("cfg_training_data_creation.py")
data_cf_train.general[
"file_path"] = data_cf_train.data_path + "train_temp.h5"
data_generator_train = DataGeneratorBrain()
data_generator_train.init_from_config(data_cf_train)
ds_train_temp = DatasetBrainParcellation()
vx, inputs, outputs, file_ids = data_generator_train.generate_parallel(
data_cf_train.general["n_data"])
ds_train_temp.populate(inputs, outputs, vx, file_ids)
ds_train_temp.shuffle_data()
[ds_train_temp,
ds_validation_temp] = ds_train_temp.split_dataset_proportions(
[1 - prop_validation, prop_validation])
## Scale some part of the data
print "Scaling"
s = Scaler([slice(-134, None, None)])
s.compute_parameters(ds_train_temp.inputs)
s.scale(ds_train_temp.inputs)
s.scale(ds_validation_temp.inputs)
s.scale(ds_test_temp.inputs)
pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
net = NetworkUltimateConv()
net.init(29, 29, 13, 134, 135)
print net
###### Configure the trainer
# Cost function
cost_function = CostNegLL()
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
freq = 1
freq2 = 0.00001
err_training = MonitorErrorRate(freq, "Train", ds_train_temp)
err_testing = MonitorErrorRate(freq, "Test", ds_test_temp)
err_validation = MonitorErrorRate(freq, "Val", ds_validation_temp)
# dice_training = MonitorDiceCoefficient(freq, "Train", ds_train_temp, 135)
dice_testing = MonitorDiceCoefficient(freq, "Test", ds_test_temp, 135)
# dice_validation = MonitorDiceCoefficient(freq, "Val", ds_validation_temp, 135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(100)
#early_stopping = EarlyStopping(err_validation, 10, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
batch_size = 200
t = Trainer(net, cost_function, params_selector, [max_epoch],
lr_update, ds_train_temp, batch_size,
[err_training, err_validation, err_testing, dice_testing])
###### Train the network
n_iter = 1
evolution = np.zeros((2, n_iter))
n_validation_data = ds_validation_temp.n_data
for i in xrange(n_iter):
# Train
t.train()
net.save_parameters(self.path + "net.net")
# Test
print "ERRORS::::"
out_pred = net.predict(ds_test_temp.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(
ds_test_temp.outputs, axis=1)
print np.mean(errors)
evolution[0, i] = np.mean(errors)
out_pred = net.predict(ds_validation_temp.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(
ds_validation_temp.outputs, axis=1)
print np.mean(errors)
evolution[1, i] = np.mean(errors)
vx_errors = ds_train_temp.vx[errors]
file_ids_errors = ds_validation_temp.file_ids[errors]
inputs_errors = ds_validation_temp.inputs[errors]
outputs_errors = ds_validation_temp.outputs[errors]
# Update datasets, trainer, monitors
n_data = int(round(0.9 * data_cf_train.general["n_data"]))
prop_validation = 0.1
vx, inputs, outputs, file_ids = data_generator_train.generate_parallel(
n_data)
s.scale(inputs)
split = int(round(n_data * (1 - prop_validation)))
ds_train_temp.populate(
np.concatenate([inputs[0:split], inputs_errors], axis=0),
np.concatenate([outputs[0:split], outputs_errors], axis=0),
np.concatenate([vx[0:split], vx_errors], axis=0),
np.concatenate([file_ids[0:split], file_ids_errors], axis=0))
ds_train_temp.shuffle_data()
ds_validation_temp.populate(inputs[split:n_data],
outputs[split:n_data],
vx[split:n_data],
file_ids[split:n_data])
ds_validation_temp.shuffle_data()
print ds_train_temp.n_data
t.init()
print evolution
###### Plot the records
# save_records_plot(self.path, [err_training, err_validation, err_testing], "err", t.n_train_batches, "upper right")
# save_records_plot(self.path, [dice_testing], "dice", t.n_train_batches, "lower right")
###### Save the network
net.save_parameters(self.path + "net.net")
extract_vx = ExtractVoxelAll(1)
pick_vx = PickVoxel(select_region, extract_vx)
pick_patch = create_pick_features(cf_data)
pick_tg = create_pick_target(cf_data)
# Create the data generator
data_gen = DataGeneratorBrain()
data_gen.init_from(file_list, pick_vx, pick_patch, pick_tg)
# Evaluate the centroids
net_wo_centroids_path = "./experiments/report_3_patches_balanced_conv/"
net_wo_centroids = NetworkThreePatchesConv()
net_wo_centroids.init(29, 135)
net_wo_centroids.load_parameters(
open_h5file(net_wo_centroids_path + "net.net"))
ds_testing = DatasetBrainParcellation()
ds_testing.read(data_path + "train.h5")
pred_wo_centroids = np.argmax(net_wo_centroids.predict(
ds_testing.inputs, 1000),
axis=1)
region_centroids = RegionCentroids(134)
region_centroids.update_barycentres(ds_testing.vx, pred_wo_centroids)
# Generate and evaluate the dataset
start_time = time.clock()
dices = np.zeros((n_files, 134))
errors = np.zeros((n_files, ))
pred_functions = {}
for atlas_id in xrange(n_files):
def run(self):
data_path = "./datasets/final_exp_n_layers_2000/"
range_n_layers = np.arange(0, 6, 1)
error_rates = np.zeros(range_n_layers.shape)
dice_coeffs = np.zeros(range_n_layers.shape)
for idx, n_layers in enumerate(range_n_layers):
print "patch width {}".format(n_layers)
### Load the config file
data_cf_train = load_config("cfg_training_data_creation.py")
data_cf_test = load_config("cfg_testing_data_creation.py")
# Create the folder if it does not exist
if not os.path.exists(data_path):
os.makedirs(data_path)
data_cf_train.data_path = data_path
data_cf_test.data_path = data_path
data_cf_train.general["file_path"] = data_path + "train.h5"
data_cf_test.general["file_path"] = data_path + "test.h5"
### Generate and write on file the dataset
generate_and_save(data_cf_train)
generate_and_save(data_cf_test)
###### Create the datasets
training_data_path = data_path + "train.h5"
testing_data_path = data_path + "test.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:100],
# img_shape=(29, 29), tile_shape=(10, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
ds_validation = DatasetBrainParcellation()
ds_validation.read(testing_data_path)
# Few stats about the targets
analyse_classes(np.argmax(ds_training.outputs, axis=1))
# Scale some part of the data
# s = Scaler([slice(-134, None, None)])
# s.compute_parameters(ds_training.inputs)
# s.scale(ds_training.inputs)
# s.scale(ds_validation.inputs)
# s.scale(ds_testing.inputs)
# pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
net = MLP()
net.init([29**2] + [2000]*n_layers +[135])
print net
# image = PIL.Image.fromarray(tile_raster_images(X=net.get_layer(0).get_layer_block(0).w.get_value().reshape((10,-1)),
# img_shape=(5, 5), tile_shape=(3, 3),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
###### Configure the trainer
# Cost function
cost_function = CostNegLL()
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
err_validation = MonitorErrorRate(1, "Validation", ds_validation)
dice_validation = MonitorDiceCoefficient(1, "Validation", ds_validation, 135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(300)
early_stopping = EarlyStopping(err_validation, 5, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
batch_size = 200
t = Trainer(net, cost_function, params_selector, [max_epoch, early_stopping],
lr_update, ds_training, batch_size,
[err_validation, dice_validation])
###### Train the network
t.train()
###### Plot the records
error_rates[idx] = err_validation.get_minimum()
dice_coeffs[idx] = dice_validation.get_maximum()
print error_rates
print dice_coeffs
plt.figure()
plt.plot(range_n_layers, error_rates, label="Validation error rates")
plt.plot(range_n_layers, dice_coeffs, label="Validation dice coefficient")
plt.xlabel('Number of layers')
plt.savefig(self.path + "res.png")
tikz_save(self.path + "res.tikz", figureheight = '\\figureheighttik', figurewidth = '\\figurewidthtik')
def run(self):
###### Create the datasets
# aa = CostNegLLWeighted(np.array([0.9, 0.1]))
# e = theano.function(inputs=[], outputs=aa.test())
# print e()
## Load the data
training_data_path = self.data_path + "train.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
[ds_training, ds_validation] = ds_training.split_dataset_proportions([0.95, 0.05])
testing_data_path = self.data_path + "test.h5"
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
## Display data sample
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:50],
# img_shape=(29, 29), tile_shape=(5, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
## Few stats about the targets
classes, proportion_class = analyse_classes(np.argmax(ds_training.outputs, axis=1), "Training data:")
print classes
## Scale some part of the data
print "Scaling"
s = Scaler([slice(-134, None, None)])
s.compute_parameters(ds_training.inputs)
s.scale(ds_training.inputs)
s.scale(ds_validation.inputs)
s.scale(ds_testing.inputs)
pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
net = NetworkUltimateConv()
net.init(33, 29, 5, 134, 135)
print net
###### Configure the trainer
# Cost function
cost_function = CostNegLL(net.ls_params)
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
freq = 1
freq2 = 0.00001
# err_training = MonitorErrorRate(freq, "Train", ds_training)
# err_testing = MonitorErrorRate(freq, "Test", ds_testing)
err_validation = MonitorErrorRate(freq, "Val", ds_validation)
# dice_training = MonitorDiceCoefficient(freq, "Train", ds_training, 135)
dice_testing = MonitorDiceCoefficient(freq, "Test", ds_testing, 135)
# dice_validation = MonitorDiceCoefficient(freq, "Val", ds_validation, 135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(300)
early_stopping = EarlyStopping(err_validation, 10, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
batch_size = 200
t = Trainer(net, cost_function, params_selector, [max_epoch, early_stopping],
lr_update, ds_training, batch_size,
[err_validation, dice_testing])
###### Train the network
t.train()
###### Plot the records
# pred = np.argmax(t.net.predict(ds_testing.inputs, 10000), axis=1)
# d = compute_dice(pred, np.argmax(ds_testing.outputs, axis=1), 134)
# print "Dice test: {}".format(np.mean(d))
# print "Error rate test: {}".format(error_rate(np.argmax(ds_testing.outputs, axis=1), pred))
save_records_plot(self.path, [err_validation], "err", t.n_train_batches, "upper right")
# save_records_plot(self.path, [dice_testing], "dice", t.n_train_batches, "lower right")
###### Save the network
net.save_parameters(self.path + "net.net")
from spynet.utils.utilities import open_h5file
if __name__ == '__main__':
"""
Evaluate a trained network (without approximating the centroids)
"""
experiment_path = "./experiments/paper_ultimate_conv/"
data_path = "./datasets/paper_ultimate_conv/"
# Load the network
net = NetworkUltimateConv()
net.init(33, 29, 5, 134, 135)
net.load_parameters(open_h5file(experiment_path + "net.net"))
n_out = net.n_out
# Load the scaler
scaler = pickle.load(open(experiment_path + "s.scaler", "rb"))
testing_data_path = data_path + "test.h5"
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
scaler.scale(ds_testing.inputs)
out_pred = net.predict(ds_testing.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(ds_testing.outputs,
axis=1)
dice = compute_dice(np.argmax(out_pred, axis=1),
np.argmax(ds_testing.outputs, axis=1), 134)
print np.mean(dice)
print np.mean(errors)
def run(self):
###### Create the datasets
# Testing
data_cf_test = load_config("cfg_testing_data_creation.py")
data_cf_test.general["file_path"] = data_cf_test.data_path + "test_temp.h5"
data_generator_test = DataGeneratorBrain()
data_generator_test.init_from_config(data_cf_test)
ds_test_temp = DatasetBrainParcellation()
vx, inputs, outputs, file_ids = data_generator_test.generate_parallel(data_cf_test.general["n_data"])
ds_test_temp.populate(inputs, outputs, vx, file_ids)
ds_test_temp.shuffle_data()
# Training
prop_validation = 0.1
data_cf_train = load_config("cfg_training_data_creation.py")
data_cf_train.general["file_path"] = data_cf_train.data_path + "train_temp.h5"
data_generator_train = DataGeneratorBrain()
data_generator_train.init_from_config(data_cf_train)
ds_train_temp = DatasetBrainParcellation()
vx, inputs, outputs, file_ids = data_generator_train.generate_parallel(data_cf_train.general["n_data"])
ds_train_temp.populate(inputs, outputs, vx, file_ids)
ds_train_temp.shuffle_data()
[ds_train_temp, ds_validation_temp] = ds_train_temp.split_dataset_proportions(
[1 - prop_validation, prop_validation]
)
## Scale some part of the data
print "Scaling"
s = Scaler([slice(-134, None, None)])
s.compute_parameters(ds_train_temp.inputs)
s.scale(ds_train_temp.inputs)
s.scale(ds_validation_temp.inputs)
s.scale(ds_test_temp.inputs)
pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
net = NetworkUltimateConv()
net.init(29, 29, 13, 134, 135)
print net
###### Configure the trainer
# Cost function
cost_function = CostNegLL()
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
freq = 1
freq2 = 0.00001
err_training = MonitorErrorRate(freq, "Train", ds_train_temp)
err_testing = MonitorErrorRate(freq, "Test", ds_test_temp)
err_validation = MonitorErrorRate(freq, "Val", ds_validation_temp)
# dice_training = MonitorDiceCoefficient(freq, "Train", ds_train_temp, 135)
dice_testing = MonitorDiceCoefficient(freq, "Test", ds_test_temp, 135)
# dice_validation = MonitorDiceCoefficient(freq, "Val", ds_validation_temp, 135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(100)
# early_stopping = EarlyStopping(err_validation, 10, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
batch_size = 200
t = Trainer(
net,
cost_function,
params_selector,
[max_epoch],
lr_update,
ds_train_temp,
batch_size,
[err_training, err_validation, err_testing, dice_testing],
)
###### Train the network
n_iter = 1
evolution = np.zeros((2, n_iter))
n_validation_data = ds_validation_temp.n_data
for i in xrange(n_iter):
# Train
t.train()
net.save_parameters(self.path + "net.net")
# Test
print "ERRORS::::"
out_pred = net.predict(ds_test_temp.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(ds_test_temp.outputs, axis=1)
print np.mean(errors)
evolution[0, i] = np.mean(errors)
out_pred = net.predict(ds_validation_temp.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(ds_validation_temp.outputs, axis=1)
print np.mean(errors)
evolution[1, i] = np.mean(errors)
vx_errors = ds_train_temp.vx[errors]
file_ids_errors = ds_validation_temp.file_ids[errors]
inputs_errors = ds_validation_temp.inputs[errors]
outputs_errors = ds_validation_temp.outputs[errors]
# Update datasets, trainer, monitors
n_data = int(round(0.9 * data_cf_train.general["n_data"]))
prop_validation = 0.1
vx, inputs, outputs, file_ids = data_generator_train.generate_parallel(n_data)
s.scale(inputs)
split = int(round(n_data * (1 - prop_validation)))
ds_train_temp.populate(
np.concatenate([inputs[0:split], inputs_errors], axis=0),
np.concatenate([outputs[0:split], outputs_errors], axis=0),
np.concatenate([vx[0:split], vx_errors], axis=0),
np.concatenate([file_ids[0:split], file_ids_errors], axis=0),
)
ds_train_temp.shuffle_data()
ds_validation_temp.populate(
inputs[split:n_data], outputs[split:n_data], vx[split:n_data], file_ids[split:n_data]
)
ds_validation_temp.shuffle_data()
print ds_train_temp.n_data
t.init()
print evolution
###### Plot the records
# save_records_plot(self.path, [err_training, err_validation, err_testing], "err", t.n_train_batches, "upper right")
# save_records_plot(self.path, [dice_testing], "dice", t.n_train_batches, "lower right")
###### Save the network
net.save_parameters(self.path + "net.net")
select_region = SelectWholeBrain()
extract_vx = ExtractVoxelAll(1)
pick_vx = PickVoxel(select_region, extract_vx)
pick_patch = create_pick_features(cf_data)
pick_tg = create_pick_target(cf_data)
# Create the data generator
data_gen = DataGeneratorBrain()
data_gen.init_from(file_list, pick_vx, pick_patch, pick_tg)
# Evaluate the centroids
net_wo_centroids_path = "./experiments/report_3_patches_balanced_conv/"
net_wo_centroids = NetworkThreePatchesConv()
net_wo_centroids.init(29, 135)
net_wo_centroids.load_parameters(open_h5file(net_wo_centroids_path + "net.net"))
ds_testing = DatasetBrainParcellation()
ds_testing.read(data_path + "train.h5")
pred_wo_centroids = np.argmax(net_wo_centroids.predict(ds_testing.inputs, 1000), axis=1)
region_centroids = RegionCentroids(134)
region_centroids.update_barycentres(ds_testing.vx, pred_wo_centroids)
# Generate and evaluate the dataset
start_time = time.clock()
dices = np.zeros((n_files, 134))
errors = np.zeros((n_files,))
pred_functions = {}
for atlas_id in xrange(n_files):
print "Atlas: {}".format(atlas_id)
def run(self):
data_path = "./datasets/final_exp_size_patch/"
range_patch_size = np.arange(3, 37, 2)
error_rates = np.zeros(range_patch_size.shape)
dice_coeffs = np.zeros(range_patch_size.shape)
for idx, patch_size in enumerate(range_patch_size):
print "patch width {}".format(patch_size)
### Load the config file
data_cf_train = load_config("cfg_training_data_creation.py")
data_cf_test = load_config("cfg_testing_data_creation.py")
data_cf_train.data_path = data_path
data_cf_test.data_path = data_path
data_cf_train.pick_features[0]["patch_width"] = patch_size
data_cf_test.pick_features[0]["patch_width"] = patch_size
### Generate and write on file the dataset
generate_and_save(data_cf_train)
generate_and_save(data_cf_test)
###### Create the datasets
training_data_path = data_path + "train.h5"
testing_data_path = data_path + "test.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:100],
# img_shape=(29, 29), tile_shape=(10, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
ds_validation = DatasetBrainParcellation()
ds_validation.read(testing_data_path)
# Few stats about the targets
analyse_classes(np.argmax(ds_training.outputs, axis=1))
# Scale some part of the data
# s = Scaler([slice(-134, None, None)])
# s.compute_parameters(ds_training.inputs)
# s.scale(ds_training.inputs)
# s.scale(ds_validation.inputs)
# s.scale(ds_testing.inputs)
# pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
net = MLP()
net.init([
patch_size**2, patch_size**2, patch_size**2, patch_size**2, 135
])
print net
# image = PIL.Image.fromarray(tile_raster_images(X=net.get_layer(0).get_layer_block(0).w.get_value().reshape((10,-1)),
# img_shape=(5, 5), tile_shape=(3, 3),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
###### Configure the trainer
# Cost function
cost_function = CostNegLL()
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
err_validation = MonitorErrorRate(1, "Validation", ds_validation)
dice_validation = MonitorDiceCoefficient(1, "Validation",
ds_validation, 135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(300)
early_stopping = EarlyStopping(err_validation, 5, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
batch_size = 200
t = Trainer(net, cost_function, params_selector,
[max_epoch, early_stopping], lr_update, ds_training,
batch_size, [err_validation, dice_validation])
###### Train the network
t.train()
###### Plot the records
error_rates[idx] = err_validation.get_minimum()
dice_coeffs[idx] = dice_validation.get_maximum()
print error_rates
print dice_coeffs
plt.figure()
plt.plot(range_patch_size, error_rates, label="Validation error rates")
plt.plot(range_patch_size,
dice_coeffs,
label="Validation dice coefficient")
plt.xlabel('Patch size')
plt.savefig(self.path + "res.png")
tikz_save(self.path + "res.tikz",
figureheight='\\figureheighttik',
figurewidth='\\figurewidthtik')
from data_brain_parcellation import DatasetBrainParcellation, DataGeneratorBrain, list_miccai_files, RegionCentroids
from spynet.utils.utilities import open_h5file
if __name__ == '__main__':
"""
Evaluate a trained network (without approximating the centroids)
"""
experiment_path = "./experiments/paper_ultimate_conv/"
data_path = "./datasets/paper_ultimate_conv/"
# Load the network
net = NetworkUltimateConv()
net.init(33, 29, 5, 134, 135)
net.load_parameters(open_h5file(experiment_path + "net.net"))
n_out = net.n_out
# Load the scaler
scaler = pickle.load(open(experiment_path + "s.scaler", "rb"))
testing_data_path = data_path + "test.h5"
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
scaler.scale(ds_testing.inputs)
out_pred = net.predict(ds_testing.inputs, 1000)
errors = np.argmax(out_pred, axis=1) != np.argmax(ds_testing.outputs, axis=1)
dice = compute_dice(np.argmax(out_pred, axis=1), np.argmax(ds_testing.outputs, axis=1), 134)
print np.mean(dice)
print np.mean(errors)
# Options for the generation of the dataset
# The generation/evaluation of the dataset has to be split into batches as a whole brain does not fit into memory
batch_size = 50000
select_region = SelectWholeBrain()
extract_vx = ExtractVoxelAll(1)
pick_vx = PickVoxel(select_region, extract_vx)
pick_patch = create_pick_features(cf_data)
pick_tg = create_pick_target(cf_data)
# Create the data generator
data_gen = DataGeneratorBrain()
data_gen.init_from(file_list, pick_vx, pick_patch, pick_tg)
# Evaluate the centroids
data_cf_train = imp.load_source("cf_data", data_path + "cfg_training_data_creation.py")
ds_train_temp = DatasetBrainParcellation()
ds_train_temp.populate_from_config(data_cf_train)
region_centroids = RegionCentroids(134)
region_centroids.update_barycentres(ds_train_temp.vx, np.argmax(ds_train_temp.outputs, axis=1))
# Generate and evaluate the dataset
start_time = time.clock()
dices = np.zeros((n_files, 134))
errors = np.zeros((n_files,))
pred_functions = {}
for atlas_id in xrange(n_files):
print "Atlas: {}".format(atlas_id)
ls_vx = []
def run(self):
###### Create the datasets
# aa = CostNegLLWeighted(np.array([0.9, 0.1]))
# e = theano.function(inputs=[], outputs=aa.test())
# print e()
## Load the data
training_data_path = self.data_path + "train.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
[ds_training,
ds_validation] = ds_training.split_dataset_proportions([0.95, 0.05])
testing_data_path = self.data_path + "test.h5"
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
## Display data sample
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:50],
# img_shape=(29, 29), tile_shape=(5, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
## Few stats about the targets
classes, proportion_class = analyse_classes(
np.argmax(ds_training.outputs, axis=1), "Training data:")
print(classes)
## Scale some part of the data
print("Scaling")
s = Scaler([slice(-134, None, None)])
s.compute_parameters(ds_training.inputs)
s.scale(ds_training.inputs)
s.scale(ds_validation.inputs)
s.scale(ds_testing.inputs)
pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
# net = NetworkUltimateConv()
# net = NetworkWithoutCentroidConv()
# net.init(29,13,135)
net = NetworkConvDropout()
# net = NetworkConvVGGDropout()
# net = ResNet()
net.init(29, 29, 13, 134, 135)
# net = NetworkDeeperConv()
# net.init(29, 29, 13, 134, 135,3)
print(net)
###### Configure the trainer
# Cost function
# cost_function = CostNegLL(net.ls_params)
cost_function = CostNegLL()
# Learning update
learning_rate = 0.05
momentum = 0.5
lr_update = LearningUpdateGDMomentum(learning_rate, momentum)
# Create monitors and add them to the trainer
freq = 1
freq2 = 0.00001
# err_training = MonitorErrorRate(freq, "Train", ds_training)
err_testing = MonitorErrorRate(freq, "Test", ds_testing)
err_validation = MonitorErrorRate(freq, "Val", ds_validation)
# dice_training = MonitorDiceCoefficient(freq, "Train", ds_training, 135)
dice_testing = MonitorDiceCoefficient(freq, "Test", ds_testing, 135)
dice_validation = MonitorDiceCoefficient(freq, "Val", ds_validation,
135)
# Create stopping criteria and add them to the trainer
max_epoch = MaxEpoch(300)
early_stopping = EarlyStopping(err_validation, 10, 0.99, 5)
# Create the network selector
params_selector = ParamSelectorBestMonitoredValue(err_validation)
# Create the trainer object
# batch_size = 200
batch_size = 10
t = Trainer(
net, cost_function, params_selector, [max_epoch, early_stopping],
lr_update, ds_training, batch_size,
[err_testing, err_validation, dice_testing, dice_validation])
###### Train the network
t.train()
###### Plot the records
# pred = np.argmax(t.net.predict(ds_testing.inputs, 10000), axis=1)
# d = compute_dice(pred, np.argmax(ds_testing.outputs, axis=1), 134)
# print "Dice test: {}".format(np.mean(d))
# print "Error rate test: {}".format(error_rate(np.argmax(ds_testing.outputs, axis=1), pred))
save_records_plot(self.path, [err_validation, err_testing], "err",
t.n_train_batches, "upper right")
save_records_plot(self.path, [dice_validation, dice_testing], "dice",
t.n_train_batches, "lower right")
###### Save the network
net.save_parameters(self.path + "net.net")
def run(self):
###### Create the datasets
# aa = CostNegLLWeighted(np.array([0.9, 0.1]))
# e = theano.function(inputs=[], outputs=aa.test())
# print e()
## Load the data
training_data_path = self.data_path + "train.h5"
ds_training = DatasetBrainParcellation()
ds_training.read(training_data_path)
ds_training, ds_validation = ds_training.split_dataset_proportions(
[0.95, 0.05])
testing_data_path = self.data_path + "test.h5"
ds_testing = DatasetBrainParcellation()
ds_testing.read(testing_data_path)
## Display data sample
# image = PIL.Image.fromarray(tile_raster_images(X=ds_training.inputs[0:50],
# img_shape=(29, 29), tile_shape=(5, 10),
# tile_spacing=(1, 1)))
# image.save(self.path + "filters_corruption_30.png")
## Few stats about the targets
classes, proportion_class = analyse_classes(
np.argmax(ds_training.outputs, axis=1), "Training data:")
print(classes)
## Scale some part of the data
print("Scaling")
s = Scaler([slice(-134, None, None)])
s.compute_parameters(ds_training.inputs)
s.scale(ds_training.inputs)
s.scale(ds_validation.inputs)
s.scale(ds_testing.inputs)
pickle.dump(s, open(self.path + "s.scaler", "wb"))
###### Create the network
input_var = T.matrix('inputs')
target_var = T.matrix('targets')
# net = ConvNet(135, input_var, target_var, 29, 29, 13, 134)
# net = ResNet(135, input_var, target_var, 29, 29, 13, 134)
# net = VGGNet(135, input_var, target_var, 29, 29, 13, 134)
# net = Conv3DNet_Multidropout(135, input_var, target_var, 29, 29, 13, 134)
# net = Conv3DNetComp_Lg(135, input_var, target_var, 29, 29, 134)
# net = GoogLeNet(135, input_var, target_var, 29, 29, 13, 134)
# net = Conv3DNet_SmCompFilter(135, input_var, target_var, 29, 29, 13, 134)
# net = Conv3DNet_HeNorm(135, input_var, target_var, 29, 29, 13, 134)
# net = SmallInception(135, input_var, target_var, 29, 29, 13, 134)
# net = Conv3DNet_NoCentroid(135, input_var, target_var, 29, 29, 13, 134)
# net = ConvNet_VerySmall(135, input_var, target_var, 29, 29, 13, 134)
#try:
net = Inceptionv4Simple(135, input_var, target_var, 29, 29, 13, 134)
# except Exception as e:
# print("Program terminated at: " + datetime.datetime.now())
# print(e)
# print net.net
learning_rate = 0.045
# learning_rate = 0.0001
# Create stopping criteria and add them to the trainer
max_epoch = 15
# early_stopping = EarlyStopping(err_validation, 10, 0.99, 5)
# Create the trainer object
batch_size = 50
t = Trainer(net, ds_testing, ds_validation, ds_training, batch_size,
learning_rate)
###### Train the network
t.train()
###### Plot the records
# pred = np.argmax(t.net.predict(ds_testing.inputs, 10000), axis=1)
# d = compute_dice(pred, np.argmax(ds_testing.outputs, axis=1), 134)
# print "Dice test: {}".format(np.mean(d))
# print "Error rate test: {}".format(error_rate(np.argmax(ds_testing.outputs, axis=1), pred))
save_records_plot(self.path, [t.val_errs, t.test_errs],
["validation", "test", "Error"], "upper right")
save_records_plot(self.path, [t.val_dices, t.test_dices],
["validation", "test", "Dice coefficient"],
"lower right")
###### Save the network
np.savez(self.path + 'model.npz', *t.best_net_param)
print("network model saved")
