def visual_results_jsrt_only(model_name, args):
print "Visual results for model {} JSRT only".format(model_name)
imgs, blobs = jsrt.load(set_name='jsrt140p')
pred_blobs = detect.read_blobs('data/{}-jsrt140p-pred-blobs.pkl'.format(
args.detector))
masks = np.load('data/aam-jsrt140p-pred-masks.npy')
rois = create_rois(imgs, masks, pred_blobs, args)
folds = KFold(n_splits=5, shuffle=True,
random_state=util.FOLDS_SEED).split(imgs)
fold_idx = 0
for tr, te in folds:
model.load('data/' + model.name + '.fold-{}'.format(fold_idx + 1))
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
X_tr, Y_tr, X_te, Y_te = neural.create_train_test_sets(
real_blobs_tr, pred_blobs_tr, rois_tr, real_blobs_te,
pred_blobs_te, rois_te)
print 'load weights {}'.format(model.name)
model.network.load_weights('data/{}_weights.h5'.format(model.name))
# FIX: remove and add zmuv mean and zmuv std no Preprocessor augment.py
if not hasattr(model.preprocessor, 'zmuv_mean'):
model.preprocessor.fit(X_tr, Y_tr)
model.save('data/' + model.name)
pred_blobs_te, probs_te = neural.predict_proba(model, pred_blobs_te,
rois_te)
util.save_rois_with_probs(rois_te, probs_te)
fold_idx += 1
def unsupervised_augment(self, model, X_train, Y_train, X_test, Y_test, fold=None, streams=False, nb_epoch=1, pos_neg_ratio=1.0, mode=None):
cropped_shape = (self.roi_size, self.roi_size)
channels = X_train.shape[1] if self.args.datasets == None else X_train[0].shape[1]
self.network = neural.create_network(model, (channels,) + cropped_shape, fold, streams)
#self.load_cnn_weights('data/{}_fold_{}'.format(model, fold))
self.load_cnn('data/{}_fold_{}'.format(model, fold))
if mode in {'add-random'}:
self.network.generator.ratio = pos_neg_ratio
self.network.generator.mode = 'balance_dataset'
if self.args.datasets == None:
X_train, Y_train, X_test, Y_test = self.network.preprocess_augment(X_train, Y_train, X_test, Y_test, streams=(self.streams != 'none'), cropped_shape=cropped_shape, disable_perturb=False)
'''
X_train = (np.array(X_train), np.array(X_train))
X_test = (np.array(X_test), np.array(X_test))
Y_train = (np.array(Y_train), np.array(Y_train))
Y_test = (np.array(Y_test), np.array(Y_test))
X_train, Y_train, X_test, Y_test = preprocess_dataset(X_train, Y_train, X_test, Y_test, streams=(self.streams != 'none'), config=self.args.preprocess_dataset, mode='hdf5')
X_train, Y_train = self._split_data_pos_neg(X_train, Y_train)
X_test, Y_test = self._split_data_pos_neg(X_test, Y_test)
std = np.std(X_train[0])
'''
#self.helper_model = ae.swwae_augment(self.network.network, X_train, Y_train, X_test, Y_test, finetune_epochs=nb_epoch, multipliers=self.multipliers, layerwise_epochs=self.lw_epochs, decoder_epochs=self.dec_epochs, lr=self.lr, model_name=self.init)
self.helper_model = ae.swwae_augment_hdf5(self.network.network, self.network.generator, X_train, Y_train, X_test, Y_test, finetune_epochs=nb_epoch, multipliers=self.multipliers, layerwise_epochs=self.lw_epochs, decoder_epochs=self.dec_epochs, lr=self.lr, model_name=self.init)
else:
print "Preprocessor {}".format(self.network.preprocessor)
print "Generator {}".format(self.network.generator)
self.helper_model = ae.swwae_augment_hdf5(self.network.network, self.network.generator, X_train, Y_train, X_test, Y_test, finetune_epochs=nb_epoch, multipliers=self.multipliers, layerwise_epochs=self.lw_epochs, decoder_epochs=self.dec_epochs, lr=self.lr, model_name=self.init)
def model_evaluation_tr_lidc_te_jsrt(model_name, args):
imgs_tr, blobs_tr = lidc.load()
pred_blobs_tr = detect.read_blobs('data/{}-lidc-pred-blobs.pkl'.format(
args.detector))
masks_tr = np.load('data/aam-lidc-pred-masks.npy')
imgs_te, blobs_te = jsrt.load(set_name='jsrt140p')
pred_blobs_te = detect.read_blobs('data/{}-jsrt140p-pred-blobs.pkl'.format(
args.detector))
masks_te = np.load('data/aam-jsrt140p-pred-masks.npy')
rois_tr = create_rois(imgs_tr, masks_tr, pred_blobs_tr, args)
rois_te = create_rois(imgs_te, masks_te, pred_blobs_te, args)
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model.name += '-{}-lidc'.format(args.detector)
froc = evaluate_model(model, blobs_tr, pred_blobs_tr, rois_tr, blobs_te,
pred_blobs_te, rois_te)
froc = eval.average_froc([froc])
legends = ['Test FROC (JSRT positives)']
util.save_froc([froc],
'data/{}-{}-lidc-jsrt-froc'.format(model.name,
args.detector),
legends,
with_std=False)
def model_output(model_name, args):
print "Model Outputs"
imgs, blobs = jsrt.load(set_name='jsrt140p')
pred_blobs = detect.read_blobs('data/{}-jsrt140p-pred-blobs.pkl'.format(
args.detector))
masks = np.load('data/aam-jsrt140p-pred-masks.npy')
rois = create_rois(imgs, masks, pred_blobs, args)
folds = KFold(n_splits=5, shuffle=True,
random_state=util.FOLDS_SEED).split(imgs)
fold_idx = 0
frocs = []
legends = ['Fold {}'.format(i + 1) for i in range(5)]
index = np.array(range(len(imgs)))
for tr, te in folds:
X_tr, Y_tr, _, _ = neural.create_train_test_sets(
blobs[tr], pred_blobs[tr], rois[tr], blobs[te], pred_blobs[te],
rois[te])
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model.name = model.name + '-{}-lidc.fold-{}'.format(
args.detector, fold_idx + 1)
model.network.load_weights('data/{}_weights.h5'.format(model.name))
if not hasattr(model.preprocessor, 'zmuv_mean'):
model.preprocessor.fit(X_tr, Y_tr)
print "Predict ..."
pred_blobs_te, probs_te, rois_te = neural.predict_proba(
model, pred_blobs[te], rois[te])
print "Save ..."
eval.save_outputs(imgs[te], blobs[te], pred_blobs_te, probs_te,
rois_te, index[te])
def model_selection(model_name, args):
# Load img, blobs and masks
imgs, blobs, paths = lidc.load(pts=True, set_name=args.ds_tr)
if args.ds_tr != args.ds_val:
_, blobs_val, _ = lidc.load(pts=True, set_name=args.ds_val)
else:
blobs_val = blobs
pred_blobs = detect.read_blobs('data/{}-lidc-pred-blobs.pkl'.format(
args.detector))
masks = np.load('data/aam-lidc-pred-masks.npy')
assert len(imgs) == len(masks) and len(pred_blobs) == len(masks)
# Load folds
folds = util.model_selection_folds(imgs)
# Create rois
rois = create_rois(imgs, masks, pred_blobs, args, real_blobs=blobs)
rois_val = create_rois(imgs, masks, pred_blobs, args, real_blobs=blobs_val)
# Set up CV
frocs = []
legends = ['Fold {}'.format(i + 1) for i in range(util.NUM_VAL_FOLDS)]
fold_idx = 0
for tr, te in folds:
# Load and setup model
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model.network.summary()
model.name = model.name + '.fold-{}'.format(fold_idx + 1)
if args.load_model:
print "Loading model: data/{}".format(model.name)
model.load('data/' + model.name)
# Train/test model
froc = evaluate_model(model, blobs[tr], pred_blobs[tr], rois[tr],
blobs_val[te], pred_blobs[te], rois_val[te],
args.load_model)
frocs.append(froc)
# Record model results
current_frocs = [eval.average_froc([froc_i]) for froc_i in frocs]
util.save_froc(current_frocs,
'data/{}-{}-folds-froc'.format(model.name[:-7],
args.detector),
legends[:len(frocs)],
with_std=False)
model.save('data/' + model.name)
fold_idx += 1
legends = ['Val FROC (LIDC-IDRI)']
average_froc = eval.average_froc(frocs, np.linspace(0.0, 10.0, 101))
util.save_froc([average_froc],
'data/{}-{}-val-froc'.format(model.name[:-7],
args.detector),
legends,
with_std=True)
def save_performance_history(model_name, args, rois, blobs, pred_blobs, folds):
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model_name = model.name
epochs = model.training_params['nb_epoch']
frocs = []
legends = []
fold_idx = 0
for tr, te in folds:
model.load('data/' + model_name + '.fold-{}'.format(fold_idx + 1))
frocs.append([])
epochs_set = list(range(1, epochs + 1, 2))
for epoch in epochs_set:
weights_file_name = 'data/{}.weights.{:02d}.hdf5'.format(
model.name, epoch)
model.network.load_weights(weights_file_name)
pred_blobs_te, probs_te = neural.predict_proba(
model, pred_blobs[te], rois[te])
frocs[fold_idx].append(
eval.froc(blobs[te], pred_blobs_te, probs_te))
fold_idx += 1
frocs = np.array(frocs)
froc_history = []
aucs_history = []
legends = []
i = 0
print "check -> frocs.shape {}".format(frocs.shape)
for epoch in range(1, epochs + 1, 2):
frocs_by_epoch = frocs[:, i]
froc_history.append(
eval.average_froc(np.array(frocs_by_epoch),
np.linspace(0.0, 10.0, 101)))
aucs_history.append([])
aucs_history[-1].append(
util.auc(froc_history[-1], np.linspace(0.2, 4.0, 101))**2)
aucs_history[-1].append(
util.auc(froc_history[-1], np.linspace(0.0, 5.0, 101))**2)
aucs_history[-1].append(
util.auc(froc_history[-1], np.linspace(0.0, 10.0, 101))**2)
legends.append('Val FROC (LIDC-IDRI), epoch {}'.format(epoch))
i += 1
util.save_froc(froc_history,
'data/{}-val-froc-by-epoch'.format(model_name),
legends,
with_std=False)
util.save_aucs(list(range(1, epochs + 1, 2)), aucs_history,
'data/{}-val-aucs'.format(model_name),
['AUC between 2-4', 'AUC between 0-5', 'AUC between 0-10'])
def train_with_feature_set_keras(self, feats_tr, pred_blobs_tr, real_blobs_tr,
feats_test=None, pred_blobs_test=None, real_blobs_test=None,
model='shallow_1', model_suffix=None, network_init=None):
print("{} {} {} {} {} {}".format(len(feats_tr), len(pred_blobs_tr), len(real_blobs_tr), len(feats_test), len(pred_blobs_test), len(real_blobs_test)))
X_train, Y_train, X_test, Y_test = neural.create_train_test_sets(feats_tr, pred_blobs_tr, real_blobs_tr,
feats_test, pred_blobs_test, real_blobs_test, streams=self.streams )
print "X_train shape {}".format(X_train.shape)
self.network = neural.create_network(model, (X_train.shape[1], self.roi_size, self.roi_size), self.streams)
if network_init is not None:
if self.args.transfer:
self.load_cnn_weights('data/{}_{}'.format(network_init, model_suffix))
else:
self.load_cnn_weights(network_init)
name = 'data/{}_{}'.format(model, model_suffix)
history = self.network.fit(X_train, Y_train, X_test, Y_test, streams=(self.streams != 'none'), cropped_shape=(self.roi_size, self.roi_size), checkpoint_prefix=name, checkpoint_interval=2)
return history
def classify(image, args):
image = preprocess.antialiasing_dowsample(image, downsample=True)
image = np.array([image])
blobs, probs, mask = detect.detect_func(image[0], 'sbf', 'aam', 0.5)
rois = create_rois([image], mask, [blobs], args)
model = neural.create_network(args.model, args,
(1, args.roi_size, args.roi_size))
model.name += '-lidc'
model.load('data/' + model.name)
blobs, probs = neural.predict_proba(model, [blobs], rois)
blobs, probs = blobs[0], probs[0]
entries = [[blobs[i], probs[i]] for i in range(len(blobs))]
entries = list(reversed(sorted(entries, key=itemgetter(1))))
top_blobs = []
top_probs = []
for i in range(args.fppi):
top_blobs.append(entries[i][0])
top_probs.append([entries[i][1]])
util.imwrite_with_blobs('data/classified', image[0], top_blobs)
return blobs, probs, mask
def model_evaluation_jsrt_only(model_name, args):
print "Model Evaluation Protocol 2"
imgs, blobs = jsrt.load(set_name='jsrt140p')
pred_blobs = detect.read_blobs('data/{}-jsrt140p-pred-blobs.pkl'.format(
args.detector))
masks = np.load('data/aam-jsrt140p-pred-masks.npy')
rois = create_rois(imgs, masks, pred_blobs, args)
folds = KFold(n_splits=5, shuffle=True,
random_state=util.FOLDS_SEED).split(imgs)
fold_idx = 0
frocs = []
legends = ['Fold {}'.format(i + 1) for i in range(5)]
for tr, te in folds:
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model.name = model.name + '-{}-lidc.fold-{}'.format(
args.detector, fold_idx + 1)
froc = evaluate_model(model, blobs[tr], pred_blobs[tr], rois[tr],
blobs[te], pred_blobs[te], rois[te])
frocs.append(froc)
current_frocs = [eval.average_froc([froc_i]) for froc_i in frocs]
util.save_froc(current_frocs,
'data/{}-{}-only-jsrt-folds'.format(
model.name[:-7], args.detector),
legends[:len(frocs)],
with_std=False)
model.save('data/' + model.name)
fold_idx += 1
froc = eval.average_froc(frocs)
legends = ['Test FROC (JSRT positives)']
util.save_froc([froc],
'data/{}-{}-only-jsrt'.format(model.name[:-7],
args.detector),
legends,
with_std=True)
def model_selection_unsup(model_name, args):
imgs, blobs, paths = lidc.load(pts=True)
pred_blobs = detect.read_blobs('data/{}-lidc-pred-blobs.pkl'.format(
args.detector))
masks = np.load('data/aam-lidc-pred-masks.npy')
assert len(imgs) == len(masks) and len(pred_blobs) == len(masks)
folds = util.model_selection_folds(imgs)
rois = create_rois(imgs, masks, pred_blobs, args, real_blobs=blobs)
frocs = []
legends = ['Fold {}'.format(i + 1) for i in range(util.NUM_VAL_FOLDS)]
fold_idx = 0
for tr, te in folds:
model = neural.create_network(model_name, args,
(1, args.roi_size, args.roi_size))
model.name = model.name + '.fold-{}'.format(fold_idx + 1)
froc = evaluate_model(model, blobs[tr], pred_blobs[tr], rois[tr],
blobs[te], pred_blobs[te], rois[te])
frocs.append(froc)
current_frocs = [eval.average_froc([froc_i]) for froc_i in frocs]
util.save_froc(current_frocs,
'data/{}-{}-folds-froc'.format(model_name,
args.detector),
legends[:len(frocs)],
with_std=False)
model.save('data/' + model.name)
fold_idx += 1
legends = ['Val FROC (LIDC-IDRI)']
average_froc = eval.average_froc(frocs, np.linspace(0.0, 10.0, 101))
util.save_froc([average_froc],
'data/{}-{}-val-froc'.format(model_name, args.detector),
legends,
with_std=True)
def transfer_with_imagenet(network_name):
network = neural.create_network(network_name, (1, 1))
# train
train_datagen = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
'../dbs/ILSVRC2012_img_train',
target_size=(32, 32),
color_mode='grayscale',
class_mode='categorical',
batch_size=32,
shuffle=True)
optimizer = SGD(lr=0.01)
network.network.compile(loss='categorical_crossentropy',
optimizer=optimizer)
network.network.fit_generator(train_generator,
samples_per_epoch=3200000,
nb_epoch=2)
network.save(network_name)
def joint_training(self, model, X_train, Y_train, X_test, Y_test, fold=None):
cropped_shape = (self.roi_size, self.roi_size)
self.network = neural.create_network(model, (X_train.shape[1],) + cropped_shape, fold, self.streams)
X_train, Y_train, X_test, Y_test = self.network.preprocess_augment(X_train, Y_train, X_test, Y_test, streams=(self.streams != 'none'), cropped_shape=cropped_shape)
self.helper_model = ae.swwae_train(self.network.network, X_train, Y_train, X_test, Y_test, finetune_epochs=self.all_epochs, multipliers=self.multipliers, layerwise_epochs=self.lw_epochs, decoder_epochs=self.dec_epochs, lr=self.lr, model_name=self.init)
def pretrain(self, model, X, fold=None, streams=False, nb_epoch=1):
cropped_shape = (self.roi_size, self.roi_size)
self.network = neural.create_network(model, (X.shape[1],) + cropped_shape, fold, streams)
ae.pretrain_layerwise(self.network.network, X, nb_epoch=nb_epoch)
def froc_by_epochs(data,
blobs,
augmented_blobs,
rois,
folds,
network_model,
nb_epochs=30,
epoch_interval=2):
network_init = None
roi_size = 32
streams = 'none'
imgs = []
masks = []
for i in range(len(data)):
img, lung_mask = data.get(i, downsample=True)
sampled, lce, norm = preprocess.preprocess_hardie(img,
lung_mask,
downsample=True)
imgs.append([lce])
masks.append(lung_mask)
imgs = np.array(imgs)
masks = np.array(masks)
# Hardcoding blob set shapes
blobs2 = blobs
blobs = blobs.reshape((len(blobs), 3))
nb_checkpoints = int(nb_epochs / epoch_interval)
epochs = np.linspace(epoch_interval, nb_checkpoints * epoch_interval,
nb_checkpoints).astype(np.int)
av_frocs = []
names = []
aucs1 = []
aucs2 = []
for epoch in epochs:
frocs = []
fold = 1
for tr_idx, te_idx in folds:
print "Fold {} ...".format(fold)
X_train, Y_train, X_test, Y_test = neural.create_train_test_sets(
rois[tr_idx],
augmented_blobs[tr_idx],
blobs[tr_idx],
rois[te_idx],
augmented_blobs[te_idx],
blobs[te_idx],
streams=streams,
detector=True)
# load network
network = neural.create_network(network_model,
X_train.shape,
fold,
streams,
detector=False)
name = 'data/{}_fold_{}.epoch_{}'.format(network_model, fold,
epoch)
network.network.load_weights('{}_weights.h5'.format(name))
# open network on detector mode
detector_network = neural.create_network(network_model,
X_train.shape,
fold,
streams,
detector=True)
copy_weights(network, detector_network)
# evaluate network on test
blobs_te_pred, probs_te_pred = detect_with_network(
detector_network, imgs[te_idx], masks[te_idx], fold=fold)
froc = eval.froc(blobs2[te_idx], blobs_te_pred, probs_te_pred)
frocs.append(froc)
fold += 1
names.append('{}, epoch {}'.format(network_model, epoch))
ops = eval.average_froc(frocs, fppi_range)
av_frocs.append(ops)
aucs1.append(util.auc(ops, range(0, 60)))
aucs2.append(util.auc(ops, range(0, 40)))
util.save_auc(
np.array(range(1,
len(aucs1) + 1)) * epoch_interval, aucs1,
'data/{}-auc-0-60'.format(network_model))
util.save_auc(
np.array(range(1,
len(aucs2) + 1)) * epoch_interval, aucs2,
'data/{}-auc-0-40'.format(network_model))
return av_frocs, names
def eval_cnn_detector(data, blobs, augmented_blobs, rois, folds, model):
fold = 1
network_init = None
roi_size = 32
streams = 'none'
imgs = []
masks = []
for i in range(len(data)):
img, lung_mask = data.get(i, downsample=True)
sampled, lce, norm = preprocess.preprocess_hardie(img,
lung_mask,
downsample=True)
imgs.append([lce])
masks.append(lung_mask)
imgs = np.array(imgs)
masks = np.array(masks)
# Hardcoding blob set shapes
blobs2 = blobs
blobs = blobs.reshape((len(blobs), 3))
frocs = []
for tr_idx, te_idx in folds:
print "Fold {} ...".format(fold)
X_train, Y_train, X_test, Y_test = neural.create_train_test_sets(
rois[tr_idx],
augmented_blobs[tr_idx],
blobs[tr_idx],
rois[te_idx],
augmented_blobs[te_idx],
blobs[te_idx],
streams=streams,
detector=True)
network = neural.create_network(model,
X_train.shape,
fold,
streams,
detector=False)
if network_init is not None:
network.network.load_weights('data/{}_fold_{}_weights.h5'.format(
network_init, fold))
# save network
name = 'data/{}_fold_{}'.format(model, fold)
history = network.fit(X_train,
Y_train,
X_test,
Y_test,
streams=(streams != 'none'),
cropped_shape=(roi_size, roi_size),
checkpoint_prefix=name,
checkpoint_interval=2,
loss='mse')
network.save(name)
# open network on detector mode
network.network.summary()
detector_network = neural.create_network(model,
X_train.shape,
fold,
streams,
detector=True)
detector_network.network.summary()
copy_weights(network, detector_network)
#network.network.load_weights('{}_weights.h5'.format(name))
#network.load(name)
# evaluate network on test
blobs_te_pred, probs_te_pred = detect_with_network(detector_network,
imgs[te_idx],
masks[te_idx],
fold=fold)
froc = eval.froc(blobs2[te_idx], blobs_te_pred, probs_te_pred)
frocs.append(froc)
fold += 1
av_froc = eval.average_froc(frocs, fppi_range)
return av_froc
