def compare_seg_with_gt(max_n_images=10, epoch=0):
    data_gen_validation = SegmentationBatchGeneratorDavid(
        all_patients,
        BATCH_SIZE,
        validation_patients,
        PATCH_SIZE=INPUT_PATCH_SIZE,
        mode="test",
        ignore=[81, 10, 47],
        losses=None,
        num_batches=None,
        seed=10,
    )
    data_gen_validation = seg_channel_selection_generator(data_gen_validation, [2])
    data_gen_validation = center_crop_seg_generator(data_gen_validation, OUTPUT_PATCH_SIZE)
    data, seg, idx = data_gen_validation.next()
    seg = np.array(seg)
    seg_pred = get_segmentation(data)
    plt.figure(figsize=(6, 20))
    n_images = np.min((seg_pred.shape[0], max_n_images))
    for i in range(n_images):
        seg_pred[i][0, :6] = np.array([0, 1, 2, 3, 4, 5])
        seg[i, 0, 0, :6] = np.array([0, 1, 2, 3, 4, 5])
        plt.subplot(n_images, 2, 2 * i + 1)
        plt.imshow(seg[i, 0])
        plt.subplot(n_images, 2, 2 * i + 2)
        plt.imshow(seg_pred[i])
    plt.savefig(os.path.join(results_dir, "some_segmentations_ep_%d.png" % epoch))
Esempio n. 2
0
def compare_seg_with_gt(max_n_images=5, epoch=0):
    data_gen_validation = SegmentationBatchGeneratorBraTS2014(
        all_patients,
        BATCH_SIZE,
        validation_patients,
        PATCH_SIZE=PATCH_SIZE,
        mode="test",
        ignore=[81],
        losses=None,
        num_batches=None,
        seed=10)
    data_gen_validation = seg_channel_selection_generator(
        data_gen_validation, [2])
    data_gen_validation = center_crop_seg_generator(data_gen_validation,
                                                    (180, 164))
    data, seg, idx = data_gen_validation.next()
    seg = np.array(seg)
    seg_pred = get_segmentation(data)
    plt.figure(figsize=(6, 12))
    n_images = np.min((seg_pred.shape[0], max_n_images))
    for i in range(n_images):
        seg_pred[i][0, :6] = np.array([0, 1, 2, 3, 4, 5])
        seg[i, 0, 0, :6] = np.array([0, 1, 2, 3, 4, 5])
        plt.subplot(n_images, 2, 2 * i + 1)
        plt.imshow(seg[i, 0])
        plt.subplot(n_images, 2, 2 * i + 2)
        plt.imshow(seg_pred[i])
    plt.savefig(
        os.path.join(results_dir, "some_segmentations_ep_%d.png" % epoch))
Esempio n. 3
0
validation_patients = [157,  69,   7,  97, 235,  12, 231, 200, 177, 104, 247,  41, 237, 24, 118, 198, 103,   6, 243,  35,   0,  18, 112, 180,  25]

'''d, s, l = data_gen_train.next()
plt.figure(figsize=(12, 5))
plt.subplot(1, 3, 1)
plt.imshow(d[0,0], cmap="gray")
plt.subplot(1, 3, 2)
d1=elastic_transform_2d(d[0,0], 550., 20.)
plt.imshow(d1, cmap="gray")
plt.subplot(1, 3, 3)
plt.imshow(d[0,0]-d1)
plt.show()
plt.close()'''

data_gen_validation = SegmentationBatchGeneratorBraTS2014(all_patients, BATCH_SIZE, validation_patients, PATCH_SIZE=PATCH_SIZE, mode="test", ignore=[81], losses=None, num_batches=None, seed=None)
data_gen_validation = seg_channel_selection_generator(data_gen_validation, [2])
data_gen_validation = center_crop_seg_generator(data_gen_validation, (180, 164))
data_gen_validation = Multithreaded_Generator(data_gen_validation, 2, 30)
data_gen_validation._start()

net = build_UNet(20, BATCH_SIZE, num_output_classes=6, base_n_filters=16, input_dim=PATCH_SIZE, pad="valid")
output_layer_for_loss = net["output_flattened"]

n_batches_per_epoch = 300
# n_batches_per_epoch = np.floor(n_training_samples/float(BATCH_SIZE))
n_test_batches = 30
# n_test_batches = np.floor(n_val_samples/float(BATCH_SIZE))

x_sym = T.tensor4()
seg_sym = T.ivector()
w_sym = T.vector()
'''d, s, l = data_gen_train.next()
plt.figure(figsize=(12, 5))
plt.subplot(1, 3, 1)
plt.imshow(d[0,0], cmap="gray")
plt.subplot(1, 3, 2)
d1=elastic_transform_2d(d[0,0], 550., 20.)
plt.imshow(d1, cmap="gray")
plt.subplot(1, 3, 3)
plt.imshow(d[0,0]-d1)
plt.show()
plt.close()'''

data_gen_validation = memmapGenerator_allInOne_segmentation_lossSampling(memmap_data, memmap_gt, BATCH_SIZE, validation_patients, mode="test", ignore=[40])
data_gen_validation = center_crop_generator(data_gen_validation, (PATCH_SIZE, PATCH_SIZE))
data_gen_validation = seg_channel_selection_generator(data_gen_validation, [2])
data_gen_validation = multi_threaded_generator(data_gen_validation, num_threads=4, num_cached=10)

net = build_UNet(20, BATCH_SIZE, num_output_classes=5, base_n_filters=16, input_dim=(PATCH_SIZE, PATCH_SIZE))
output_layer_for_loss = net["output_flattened"]
'''with open(os.path.join(results_dir, "%s_Params_ep30.pkl"%EXPERIMENT_NAME, 'r') as f:
    params = cPickle.load(f)
    lasagne.layers.set_all_param_values(output_layer_for_loss, params)
with open(os.path.join(results_dir, "%s_allLossesNAccur_ep30.pkl"%EXPERIMENT_NAME, 'r') as f:
    # [all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, auc_all] = cPickle.load(f)
    [all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies] = cPickle.load(f)'''

n_batches_per_epoch = 500
# n_batches_per_epoch = np.floor(n_training_samples/float(BATCH_SIZE))
n_test_batches = 50
# n_test_batches = np.floor(n_val_samples/float(BATCH_SIZE))