def __init__(self, batch_size = 128, iterations = 32):
BatchIterator.__init__(self, batch_size)
self.iterations = iterations
self.X = None
self.y = None
self.cidx = 0
self.midx = 0
def __init__(self, batch_size = 128, iterations = 32):
BatchIterator.__init__(self, batch_size)
update=adam,
update_learning_rate=theano.shared(float32(0.0001), borrow=True),
# update_momentum=theano.shared(float32(0.001), borrow=True),
update_beta1=0.9,
update_beta2=0.99,
update_epsilon=1e-06,
on_epoch_finished=[
# AdjustVariable('update_learning_rate', start=0.3, stop=0.05),
# AdjustVariable('update_momentum', start=0.001, stop=0.00299),
# EarlyStopping(patience=200),
],
regression=True,
train_split=TrainSplit(eval_size=0.0),
y_tensor_type=T.matrix,
verbose=1,
batch_iterator_train=BatchIterator(3200),
max_epochs=230)
#np.random.seed(7)
#net0_clone = clone(net0)
#net0_clone.fit(t1nn_conc_shared.get_value(), y)
#net0_clone.fit(X_encoded_shared.get_value(), y)
cv_by_hand = [(np.where(cvFolds != fold)[0], np.where(cvFolds == fold)[0])
for fold in np.unique(cvFolds)]
foldPred = np.zeros((t1nn_conc_shared.get_value().shape[0], 1))
bags = 10
for iter in xrange(0, bags):
for fold in xrange(0, np.max(cvFolds)):
np.random.seed(iter + 56)
nin2_nonlinearity=rectify,
pool2_pool_size=(2, 2),
pool2_stride=(2, 2),
conv5_num_filters=50,
conv5_filter_size=(3, 3),
conv5_nonlinearity=rectify,
output_num_units=32 * 32,
output_nonlinearity=sigmoid,
update_learning_rate=LearningRate,
update_momentum=0.975,
objective_loss_function=lasagne.objectives.binary_crossentropy,
batch_iterator_train=BatchIterator(batch_size=100),
batch_iterator_test=BatchIterator(batch_size=100),
train_split=TrainSplit(eval_size=0.05),
regression=True,
max_epochs=1,
verbose=1,
);
class Logger(object):
def __init__(self):
self.terminal = sys.stdout
self.log = open("logfile_6.log", "a")
def write(self, message):
self.terminal.write(message)
from lasagne.updates import nesterov_momentum
clf = NeuralNet(layers=[
('input', InputLayer),
('hidden1', DenseLayer),
('output', DenseLayer),
],
input_shape=(None, 784),
output_num_units=10,
output_nonlinearity=softmax,
eval_size=0.0,
more_params=dict(hidden1_num_units=300, ),
update=nesterov_momentum,
update_learning_rate=0.02,
update_momentum=0.9,
batch_iterator_train=BatchIterator(batch_size=25),
max_epochs=10,
verbose=1)
classifiers.append(('nolearn.lasagne', clf))
RUNS = 1
for name, orig in classifiers:
times = []
accuracies = []
for i in range(RUNS):
start = time.time()
clf = clone(orig)
clf.random_state = int(time.time())
clf.fit(X_train, y_train)
loss = tf.reduce_mean(tf.square(predictions - tf_y_batch))
#Optimizer
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(loss)
every_epoch_to_log = 1
with tf.Session(graph=graph) as session:
session.run(tf.global_variables_initializer())
saver = tf.train.Saver()
train_loss_history = np.zeros(num_epochs)
valid_loss_history = np.zeros(num_epochs)
print("============ TRAINING =============")
for epoch in range(num_epochs):
current_epoch = epoch
batch_iterator = BatchIterator(batch_size=batch_size, shuffle=True)
for x_batch, y_batch in batch_iterator(voxels, labels):
session.run(optimizer,
feed_dict={
tf_x_batch: x_batch,
tf_y_batch: y_batch,
is_training: True
})
#to log the losses get predictions on entire training set
p = []
total_loss = 0
if (epoch % every_epoch_to_log == 0):
batch_iterator = BatchIterator(batch_size=10) #128
for x_batch, y_batch in batch_iterator(voxels, labels):
#[p_batch]=session.run([logits],feed_dict={tf_x_batch:x_batch,is_training:False})
from lasagne.updates import nesterov_momentum
clf = NeuralNet(layers=[
('input', InputLayer),
('hidden1', DenseLayer),
('output', DenseLayer),
],
input_shape=(None, 784),
output_num_units=10,
output_nonlinearity=softmax,
eval_size=0.0,
more_params=dict(hidden1_num_units=200, ),
update=nesterov_momentum,
update_learning_rate=0.02,
update_momentum=0.9,
batch_iterator_train=BatchIterator(batch_size=300),
max_epochs=10,
verbose=1)
classifiers.append(('nolearn.lasagne', clf))
RUNS = 10
for name, orig in classifiers:
times = []
accuracies = []
for i in range(RUNS):
start = time.time()
clf = clone(orig)
clf.random_state = int(time.time())
clf.fit(X_train, y_train)
def build_net(randomize=False,loss=categorical_crossentropy,
y_tensor_type=None,dropfactor=1.0,sizefactor=1):
layers0=[('input',InputLayer),
('dropin',DropoutLayer),
('dense0',DenseLayer),
('dropout0',DropoutLayer),
('dense1',DenseLayer),
('dropout1',DropoutLayer),
('dense2',DenseLayer),
('dropout2',DropoutLayer),
('output',DenseLayer)]
n=[int(512*sizefactor),int(800*sizefactor),int(1024*sizefactor)]
leak=[0.3,0.0,0.0]
drop=[0.1,0.2,0.3,0.4]
if randomize:
for i in range(3):
n[i] += np.random.randint(low=-n[i]//15,high=n[i]//15)
"""
for i in range(4):
drop[i] *= np.random.uniform(0.8,1.2)
leak[0]=np.random.uniform(0.2,0.3)
leak[1]=np.random.uniform(0,0.1)
leak[2]=np.random.uniform(0.0,0.05)
"""
print "net: ", n,leak,drop
net0=NeuralNet(layers=layers0,
input_shape=(None,num_features),
dropin_p=drop[0]*dropfactor,
dense0_num_units=n[0],
dense0_W=HeNormal(),
dense0_nonlinearity=LeakyRectify(leak[0]),
dropout0_p=drop[1]*dropfactor,
dense1_num_units=n[1],
dense1_nonlinearity=LeakyRectify(leak[1]),
dense1_W=HeNormal(),
dropout1_p=drop[2]*dropfactor,
dense2_num_units=n[2], # 1024
dense2_nonlinearity=LeakyRectify(leak[2]),
dense2_W=HeNormal(),
dropout2_p=drop[3]*dropfactor,
output_num_units=num_classes,
output_nonlinearity=softmax,
update=nesterov_momentum,
update_learning_rate = theano.shared(tfloat32(0.02)),
update_momentum = theano.shared(tfloat32(0.9)),
eval_size=0.0,
verbose=1,
max_epochs=150,
on_epoch_finished=[
AdjustVariable('update_learning_rate',
epochs=[50,100],rates=[2e-3,2e-4])],
regularization_rate=1e-5,
batch_iterator_train=BatchIterator(batch_size=128),
objective_loss_function= loss,
y_tensor_type=y_tensor_type
)
return net0
'num_units': 1024
}),
# the output layer
(layers.DenseLayer, {
'num_units': 11,
'nonlinearity': lasagne.nonlinearities.softmax
}),
]
net0 = NeuralNet(
layers=layers0,
update_learning_rate=0.0001,
max_epochs=100,
update=adam,
objective_l2=0.0025,
batch_iterator_train=BatchIterator(
path='/home/sharique/Documents/minor/dataset/', batch_size=60),
batch_iterator_test=BatchIterator(
path='/home/sharique/Documents/minor/dataset/', batch_size=29),
train_split=TrainSplit(eval_size=0.02),
verbose=1,
)
#################################################################
# bi = BatchIterator(batch_size=29)
#################################################################
# from nolearn.lasagne import PrintLayerInfo
# layer_info=PrintLayerInfo()
#################################################################
# type(Y_train)
softmax_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits, tf_y_batch)
loss = tf.reduce_mean(softmax_cross_entropy)
with tf.variable_scope('fc8', reuse=True):
optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(
loss, var_list=[tf.get_variable('weights'),
tf.get_variable('biases')])
with tf.Session() as session:
session.run(tf.global_variables_initializer())
print('Training...')
for epoch in range(10):
# Train on whole randomised dataset in batches
batch_iterator = BatchIterator(batch_size=128, shuffle=True)
for x_batch, y_batch in batch_iterator(X_train, y_train):
session.run([optimizer],
feed_dict={
tf_x_batch: x_batch,
tf_y_batch: y_batch
})
p = []
sce = []
batch_iterator = BatchIterator(batch_size=128)
for x_batch, y_batch in batch_iterator(X_valid, y_valid):
[p_batch,
sce_batch] = session.run([predictions, softmax_cross_entropy],
feed_dict={
tf_x_batch: x_batch,
def make_grnn(
batch_size,
emb_size,
g_hidden_size,
word_n,
wc_num,
dence,
wsm_num=1,
rnn_type='LSTM',
rnn_size=12,
dropout_d=0.5, # pooling='mean',
quest_na=4,
gradient_steps=-1,
valid_indices=None,
lr=0.05,
grad_clip=10):
def select_rnn(x):
return {
'RNN': LL.RecurrentLayer,
'LSTM': LL.LSTMLayer,
'GRU': LL.GRULayer,
}.get(x, LL.LSTMLayer)
# dence = dence + [1]
RNN = select_rnn(rnn_type)
#------------------------------------------------------------------input layers
layers = [
(LL.InputLayer, {
'name': 'l_in_se_q',
'shape': (None, word_n, emb_size)
}),
(LL.InputLayer, {
'name': 'l_in_se_a',
'shape': (None, quest_na, word_n, emb_size)
}),
(LL.InputLayer, {
'name': 'l_in_mask_q',
'shape': (None, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_mask_a',
'shape': (None, quest_na, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_mask_ri_q',
'shape': (None, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_mask_ri_a',
'shape': (None, quest_na, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_wt_q',
'shape': (None, word_n, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_wt_a',
'shape': (None, word_n, quest_na, word_n)
}),
(LL.InputLayer, {
'name': 'l_in_act_',
'shape': (None, word_n, g_hidden_size)
}),
(LL.InputLayer, {
'name': 'l_in_act__',
'shape': (None, word_n, word_n, g_hidden_size)
}),
]
#------------------------------------------------------------------slice layers
# l_qs = []
# l_cas = []
l_ase_names = ['l_ase_{}'.format(i) for i in range(quest_na)]
l_amask_names = ['l_amask_{}'.format(i) for i in range(quest_na)]
l_amask_ri_names = ['l_amask_ri_{}'.format(i) for i in range(quest_na)]
l_awt_names = ['l_awt_{}'.format(i) for i in range(quest_na)]
for i in range(quest_na):
layers.extend([(LL.SliceLayer, {
'name': l_ase_names[i],
'incoming': 'l_in_se_a',
'indices': i,
'axis': 1
})])
for i in range(quest_na):
layers.extend([(LL.SliceLayer, {
'name': l_amask_names[i],
'incoming': 'l_in_mask_a',
'indices': i,
'axis': 1
})])
for i in range(quest_na):
layers.extend([(LL.SliceLayer, {
'name': l_amask_ri_names[i],
'incoming': 'l_in_mask_ri_a',
'indices': i,
'axis': 1
})])
for i in range(quest_na):
layers.extend([(LL.SliceLayer, {
'name': l_awt_names[i],
'incoming': 'l_in_wt_a',
'indices': i,
'axis': 1
})])
#-------------------------------------------------------------------GRNN layers
WC = theano.shared(
np.random.randn(wc_num, g_hidden_size,
g_hidden_size).astype('float32'))
# WC = LI.Normal(0.1)
WSM = theano.shared(
np.random.randn(emb_size, g_hidden_size).astype('float32'))
b = theano.shared(np.ones(g_hidden_size).astype('float32'))
# b = lasagne.init.Constant(1.0)
layers.extend([(GRNNLayer, {
'name':
'l_q_grnn',
'incomings':
['l_in_se_q', 'l_in_mask_q', 'l_in_wt_q', 'l_in_act_', 'l_in_act__'],
'emb_size':
emb_size,
'hidden_size':
g_hidden_size,
'word_n':
word_n,
'wc_num':
wc_num,
'wsm_num':
wsm_num,
'only_return_final':
False,
'WC':
WC,
'WSM':
WSM,
'b':
b
})])
l_a_grnns_names = ['l_a_grnn_{}'.format(i) for i in range(quest_na)]
for i, l_a_grnns_name in enumerate(l_a_grnns_names):
layers.extend([(GRNNLayer, {
'name':
l_a_grnns_name,
'incomings': [
l_ase_names[i], l_amask_names[i], l_awt_names[i], 'l_in_act_',
'l_in_act__'
],
'emb_size':
emb_size,
'hidden_size':
g_hidden_size,
'word_n':
word_n,
'wc_num':
wc_num,
'wsm_num':
wsm_num,
'only_return_final':
False,
'WC':
WC,
'WSM':
WSM,
'b':
b
})])
#------------------------------------------------------------concatenate layers
layers.extend([(LL.ConcatLayer, {
'name': 'l_qa_concat',
'incomings': ['l_q_grnn'] + l_a_grnns_names
})])
layers.extend([(LL.ConcatLayer, {
'name': 'l_qamask_concat',
'incomings': ['l_in_mask_ri_q'] + l_amask_ri_names
})])
#--------------------------------------------------------------------RNN layers
layers.extend([(RNN, {
'name': 'l_qa_rnn_f',
'incoming': 'l_qa_concat',
'mask_input': 'l_qamask_concat',
'num_units': rnn_size,
'backwards': False,
'only_return_final': True,
'grad_clipping': grad_clip
})])
layers.extend([(RNN, {
'name': 'l_qa_rnn_b',
'incoming': 'l_qa_concat',
'mask_input': 'l_qamask_concat',
'num_units': rnn_size,
'backwards': True,
'only_return_final': True,
'grad_clipping': grad_clip
})])
layers.extend([(LL.ElemwiseSumLayer, {
'name': 'l_qa_rnn_conc',
'incomings': ['l_qa_rnn_f', 'l_qa_rnn_b']
})])
##-----------------------------------------------------------------pooling layer
## l_qa_pool = layers.extend([(LL.ExpressionLayer, {'name': 'l_qa_pool',
## 'incoming': l_qa_rnn_conc,
## 'function': lambda X: X.mean(-1),
## 'output_shape'='auto'})])
#------------------------------------------------------------------dence layers
l_dence_names = ['l_dence_{}'.format(i) for i, _ in enumerate(dence)]
if dropout_d:
layers.extend([(LL.DropoutLayer, {
'name': 'l_dence_do' + 'do',
'p': dropout_d
})])
for i, d in enumerate(dence):
if i < len(dence) - 1:
nonlin = LN.tanh
else:
nonlin = LN.softmax
layers.extend([(LL.DenseLayer, {
'name': l_dence_names[i],
'num_units': d,
'nonlinearity': nonlin
})])
if i < len(dence) - 1 and dropout_d:
layers.extend([(LL.DropoutLayer, {
'name': l_dence_names[i] + 'do',
'p': dropout_d
})])
def loss(x, t):
return LO.aggregate(
LO.categorical_crossentropy(T.clip(x, 1e-6, 1. - 1e-6), t))
# return LO.aggregate(LO.squared_error(T.clip(x, 1e-6, 1. - 1e-6), t))
if isinstance(valid_indices, np.ndarray) or isinstance(
valid_indices, list):
train_split = TrainSplit_indices(valid_indices=valid_indices)
else:
train_split = TrainSplit(eval_size=valid_indices, stratify=False)
nnet = NeuralNet(
y_tensor_type=T.ivector,
layers=layers,
update=LU.adagrad,
update_learning_rate=lr,
# update_epsilon=1e-7,
objective_loss_function=loss,
regression=False,
verbose=2,
batch_iterator_train=PermIterator(batch_size=batch_size),
batch_iterator_test=BatchIterator(batch_size=batch_size / 2),
# batch_iterator_train=BatchIterator(batch_size=batch_size),
# batch_iterator_test=BatchIterator(batch_size=batch_size),
#train_split=TrainSplit(eval_size=eval_size)
train_split=train_split)
nnet.initialize()
PrintLayerInfo()(nnet)
return nnet
def train_model(params, X_train, y_train, X_valid, y_valid, X_test, y_test):
# Initialisation routines: generate variable scope, create logger, note start time.
paths = Paths(params)
start = time.time()
model_variable_scope = paths.var_scope
# Build the graph
graph = tf.Graph()
with graph.as_default():
# Input data. For the training data, we use a placeholder that will be fed at run time with a training minibatch.
tf_x_batch = tf.placeholder(tf.float32, shape = (None, params.image_size[0], params.image_size[1], 1))
tf_y_batch = tf.placeholder(tf.float32, shape = (None, params.num_classes))
is_training = tf.placeholder(tf.bool)
current_epoch = tf.Variable(0, trainable=False) # count the number of epochs
# Model parameters.
if params.learning_rate_decay:
learning_rate = tf.train.exponential_decay(params.learning_rate, current_epoch, decay_steps = params.max_epochs, decay_rate = 0.01)
else:
learning_rate = params.learning_rate
# Training computation.
with tf.variable_scope(model_variable_scope):
logits = model_pass(tf_x_batch, params, is_training)
if params.l2_reg_enabled:
with tf.variable_scope('fc4', reuse = True):
l2_loss = tf.nn.l2_loss(tf.get_variable('weights'))
else:
l2_loss = 0
predictions = tf.nn.softmax(logits)
softmax_cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=tf_y_batch, logits=logits)
loss = tf.reduce_mean(softmax_cross_entropy) + params.l2_lambda * l2_loss
# Optimizer.
optimizer = tf.train.AdamOptimizer(
learning_rate = learning_rate
).minimize(loss)
with tf.Session(graph = graph) as session:
session.run(tf.global_variables_initializer())
# A routine for evaluating current model parameters
def get_accuracy_and_loss_in_batches(X, y, is_test=False):
p = []
sce = []
batch_iterator = BatchIterator(batch_size = 128)
for x_batch, y_batch in batch_iterator(X, y):
[p_batch, sce_batch] = session.run([predictions, softmax_cross_entropy], feed_dict = {
tf_x_batch : x_batch,
tf_y_batch : y_batch,
is_training : False
}
)
p.extend(p_batch)
sce.extend(sce_batch)
p = np.array(p)
sce = np.array(sce)
accuracy = 100.0 * np.sum(np.argmax(p, 1) == np.argmax(y, 1)) / p.shape[0]
loss = np.mean(sce)
if is_test:
print ("test accuracy ", accuracy, " test loss ", loss)
return (accuracy, loss)
# If we chose to keep training previously trained model, restore session.
if params.resume_training:
try:
tf.train.Saver().restore(session, paths.model_path)
except Exception as e:
print("Failed restoring previously trained model: file does not exist.")
pass
saver = tf.train.Saver()
# early_stopping = EarlyStopping(tf.train.Saver(), session, patience = params.early_stopping_patience, minimize = True)
train_loss_history = np.empty([0], dtype = np.float32)
train_accuracy_history = np.empty([0], dtype = np.float32)
valid_loss_history = np.empty([0], dtype = np.float32)
valid_accuracy_history = np.empty([0], dtype = np.float32)
if params.max_epochs > 0:
print("================= TRAINING ==================")
else:
print("================== TESTING ==================")
for epoch in range(params.max_epochs):
current_epoch = epoch
print ("current epoch ", current_epoch)
# Train on whole randomised dataset in batches
batch_iterator = BatchIterator(batch_size = params.batch_size, shuffle = True)
batch_cnt=0
for x_batch, y_batch in batch_iterator(X_train, y_train):
batch_cnt+=1
# print ("batch ", batch_cnt)
session.run([optimizer], feed_dict = {
tf_x_batch : x_batch,
tf_y_batch : y_batch,
is_training : True
}
)
# If another significant epoch ended, we log our losses.
if (epoch % params.log_epoch == 0):
# Get validation data predictions and log validation loss:
valid_accuracy, valid_loss = get_accuracy_and_loss_in_batches(X_valid, y_valid)
# Get training data predictions and log training loss:
train_accuracy, train_loss = get_accuracy_and_loss_in_batches(X_train, y_train)
print ("train accuracy ", train_accuracy, " train loss ", train_loss)
print ("valid accuracy ", valid_accuracy, " valid loss ", valid_loss)
else:
valid_loss = 0.
valid_accuracy = 0.
train_loss = 0.
train_accuracy = 0.
valid_loss_history = np.append(valid_loss_history, [valid_loss])
valid_accuracy_history = np.append(valid_accuracy_history, [valid_accuracy])
train_loss_history = np.append(train_loss_history, [train_loss])
train_accuracy_history = np.append(train_accuracy_history, [train_accuracy])
# Evaluate on test dataset.
test_accuracy, test_loss = get_accuracy_and_loss_in_batches(X_test, y_test)
# valid_accuracy, valid_loss = get_accuracy_and_loss_in_batches(X_valid, y_valid)
# Save model weights for future use.
saved_model_path = saver.save(session, paths.model_path)
np.savez(paths.train_history_path, train_loss_history = train_loss_history, train_accuracy_history = train_accuracy_history, valid_loss_history = valid_loss_history, valid_accuracy_history = valid_accuracy_history)
def main():
c = color_codes()
patch_size = (15, 15, 15)
dir_name = '/home/sergivalverde/w/CNN/images/CH16'
patients = [
f for f in sorted(os.listdir(dir_name))
if os.path.isdir(os.path.join(dir_name, f))
]
names = np.stack([
name for name in
[[
os.path.join(dir_name, patient, 'FLAIR_preprocessed.nii.gz')
for patient in patients
],
[
os.path.join(dir_name, patient, 'DP_preprocessed.nii.gz')
for patient in patients
],
[
os.path.join(dir_name, patient, 'T2_preprocessed.nii.gz')
for patient in patients
],
[
os.path.join(dir_name, patient, 'T1_preprocessed.nii.gz')
for patient in patients
]] if name is not None
],
axis=1)
seed = np.random.randint(np.iinfo(np.int32).max)
''' Here we create an initial net to find conflictive voxels '''
print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +
'<Running iteration ' + c['b'] + '1>' + c['nc'])
net_name = '/home/sergivalverde/w/CNN/code/CNN1/miccai_challenge2016/deep-challenge2016.init.'
net = NeuralNet(
layers=[
(InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))),
(Conv3DDNNLayer,
dict(name='conv1_1',
num_filters=32,
filter_size=(5, 5, 5),
pad='same')),
(Pool3DDNNLayer,
dict(name='avgpool_1',
pool_size=2,
stride=2,
mode='average_inc_pad')),
(Conv3DDNNLayer,
dict(name='conv2_1',
num_filters=64,
filter_size=(5, 5, 5),
pad='same')),
(Pool3DDNNLayer,
dict(name='avgpool_2',
pool_size=2,
stride=2,
mode='average_inc_pad')),
(DropoutLayer, dict(name='l2drop', p=0.5)),
(DenseLayer, dict(name='l1', num_units=256)),
(DenseLayer,
dict(name='out', num_units=2,
nonlinearity=nonlinearities.softmax)),
],
objective_loss_function=objectives.categorical_crossentropy,
update=updates.adam,
update_learning_rate=0.0001,
on_epoch_finished=[
SaveWeights(net_name + 'model_weights.pkl',
only_best=True,
pickle=False),
SaveTrainingHistory(net_name + 'model_history.pkl'),
PlotTrainingHistory(net_name + 'training_history.png'),
EarlyStopping(patience=10)
],
verbose=10,
max_epochs=50,
train_split=TrainSplit(eval_size=0.25),
custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum(
(p + t[:, 1])))],
)
try:
net.load_params_from(net_name + 'model_weights.pkl')
except IOError:
print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +
'Loading the data for ' + c['b'] + 'iteration 1' + c['nc'])
# Create the data
(x, y, _) = load_patches(dir_name=dir_name,
use_flair=True,
use_pd=True,
use_t2=True,
use_t1=True,
use_gado=False,
flair_name='FLAIR_preprocessed.nii.gz',
pd_name='DP_preprocessed.nii.gz',
t2_name='T2_preprocessed.nii.gz',
t1_name='T1_preprocessed.nii.gz',
gado_name=None,
mask_name='Consensus.nii.gz',
size=patch_size)
print('-- Permuting the data')
np.random.seed(seed)
x_train = np.random.permutation(
np.concatenate(x).astype(dtype=np.float32))
print('-- Permuting the labels')
np.random.seed(seed)
y_train = np.random.permutation(
np.concatenate(y).astype(dtype=np.int32))
y_train = y_train[:, y_train.shape[1] / 2 + 1,
y_train.shape[2] / 2 + 1, y_train.shape[3] / 2 + 1]
print('-- Training vector shape = (' +
','.join([str(length) for length in x_train.shape]) + ')')
print('-- Training labels shape = (' +
','.join([str(length) for length in y_train.shape]) + ')')
print c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +\
'Training (' + c['b'] + 'initial' + c['nc'] + c['g'] + ')' + c['nc']
# We try to get the last weights to keep improving the net over and over
net.fit(x_train, y_train)
''' Here we get the seeds '''
print c['c'] + '[' + strftime(
"%H:%M:%S") + '] ' + c['g'] + '<Looking for seeds>' + c['nc']
for patient in names:
output_name = os.path.join('/'.join(patient[0].rsplit('/')[:-1]),
'test.iter1.nii.gz')
try:
load_nii(output_name)
print c['c'] + '[' + strftime("%H:%M:%S") + '] ' \
+ c['g'] + '-- Patient ' + patient[0].rsplit('/')[-2] + ' already done' + c['nc']
except IOError:
print c['c'] + '[' + strftime("%H:%M:%S") + '] '\
+ c['g'] + '-- Testing with patient ' + c['b'] + patient[0].rsplit('/')[-2] + c['nc']
image_nii = load_nii(patient[0])
image = np.zeros_like(image_nii.get_data())
for batch, centers in load_patch_batch(patient, 100000,
patch_size):
y_pred = net.predict_proba(batch)
[x, y, z] = np.stack(centers, axis=1)
image[x, y, z] = y_pred[:, 1]
print c['g'] + '-- Saving image ' + c['b'] + output_name + c['nc']
image_nii.get_data()[:] = image
image_nii.to_filename(output_name)
''' Here we perform the last iteration '''
print c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c[
'g'] + '<Running iteration ' + c['b'] + '2>' + c['nc']
net_name = '/home/sergivalverde/w/CNN/code/CNN1/miccai_challenge2016/deep-challenge2016.final.'
net = NeuralNet(
layers=[
(InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))),
(Conv3DDNNLayer,
dict(name='conv1_1',
num_filters=32,
filter_size=(5, 5, 5),
pad='same')),
(Pool3DDNNLayer,
dict(name='avgpool_1',
pool_size=2,
stride=2,
mode='average_inc_pad')),
(Conv3DDNNLayer,
dict(name='conv2_1',
num_filters=64,
filter_size=(5, 5, 5),
pad='same')),
(Pool3DDNNLayer,
dict(name='avgpool_2',
pool_size=2,
stride=2,
mode='average_inc_pad')),
(DropoutLayer, dict(name='l2drop', p=0.5)),
(DenseLayer, dict(name='l1', num_units=256)),
(DenseLayer,
dict(name='out', num_units=2,
nonlinearity=nonlinearities.softmax)),
],
objective_loss_function=objectives.categorical_crossentropy,
update=updates.adam,
update_learning_rate=0.0001,
on_epoch_finished=[
SaveWeights(net_name + 'model_weights.pkl',
only_best=True,
pickle=False),
SaveTrainingHistory(net_name + 'model_history.pkl'),
PlotTrainingHistory(net_name + 'training_history.png'),
],
batch_iterator_train=BatchIterator(batch_size=4096),
verbose=10,
max_epochs=2000,
train_split=TrainSplit(eval_size=0.25),
custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum(
(p + t[:, 1])))],
)
try:
net.load_params_from(net_name + 'model_weights.pkl')
except IOError:
pass
print c['c'] + '[' + strftime("%H:%M:%S") + '] '\
+ c['g'] + 'Loading the data for ' + c['b'] + 'iteration 2' + c['nc']
(x, y,
names) = load_patches(dir_name='/home/sergivalverde/w/CNN/images/CH16',
use_flair=True,
use_pd=True,
use_t2=True,
use_t1=True,
use_gado=False,
flair_name='FLAIR_preprocessed.nii.gz',
pd_name='DP_preprocessed.nii.gz',
t2_name='T2_preprocessed.nii.gz',
gado_name=None,
t1_name='T1_preprocessed.nii.gz',
mask_name='Consensus.nii.gz',
size=patch_size,
roi_name='test.iter1.nii.gz')
print '-- Permuting the data'
np.random.seed(seed)
x_train = np.random.permutation(np.concatenate(x).astype(dtype=np.float32))
print '-- Permuting the labels'
np.random.seed(seed)
y_train = np.random.permutation(np.concatenate(y).astype(dtype=np.int32))
y_train = y_train[:, y_train.shape[1] / 2 + 1, y_train.shape[2] / 2 + 1,
y_train.shape[3] / 2 + 1]
print '-- Training vector shape = (' + ','.join(
[str(length) for length in x_train.shape]) + ')'
print '-- Training labels shape = (' + ','.join(
[str(length) for length in y_train.shape]) + ')'
print c['c'] + '[' + strftime("%H:%M:%S") + '] '\
+ c['g'] + 'Training (' + c['b'] + 'final' + c['nc'] + c['g'] + ')' + c['nc']
net.fit(x_train, y_train)
def gen_BatchIterator(self, batch_size=100, shuffle=True):
"""Generate the batch iterator"""
B = BatchIterator(batch_size=batch_size, shuffle=shuffle)
return B
def __init__(self, batch_size = 128):
BatchIterator.__init__(self, batch_size)
def test_shuffle_no_copy(self, BatchIterator, X, y):
bi = BatchIterator(2, shuffle=True)(X, y)
X0, y0 = list(bi)[0]
assert X0.base is X # make sure X0 is a view
def test():
if not args.no_predict_test:
print "Reading in the test files before starting the loop"
preprocess_test_data()
print("Validating...")
for ch in range(args.no_channels):
print 'Prediction for channel', ch
print "Changing batch iterator test:"
from batch_iterators import BI_test_sch_sch
netSpec.batch_iterator_test = BI_test_sch_sch(batch_size=256,channel=ch)
if include_userdata:
prediction = predict(netSpec, {'sensors':xVal,'user':udVal})
probabilities = netSpec.predict_proba({'sensors':xVal,'user':udVal})
print "probabilities.shape", probabilities.shape
else:
prediction = predict(netSpec, xVal)
print "xVal.shape", xVal.shape
probabilities = netSpec.predict_proba(xVal)
print "probabilities.shape", probabilities.shape
print("Showing last 30 test samples..")
print("Predictions:")
print(prediction[-30:])
print("Ground Truth:")
print(yVal[-30:])
print("Performance on relevant data")
print 'yVal.shape', yVal.shape
print 'prediction.shape', prediction.shape
result = yVal==prediction
faults = yVal!=prediction
acc_val = float(np.sum(result))/float(len(result))
print "Accuracy validation: ", acc_val
print "Error rate (%): ", 100*(1-acc_val)
#print np.nonzero(faults)
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(yVal,prediction)
print cm
from sklearn.metrics import roc_auc_score,log_loss
print "roc_auc:", roc_auc_score(yVal, probabilities[:,1])
print "log_loss:", log_loss(yVal, probabilities[:,1])
print "Changing batch iterator test:"
from nolearn.lasagne import BatchIterator
netSpec.batch_iterator_test = BatchIterator(batch_size=256)
print "Calculating final prediction for the hour long sessions"
print "magnitudes_normal_val.shape", g.magnitudes_normal_val.shape
probabilities_hour = []
for mag_hour in g.magnitudes_normal_val:
m_hour = mag_hour[ch]
patches = rolling_window_ext(m_hour,(magnitude_window,ceil-floor))
predictions_patches = netSpec.predict_proba(patches)
prediction_hour = np.sum(predictions_patches,axis=0)/predictions_patches.shape[0]
probabilities_hour.append(prediction_hour[1])
print "magnitudes_seizure_val.shape", g.magnitudes_seizure_val.shape
for mag_hour in g.magnitudes_seizure_val:
m_hour = mag_hour[ch]
patches = rolling_window_ext(m_hour,(magnitude_window,ceil-floor))
predictions_patches = netSpec.predict_proba(patches)
prediction_hour = np.sum(predictions_patches,axis=0)/predictions_patches.shape[0]
probabilities_hour.append(prediction_hour[1])
yVal_hour = np.hstack((np.zeros(g.magnitudes_normal_val.shape[0]),np.ones(g.magnitudes_seizure_val.shape[0])))
print "roc_auc for the hours:", roc_auc_score(yVal_hour, probabilities_hour)
print "log_loss for the hours:", log_loss(yVal_hour, probabilities_hour)
print "saving predictions to csv file"
patient_str = '-'.join(args.patients)
csv_filename = 'hours'+patient_str+'_'+cfg['training']['model']+'_'+datetime.now().strftime("%m-%d-%H-%M-%S")+'.csv'
print csv_filename
csv=open('./results/'+csv_filename, 'w+')
for i in range(yVal_hour.shape[0]):
csv.write(str(yVal_hour[i])+','+str(probabilities_hour[i])+'\n')
csv.close
predictions_hour = np.round(probabilities_hour)
result_hour = yVal_hour==predictions_hour
acc_val_hour = float(np.sum(result_hour))/float(len(result_hour))
print "Accuracy validation for the hours: ", acc_val_hour
if not args.no_predict_test:
print "Calculating the predictions for the test files"
probabilities_test = []
for mag_test in magnitudes_test:
m_test = mag_test[ch]
patches = rolling_window_ext(m_test,(magnitude_window,ceil-floor))
predictions_patches = netSpec.predict_proba(patches)
prediction_hour = np.sum(predictions_patches,axis=0)/predictions_patches.shape[0]
probabilities_test.append(prediction_hour[1])
print "saving predictions to csv file"
csv_filename = patient_str+'_'+str(ch)+'_'+cfg['training']['model']+'_'+datetime.now().strftime("%m-%d-%H-%M-%S")+'.csv'
print csv_filename
csv=open('./results/'+csv_filename, 'w+')
counter = 0
for dataset in datasets.all:
if dataset.enabled and not dataset.trainset:
for i in range(int(dataset.no_files * args.debug_sub_ratio)):
filename = dataset.base_name+str(i+1)+'.mat'
csv.write(filename+','+str(probabilities_test[counter+i])+'\n')
csv.close
