def build_model(input_layer=None):
#################
# Regular model #
#################
l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"])
l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"])
# Add an axis to concatenate over later
l_4chr = nn.layers.ReshapeLayer(l_4ch, (
-1,
1,
) + l_4ch.output_shape[1:])
l_2chr = nn.layers.ReshapeLayer(l_2ch, (
-1,
1,
) + l_2ch.output_shape[1:])
# Cut the images in half, flip the left ones
l_4ch_left = nn.layers.SliceLayer(l_4ch,
indices=slice(image_size // 2 - 1, None,
-1),
axis=-1)
l_4ch_right = nn.layers.SliceLayer(l_4ch,
indices=slice(image_size // 2, None, 1),
axis=-1)
l_2ch_left = nn.layers.SliceLayer(l_2ch,
indices=slice(image_size // 2 - 1, None,
-1),
axis=-1)
l_2ch_right = nn.layers.SliceLayer(l_2ch,
indices=slice(image_size // 2, None, 1),
axis=-1)
# Concatenate over second axis
l_24lr = nn.layers.ConcatLayer(
[l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1)
# Move second axis to batch, process them all in the same way
l_halves = nn.layers.ReshapeLayer(
l_24lr, (-1, nr_frames, image_size, image_size // 2))
# First, do some convolutions in all directions
l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(1, 2), stride=(1, 2))
# Then, only use the last axis
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(1, 2), stride=(1, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(1, 2), stride=(1, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(1, 2), stride=(1, 2))
# Now, process each row seperately, by flipping the channel and height axis, and then putting height in the batch
l4shuffle = nn.layers.DimshuffleLayer(l4, pattern=(0, 2, 1, 3))
l4rows = nn.layers.ReshapeLayer(
l4shuffle,
(-1, l4shuffle.output_shape[-2], l4shuffle.output_shape[-1]))
# Systole
ldsys1 = nn.layers.DenseLayer(l4rows,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys2drop = nn.layers.dropout(ldsys2, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(16.0),
nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(4.0),
nonlinearity=lb_softplus(.01))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_24lr_sys_musigma = nn.layers.ReshapeLayer(ldsys3musigma,
(-1, 4, image_size, 2))
l_4ch_left_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma,
indices=0,
axis=1)
l_4ch_right_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma,
indices=1,
axis=1)
l_2ch_left_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma,
indices=2,
axis=1)
l_2ch_right_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma,
indices=3,
axis=1)
l_4ch_sys_musigma = layers.SumGaussLayer(
[l_4ch_left_sys_musigma, l_4ch_right_sys_musigma])
l_2ch_sys_musigma = layers.SumGaussLayer(
[l_2ch_left_sys_musigma, l_2ch_right_sys_musigma])
l_sys_musigma = layers.IraLayerNoTime(l_4ch_sys_musigma, l_2ch_sys_musigma)
l_systole = layers.MuSigmaErfLayer(l_sys_musigma)
# Systole
lddia1 = nn.layers.DenseLayer(l4rows,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia2drop = nn.layers.dropout(lddia2, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(16.0),
nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(4.0),
nonlinearity=lb_softplus(.01))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_24lr_dia_musigma = nn.layers.ReshapeLayer(lddia3musigma,
(-1, 4, image_size, 2))
l_4ch_left_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma,
indices=0,
axis=1)
l_4ch_right_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma,
indices=1,
axis=1)
l_2ch_left_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma,
indices=2,
axis=1)
l_2ch_right_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma,
indices=3,
axis=1)
l_4ch_dia_musigma = layers.SumGaussLayer(
[l_4ch_left_dia_musigma, l_4ch_right_dia_musigma])
l_2ch_dia_musigma = layers.SumGaussLayer(
[l_2ch_left_dia_musigma, l_2ch_right_dia_musigma])
l_dia_musigma = layers.IraLayerNoTime(l_4ch_dia_musigma, l_2ch_dia_musigma)
l_diastole = layers.MuSigmaErfLayer(l_dia_musigma)
return {
"inputs": {
"sliced:data:chanzoom:4ch": l_4ch,
"sliced:data:chanzoom:2ch": l_2ch,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {},
"meta_outputs": {}
}
def build_model(input_layer=None):
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice"]
if input_layer:
l0 = input_layer
else:
l0 = nn.layers.InputLayer(input_size)
l0c = dihedral.CyclicSliceLayer(l0)
l1a = nn.layers.dnn.Conv2DDNNLayer(
l0c,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(
l1a,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l1r = dihedral_fast.CyclicConvRollLayer(l1)
l2a = nn.layers.dnn.Conv2DDNNLayer(
l1r,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(
l2a,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l2r = dihedral_fast.CyclicConvRollLayer(l2)
l3a = nn.layers.dnn.Conv2DDNNLayer(
l2r,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(
l3a,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(
l3b,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l3r = dihedral_fast.CyclicConvRollLayer(l3)
l4a = nn.layers.dnn.Conv2DDNNLayer(
l3r,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(
l4a,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(
l4b,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
l4r = dihedral_fast.CyclicConvRollLayer(l4)
l5a = nn.layers.dnn.Conv2DDNNLayer(
l4r,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(
l5a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(
l5b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.very_leaky_rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2, 2), stride=(2, 2))
l5r = dihedral_fast.CyclicConvRollLayer(l5)
l5f = nn.layers.FlattenLayer(l5r)
l5m = dihedral.CyclicPoolLayer(l5f, pool_function=rms)
# l5drop = nn.layers.dropout(l5m, p=0.5)
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(
l5m,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.very_leaky_rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(
ldsys1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.very_leaky_rectify)
ldsys2drop = nn.layers.dropout(ldsys2, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(
l5m,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.very_leaky_rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(
lddia1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.very_leaky_rectify)
lddia2drop = nn.layers.dropout(lddia2, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
return {
"inputs": {
"sliced:data:singleslice": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,
},
"meta_outputs": {
"systole": ldsys2,
"diastole": lddia2,
}
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:sax"]
input_size_mask = data_sizes["sliced:data:sax:is_not_padded"]
input_size_locations = data_sizes["sliced:data:sax:locations"]
l0 = nn.layers.InputLayer(input_size)
lin_slice_mask = nn.layers.InputLayer(input_size_mask)
lin_slice_locations = nn.layers.InputLayer(input_size_locations)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers and some dense layers are defined in a submodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
import je_ss_jonisc80_leaky_convroll_augzoombright
submodel = je_ss_jonisc80_leaky_convroll_augzoombright.build_model(
l0_slices)
# Systole Dense layers
l_sys_mu = submodel["meta_outputs"]["systole:mu"]
l_sys_sigma = submodel["meta_outputs"]["systole:sigma"]
# Diastole Dense layers
l_dia_mu = submodel["meta_outputs"]["diastole:mu"]
l_dia_sigma = submodel["meta_outputs"]["diastole:sigma"]
# AGGREGATE SLICES PER PATIENT
l_scaled_slice_locations = layers.TrainableScaleLayer(
lin_slice_locations, scale=nn.init.Constant(0.1), trainable=False)
# Systole
l_pat_sys_ss_mu = nn.layers.ReshapeLayer(l_sys_mu, (-1, nr_slices))
l_pat_sys_ss_sigma = nn.layers.ReshapeLayer(l_sys_sigma, (-1, nr_slices))
l_pat_sys_aggr_mu_sigma = layers.JeroenLayer([
l_pat_sys_ss_mu, l_pat_sys_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=100.)
l_systole = layers.MuSigmaErfLayer(l_pat_sys_aggr_mu_sigma)
# Diastole
l_pat_dia_ss_mu = nn.layers.ReshapeLayer(l_dia_mu, (-1, nr_slices))
l_pat_dia_ss_sigma = nn.layers.ReshapeLayer(l_dia_sigma, (-1, nr_slices))
l_pat_dia_aggr_mu_sigma = layers.JeroenLayer([
l_pat_dia_ss_mu, l_pat_dia_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=100.)
l_diastole = layers.MuSigmaErfLayer(l_pat_dia_aggr_mu_sigma)
submodels = [submodel]
return {
"inputs": {
"sliced:data:sax": l0,
"sliced:data:sax:is_not_padded": lin_slice_mask,
"sliced:data:sax:locations": lin_slice_locations,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable":
dict({}, **{
k: v
for d in [
model["regularizable"] for model in submodels
if "regularizable" in model
] for k, v in d.items()
}),
"pretrained": {
je_ss_jonisc80_leaky_convroll_augzoombright.__name__:
submodel["outputs"],
}
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:sax"]
input_size_mask = data_sizes["sliced:data:sax:is_not_padded"]
input_size_locations = data_sizes["sliced:data:sax:locations"]
l0 = nn.layers.InputLayer(input_size)
lin_slice_mask = nn.layers.InputLayer(input_size_mask)
lin_slice_locations = nn.layers.InputLayer(input_size_locations)
# PREPROCESS SLICES SEPERATELY
l0_slices = nn.layers.ReshapeLayer(l0, (batch_size * nr_slices, 30, patch_px, patch_px)) # (bxs, t, i, j)
subsample_factor = 2
l0_slices_subsampled = nn.layers.SliceLayer(l0_slices, axis=1, indices=slice(0, 30, subsample_factor))
nr_frames_subsampled = 30 / subsample_factor
# PREPROCESS FRAMES SEPERATELY
l0_frames = nn.layers.ReshapeLayer(l0_slices_subsampled, (batch_size * nr_slices * nr_frames_subsampled, 1, patch_px, patch_px)) # (bxsxt, 1, i, j)
l1a = nn.layers.dnn.Conv2DDNNLayer(l0_frames, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=16, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=16, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1c = nn.layers.dnn.Conv2DDNNLayer(l1b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=16, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1c, pool_size=(2,2), stride=(2,2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=32, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=32, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2c = nn.layers.dnn.Conv2DDNNLayer(l2b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=32, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2c, pool_size=(2,2), stride=(2,2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3d = nn.layers.dnn.Conv2DDNNLayer(l3c, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3d, pool_size=(2,2), stride=(2,2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4d = nn.layers.dnn.Conv2DDNNLayer(l4c, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4d, pool_size=(2,2), stride=(2,2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5d = nn.layers.dnn.Conv2DDNNLayer(l5c, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5d, pool_size=(2,2), stride=(2,2))
l5drop = nn.layers.dropout(l5, p=0.5)
ld1 = nn.layers.DenseLayer(l5drop, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
ld1drop = nn.layers.dropout(ld1, p=0.5)
ld2 = nn.layers.DenseLayer(ld1drop, num_units=256, W=nn.init.Orthogonal("relu"),b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
ld2drop = nn.layers.dropout(ld2, p=0.5)
ld3mu = nn.layers.DenseLayer(ld2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(15.0), nonlinearity=None)
ld3sigma = nn.layers.DenseLayer(ld2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(5.0), nonlinearity=lb_softplus(.3))
ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1)
# Go back to a per slice model
l_slices_musigma = nn.layers.ReshapeLayer(ld3musigma, (batch_size * nr_slices, nr_frames_subsampled, 2)) # (bxs, t, 2)
l_slices_musigma_sys = layers.ArgmaxAndMaxLayer(l_slices_musigma, mode='min') # (bxs, 2)
l_slices_musigma_dia = layers.ArgmaxAndMaxLayer(l_slices_musigma, mode='max') # (bxs, 2)
# AGGREGATE SLICES PER PATIENT
l_scaled_slice_locations = layers.TrainableScaleLayer(lin_slice_locations, scale=nn.init.Constant(0.1), trainable=False)
# Systole
l_pat_sys_ss_musigma = nn.layers.ReshapeLayer(l_slices_musigma_sys, (batch_size, nr_slices, 2))
l_pat_sys_ss_mu = nn.layers.SliceLayer(l_pat_sys_ss_musigma, indices=0, axis=-1)
l_pat_sys_ss_sigma = nn.layers.SliceLayer(l_pat_sys_ss_musigma, indices=1, axis=-1)
l_pat_sys_aggr_mu_sigma = layers.JeroenLayer([l_pat_sys_ss_mu, l_pat_sys_ss_sigma, lin_slice_mask, l_scaled_slice_locations], rescale_input=1.)
l_systole = layers.MuSigmaErfLayer(l_pat_sys_aggr_mu_sigma)
# Diastole
l_pat_dia_ss_musigma = nn.layers.ReshapeLayer(l_slices_musigma_dia, (batch_size, nr_slices, 2))
l_pat_dia_ss_mu = nn.layers.SliceLayer(l_pat_dia_ss_musigma, indices=0, axis=-1)
l_pat_dia_ss_sigma = nn.layers.SliceLayer(l_pat_dia_ss_musigma, indices=1, axis=-1)
l_pat_dia_aggr_mu_sigma = layers.JeroenLayer([l_pat_dia_ss_mu, l_pat_dia_ss_sigma, lin_slice_mask, l_scaled_slice_locations], rescale_input=1.)
l_diastole = layers.MuSigmaErfLayer(l_pat_dia_aggr_mu_sigma)
return {
"inputs":{
"sliced:data:sax": l0,
"sliced:data:sax:is_not_padded": lin_slice_mask,
"sliced:data:sax:locations": lin_slice_locations,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
},
}
def build_model(input_layer=None):
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice"]
if input_layer:
l0 = input_layer
else:
l0 = nn.layers.InputLayer(input_size)
# Reshape to framemodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, 1, [2], [3]))
l1a = nn.layers.dnn.Conv2DDNNLayer(l0_slices,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2, 2), stride=(2, 2))
l5drop = nn.layers.dropout(l5, p=0.0)
ld1 = nn.layers.DenseLayer(l5drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld1drop = nn.layers.dropout(ld1, p=0.0)
ld2 = nn.layers.DenseLayer(ld1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld2drop = nn.layers.dropout(ld2, p=0.0)
ld3mu = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ld3sigma = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(50.0),
nonlinearity=lb_softplus(3))
ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1)
# Reshape back to slicemodel
ld3musigma_slices = nn.layers.ReshapeLayer(ld3musigma, (-1, NR_FRAMES, 2))
l_systole_musigma = layers.ArgmaxAndMaxLayer(ld3musigma_slices, 'min')
l_systole = layers.MuSigmaErfLayer(l_systole_musigma)
l_diastole_musigma = layers.ArgmaxAndMaxLayer(ld3musigma_slices, 'max')
l_diastole = layers.MuSigmaErfLayer(l_diastole_musigma)
return {
"inputs": {
"sliced:data:singleslice": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ld1: l2_weight,
ld2: l2_weight,
ld3mu: l2_weight_out,
ld3musigma: l2_weight_out,
}
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:randomslices"]
l0 = nn.layers.InputLayer(input_size)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers and some dense layers are defined in a submodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
import je_ss_jonisc64small_360
submodel = je_ss_jonisc64small_360.build_model(l0_slices)
# Systole Dense layers
ldsys2 = submodel["meta_outputs"]["systole"]
# Diastole Dense layers
lddia2 = submodel["meta_outputs"]["diastole"]
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsys2, (-1, nr_slices, [1]))
input_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal())
forget_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal(),
b=nn.init.Constant(5.0))
output_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal())
cell_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal(),
W_cell=None,
nonlinearity=nn.nonlinearities.tanh)
ldsys_lstm = nn.layers.LSTMLayer(
ldsys_pat_in,
num_units=256,
ingate=input_gate_sys,
forgetgate=forget_gate_sys,
cell=cell_sys,
outgate=output_gate_sys,
peepholes=False,
precompute_input=False,
grad_clipping=5,
only_return_final=True,
learn_init=True,
)
ldsys_lstm_drop = nn.layers.dropout(ldsys_lstm, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddia2, (-1, nr_slices, [1]))
input_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal())
forget_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal(),
b=nn.init.Constant(5.0))
output_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal())
cell_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(),
W_hid=nn.init.Orthogonal(),
W_cell=None,
nonlinearity=nn.nonlinearities.tanh)
lddia_lstm = nn.layers.LSTMLayer(
lddia_pat_in,
num_units=256,
ingate=input_gate_dia,
forgetgate=forget_gate_dia,
cell=cell_dia,
outgate=output_gate_dia,
peepholes=False,
precompute_input=False,
grad_clipping=5,
only_return_final=True,
learn_init=True,
)
lddia_lstm_drop = nn.layers.dropout(lddia_lstm, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
submodels = [submodel]
return {
"inputs": {
"sliced:data:randomslices": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable":
dict(
{
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,
}, **{
k: v
for d in [
model["regularizable"] for model in submodels
if "regularizable" in model
] for k, v in d.items()
}),
"pretrained": {
je_ss_jonisc64small_360.__name__: submodel["outputs"],
}
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice"]
l0 = nn.layers.InputLayer(input_size)
l1a = nn.layers.dnn.Conv2DDNNLayer(l0,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(l4,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys2drop = nn.layers.dropout(ldsys2, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(50.0),
nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(l4,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia2drop = nn.layers.dropout(lddia2, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(50.0),
nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
return {
"inputs": {
"sliced:data:singleslice": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,
},
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:sax"]
input_size_mask = data_sizes["sliced:data:sax:is_not_padded"]
input_size_locations = data_sizes["sliced:data:sax:locations"]
l0 = nn.layers.InputLayer(input_size)
lin_slice_mask = nn.layers.InputLayer(input_size_mask)
lin_slice_locations = nn.layers.InputLayer(input_size_locations)
# PREPROCESS SLICES SEPERATELY
l0_slices = nn.layers.ReshapeLayer(
l0, (batch_size * nr_slices, 30, patch_px, patch_px)) # (bxs, t, i, j)
subsample_factor = 2
l0_slices_subsampled = nn.layers.SliceLayer(l0_slices,
axis=1,
indices=slice(
0, 30, subsample_factor))
nr_frames_subsampled = 30 / subsample_factor
# PREPROCESS FRAMES SEPERATELY
l0_frames = nn.layers.ReshapeLayer(
l0_slices_subsampled, (batch_size * nr_slices * nr_frames_subsampled,
1, patch_px, patch_px)) # (bxsxt, 1, i, j)
# downsample
downsample = lambda incoming: nn.layers.dnn.Pool2DDNNLayer(
incoming, pool_size=(2, 2), stride=(2, 2), mode='average_inc_pad')
upsample = lambda incoming: nn.layers.Upscale2DLayer(incoming,
scale_factor=2)
l0_frames_d0 = l0_frames
l0_frames_d1 = downsample(l0_frames_d0)
l0_frames_d2 = downsample(l0_frames_d1)
l0_frames_d3 = downsample(l0_frames_d2)
ld3a = nn.layers.dnn.Conv2DDNNLayer(l0_frames_d3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld3b = nn.layers.dnn.Conv2DDNNLayer(ld3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld3c = nn.layers.dnn.Conv2DDNNLayer(ld3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld3o = nn.layers.dnn.Conv2DDNNLayer(ld3c,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld2i = nn.layers.ConcatLayer([l0_frames_d2, upsample(ld3o)], axis=1)
ld2a = nn.layers.dnn.Conv2DDNNLayer(ld2i,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld2b = nn.layers.dnn.Conv2DDNNLayer(ld2a,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld2c = nn.layers.dnn.Conv2DDNNLayer(ld2b,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld2d = nn.layers.dnn.Conv2DDNNLayer(ld2c,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld2o = nn.layers.dnn.Conv2DDNNLayer(ld2d,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld1i = nn.layers.ConcatLayer([l0_frames_d1, upsample(ld2o)], axis=1)
ld1a = nn.layers.dnn.Conv2DDNNLayer(ld1i,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld1b = nn.layers.dnn.Conv2DDNNLayer(ld1a,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld1c = nn.layers.dnn.Conv2DDNNLayer(ld1b,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld1d = nn.layers.dnn.Conv2DDNNLayer(ld1c,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld1o = nn.layers.dnn.Conv2DDNNLayer(ld1d,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld0i = nn.layers.ConcatLayer([l0_frames_d0, upsample(ld1o)], axis=1)
ld0a = nn.layers.dnn.Conv2DDNNLayer(ld0i,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld0b = nn.layers.dnn.Conv2DDNNLayer(ld0a,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld0c = nn.layers.dnn.Conv2DDNNLayer(ld0b,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld0d = nn.layers.dnn.Conv2DDNNLayer(ld0c,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
ld0o = nn.layers.dnn.Conv2DDNNLayer(ld0d,
W=nn.init.Orthogonal("relu"),
filter_size=(5, 5),
num_filters=1,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.sigmoid)
ld0r = nn.layers.ReshapeLayer(
ld0o,
(batch_size * nr_slices * nr_frames_subsampled, patch_px, patch_px))
l_frames_musigma = layers.IntegrateAreaLayer(ld0r,
sigma_mode='scale',
sigma_scale=.1)
area_per_pixel_cm = (float(patch_mm) / float(patch_px))**2 / 100.0
l_frames_musigma_cm = layers.TrainableScaleLayer(
l_frames_musigma,
scale=nn.init.Constant(area_per_pixel_cm),
trainable=False)
# Go back to a per slice model
l_slices_musigma_cm = nn.layers.ReshapeLayer(
l_frames_musigma_cm,
(batch_size * nr_slices, nr_frames_subsampled, 2)) # (bxs, t, 2)
l_slices_musigma_cm_sys = layers.ArgmaxAndMaxLayer(l_slices_musigma_cm,
mode='min') # (bxs, 2)
l_slices_musigma_cm_dia = layers.ArgmaxAndMaxLayer(l_slices_musigma_cm,
mode='max') # (bxs, 2)
l_slices_musigma_cm_avg = layers.ArgmaxAndMaxLayer(l_slices_musigma_cm,
mode='mean')
# AGGREGATE SLICES PER PATIENT
l_scaled_slice_locations = layers.TrainableScaleLayer(
lin_slice_locations, scale=nn.init.Constant(0.1), trainable=False)
# Systole
l_pat_sys_ss_musigma_cm = nn.layers.ReshapeLayer(
l_slices_musigma_cm_sys, (batch_size, nr_slices, 2))
l_pat_sys_ss_mu_cm = nn.layers.SliceLayer(l_pat_sys_ss_musigma_cm,
indices=0,
axis=-1)
l_pat_sys_ss_sigma_cm = nn.layers.SliceLayer(l_pat_sys_ss_musigma_cm,
indices=1,
axis=-1)
l_pat_sys_ss_sigma_cm = nn.layers.TrainableScaleLayer(
l_pat_sys_ss_sigma_cm)
l_pat_sys_aggr_mu_sigma = layers.JeroenLayer([
l_pat_sys_ss_mu_cm, l_pat_sys_ss_sigma_cm, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=1.)
l_systole = layers.MuSigmaErfLayer(l_pat_sys_aggr_mu_sigma)
# Diastole
l_pat_dia_ss_musigma_cm = nn.layers.ReshapeLayer(
l_slices_musigma_cm_dia, (batch_size, nr_slices, 2))
l_pat_dia_ss_mu_cm = nn.layers.SliceLayer(l_pat_dia_ss_musigma_cm,
indices=0,
axis=-1)
l_pat_dia_ss_sigma_cm = nn.layers.SliceLayer(l_pat_dia_ss_musigma_cm,
indices=1,
axis=-1)
l_pat_dia_ss_sigma_cm = nn.layers.TrainableScaleLayer(
l_pat_dia_ss_sigma_cm)
l_pat_dia_aggr_mu_sigma = layers.JeroenLayer([
l_pat_dia_ss_mu_cm, l_pat_dia_ss_sigma_cm, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=1.)
l_diastole = layers.MuSigmaErfLayer(l_pat_dia_aggr_mu_sigma)
# Average
l_pat_avg_ss_musigma_cm = nn.layers.ReshapeLayer(
l_slices_musigma_cm_avg, (batch_size, nr_slices, 2))
l_pat_avg_ss_mu_cm = nn.layers.SliceLayer(l_pat_avg_ss_musigma_cm,
indices=0,
axis=-1)
l_pat_avg_ss_sigma_cm = nn.layers.SliceLayer(l_pat_avg_ss_musigma_cm,
indices=1,
axis=-1)
l_pat_avg_aggr_mu_sigma = layers.JeroenLayer([
l_pat_avg_ss_mu_cm, l_pat_avg_ss_sigma_cm, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=1.)
l_mean = layers.MuSigmaErfLayer(l_pat_avg_aggr_mu_sigma)
return {
"inputs": {
"sliced:data:sax": l0,
"sliced:data:sax:is_not_padded": lin_slice_mask,
"sliced:data:sax:locations": lin_slice_locations,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
"average": l_mean,
},
"regularizable": {},
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:randomslices"]
l0 = nn.layers.InputLayer(input_size)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers
batch_norm = nn.layers.normalization.batch_norm
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
l1a = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l0_slices,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l1b = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l2a = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l2b = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l3a = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l3b = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l3c = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l4a = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l4b = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l4c = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
l5a = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l4,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l5b = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l5a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l5c = batch_norm(
nn.layers.dnn.Conv2DDNNLayer(l5b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify))
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2, 2), stride=(2, 2))
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(l5,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(l5,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsys2, (-1, nr_slices, [1]))
ldsys_lstm = rnn_layer(ldsys_pat_in, num_units=256)
ldsys_lstm_drop = nn.layers.dropout(ldsys_lstm, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddia2, (-1, nr_slices, [1]))
lddia_lstm = rnn_layer(lddia_pat_in, num_units=256)
lddia_lstm_drop = nn.layers.dropout(lddia_lstm, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia_lstm_drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(100.0),
nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
return {
"inputs": {
"sliced:data:randomslices": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,
},
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:randomslices"]
l0 = nn.layers.InputLayer(input_size)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers and some dense layers are defined in a submodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
from . import je_ss_jonisc64small_360
submodel = je_ss_jonisc64small_360.build_model(l0_slices)
# Systole Dense layers
ldsys2 = submodel["meta_outputs"]["systole"]
# Diastole Dense layers
lddia2 = submodel["meta_outputs"]["diastole"]
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsys2, (-1, nr_slices, [1]))
ldsys_rnn = rnn_layer(ldsys_pat_in, num_units=256)
# ldsys_rnn_drop = nn.layers.dropout(ldsys_rnn, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(200.0), nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(100.0), nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddia2, (-1, nr_slices, [1]))
lddia_rnn = rnn_layer(lddia_pat_in, num_units=256)
# lddia_rnn_drop = nn.layers.dropout(lddia_rnn, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(200.0), nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(100.0), nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
submodels = [submodel]
return {
"inputs":{
"sliced:data:randomslices": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": dict(
{
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,},
**{
k: v
for d in [model["regularizable"] for model in submodels if "regularizable" in model]
for k, v in list(d.items()) }
),
# "pretrained":{
# je_ss_jonisc64small_360.__name__: submodel["outputs"],
# }
}
def build_model(input_layer=None):
#################
# Regular model #
#################
l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"])
l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"])
# Add an axis to concatenate over later
l_4chr = nn.layers.ReshapeLayer(l_4ch, (
batch_size,
1,
) + l_4ch.output_shape[1:])
l_2chr = nn.layers.ReshapeLayer(l_2ch, (
batch_size,
1,
) + l_2ch.output_shape[1:])
# Cut the images in half, flip the left ones
l_4ch_left = nn.layers.SliceLayer(l_4chr,
indices=slice(image_size // 2 - 1, None,
-1),
axis=-1)
l_4ch_right = nn.layers.SliceLayer(l_4chr,
indices=slice(image_size // 2, None, 1),
axis=-1)
l_2ch_left = nn.layers.SliceLayer(l_2chr,
indices=slice(image_size // 2 - 1, None,
-1),
axis=-1)
l_2ch_right = nn.layers.SliceLayer(l_2chr,
indices=slice(image_size // 2, None, 1),
axis=-1)
# Concatenate over second axis
l_24lr = nn.layers.ConcatLayer(
[l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1)
# b, 4, t, h, w
# Subsample frames
SUBSAMPLING_FACTOR = 2
nr_subsampled_frames = nr_frames // SUBSAMPLING_FACTOR
l_24lr_ss = nn.layers.SliceLayer(l_24lr,
indices=slice(None, None,
SUBSAMPLING_FACTOR),
axis=2)
# Move frames and halves to batch, process them all in the same way, add channel axis
l_halves = nn.layers.ReshapeLayer(l_24lr_ss,
(batch_size * 4 * nr_subsampled_frames,
1, image_size, image_size // 2))
# First, do some convolutions in all directions
l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(1, 2), stride=(1, 2))
# Then, only use the last axis
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(1, 2), stride=(1, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(1, 2), stride=(1, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(1, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(1, 2), stride=(1, 2))
# Now, process each row seperately, by flipping the channel and height axis, and then putting height in the batch
l4shuffle = nn.layers.DimshuffleLayer(l4, pattern=(0, 2, 1, 3))
l4rows = nn.layers.ReshapeLayer(
l4shuffle, (batch_size * 4 * nr_subsampled_frames * image_size,
l4shuffle.output_shape[-2], l4shuffle.output_shape[-1]))
# Systole
ld1 = nn.layers.DenseLayer(l4rows,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld1drop = nn.layers.dropout(ld1, p=0.5)
ld2 = nn.layers.DenseLayer(ld1drop,
num_units=256,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld2drop = nn.layers.dropout(ld2, p=0.5)
ld3mu = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(16.0),
nonlinearity=None)
ld3sigma = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(4.0),
nonlinearity=lb_softplus(.01))
ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1)
# Get the four halves back
l_24lr_musigma = nn.layers.ReshapeLayer(
ld3musigma, (batch_size, 4, nr_subsampled_frames, image_size, 2))
l_24lr_musigma_shuffle = nn.layers.DimshuffleLayer(l_24lr_musigma,
pattern=(0, 2, 1, 3, 4))
l_24lr_musigma_re = nn.layers.ReshapeLayer(
l_24lr_musigma_shuffle,
(batch_size * nr_subsampled_frames, 4, image_size, 2))
l_4ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re,
indices=0,
axis=1)
l_4ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re,
indices=1,
axis=1)
l_2ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re,
indices=2,
axis=1)
l_2ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re,
indices=3,
axis=1)
l_4ch_musigma = layers.SumGaussLayer(
[l_4ch_left_musigma, l_4ch_right_musigma])
l_2ch_musigma = layers.SumGaussLayer(
[l_2ch_left_musigma, l_2ch_right_musigma])
l_musigma_frames = layers.IraLayerNoTime(l_4ch_musigma, l_2ch_musigma)
# Minmax over time
print l_musigma_frames.output_shape
l_musigmas = nn.layers.ReshapeLayer(l_musigma_frames,
(-1, nr_subsampled_frames, 2))
l_musigma_sys = layers.ArgmaxAndMaxLayer(l_musigmas, mode='min')
l_musigma_dia = layers.ArgmaxAndMaxLayer(l_musigmas, mode='max')
l_systole = layers.MuSigmaErfLayer(l_musigma_sys)
l_diastole = layers.MuSigmaErfLayer(l_musigma_dia)
return {
"inputs": {
"sliced:data:chanzoom:4ch": l_4ch,
"sliced:data:chanzoom:2ch": l_2ch,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {},
"meta_outputs": {}
}
def build_model(input_layer=None):
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice"]
if input_layer:
l0 = input_layer
else:
l0 = nn.layers.InputLayer(input_size)
# Subsample frames
subsample_factor = 2
l0_slices_subsampled = nn.layers.SliceLayer(l0,
axis=1,
indices=slice(
0, NR_FRAMES,
subsample_factor))
nr_frames_subsampled = NR_FRAMES / subsample_factor
# Reshape to framemodel
l0_frames = nn.layers.ReshapeLayer(l0_slices_subsampled, (-1, 1, [2], [3]))
l1a = nn.layers.dnn.Conv2DDNNLayer(l0_frames,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=16,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=32,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2, 2), stride=(2, 2))
l5drop = nn.layers.dropout(l5, p=0.5)
ld1 = nn.layers.DenseLayer(l5drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld1drop = nn.layers.dropout(ld1, p=0.5)
ld2 = nn.layers.DenseLayer(ld1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ld2drop = nn.layers.dropout(ld2, p=0.5)
ld3mu = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(200.0),
nonlinearity=None)
ld3sigma = nn.layers.DenseLayer(ld2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(50.0),
nonlinearity=lb_softplus(3))
ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1)
# Attention model
l_att_d1 = nn.layers.DenseLayer(l5,
num_units=32,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_att_d1re = nn.layers.ReshapeLayer(
l_att_d1, (batch_size, nr_frames_subsampled * 32))
l_att_d2 = nn.layers.DenseLayer(l_att_d1re,
num_units=64,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_att = nn.layers.DenseLayer(l_att_d2,
num_units=nr_frames_subsampled,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=None)
l_att_sys = nn.layers.NonlinearityLayer(
l_att, nonlinearity=nn.nonlinearities.softmax)
l_att_dia = nn.layers.NonlinearityLayer(l_att,
nonlinearity=reverse_softmax)
# Reshape back to slicemodel
ld3musigma_slices = nn.layers.ReshapeLayer(ld3musigma,
(-1, nr_frames_subsampled, 2))
l_slices_musigma_cm_sys = layers.SelectWithAttentionLayer(
[ld3musigma_slices, l_att_sys]) # (bxs, 2)
l_slices_musigma_cm_dia = layers.SelectWithAttentionLayer(
[ld3musigma_slices, l_att_dia]) # (bxs, 2)
l_systole = layers.MuSigmaErfLayer(l_slices_musigma_cm_sys)
l_diastole = layers.MuSigmaErfLayer(l_slices_musigma_cm_dia)
return {
"inputs": {
"sliced:data:singleslice": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ld1: l2_weight,
ld2: l2_weight,
ld3mu: l2_weight_out,
ld3musigma: l2_weight_out,
}
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:sax"]
input_size_mask = data_sizes["sliced:data:sax:is_not_padded"]
input_size_locations = data_sizes["sliced:data:sax:locations"]
l0 = nn.layers.InputLayer(input_size)
lin_slice_mask = nn.layers.InputLayer(input_size_mask)
lin_slice_locations = nn.layers.InputLayer(input_size_locations)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers and some dense layers are defined in a submodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
l1a = nn.layers.dnn.Conv2DDNNLayer(l0_slices,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=64,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2, 2), stride=(2, 2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=128,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2, 2), stride=(2, 2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=256,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2, 2), stride=(2, 2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2, 2), stride=(2, 2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b,
W=nn.init.Orthogonal("relu"),
filter_size=(3, 3),
num_filters=512,
stride=(1, 1),
pad="same",
nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2, 2), stride=(2, 2))
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(l5,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
ldsys2drop = nn.layers.dropout(ldsys2, p=0.5)
l_sys_mu = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(10.0),
nonlinearity=None)
l_sys_sigma = nn.layers.DenseLayer(ldsys2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(3.),
nonlinearity=lb_softplus(.1))
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(l5,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop,
num_units=512,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
lddia2drop = nn.layers.dropout(lddia2, p=0.5)
l_dia_mu = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(10.0),
nonlinearity=None)
l_dia_sigma = nn.layers.DenseLayer(lddia2drop,
num_units=1,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(3.),
nonlinearity=lb_softplus(.1))
# AGGREGATE SLICES PER PATIENT
l_scaled_slice_locations = layers.TrainableScaleLayer(
lin_slice_locations, scale=nn.init.Constant(0.1), trainable=False)
# Systole
l_pat_sys_ss_mu = nn.layers.ReshapeLayer(l_sys_mu, (-1, nr_slices))
l_pat_sys_ss_sigma = nn.layers.ReshapeLayer(l_sys_sigma, (-1, nr_slices))
l_pat_sys_aggr_mu_sigma = layers.JeroenLayer([
l_pat_sys_ss_mu, l_pat_sys_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=1.)
l_systole = layers.MuSigmaErfLayer(l_pat_sys_aggr_mu_sigma)
# Diastole
l_pat_dia_ss_mu = nn.layers.ReshapeLayer(l_dia_mu, (-1, nr_slices))
l_pat_dia_ss_sigma = nn.layers.ReshapeLayer(l_dia_sigma, (-1, nr_slices))
l_pat_dia_aggr_mu_sigma = layers.JeroenLayer([
l_pat_dia_ss_mu, l_pat_dia_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=1.)
l_diastole = layers.MuSigmaErfLayer(l_pat_dia_aggr_mu_sigma)
return {
"inputs": {
"sliced:data:sax": l0,
"sliced:data:sax:is_not_padded": lin_slice_mask,
"sliced:data:sax:locations": lin_slice_locations,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
l_sys_mu: l2_weight_out,
l_sys_sigma: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
l_dia_mu: l2_weight_out,
l_dia_sigma: l2_weight_out,
},
}
def build_model(input_layer = None):
#################
# Regular model #
#################
l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"])
l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"])
# Add an axis to concatenate over later
l_4chr = nn.layers.ReshapeLayer(l_4ch, (batch_size, 1, ) + l_4ch.output_shape[1:])
l_2chr = nn.layers.ReshapeLayer(l_2ch, (batch_size, 1, ) + l_2ch.output_shape[1:])
# Cut the images in half, flip the left ones
l_4ch_left = nn.layers.SliceLayer(l_4chr, indices=slice(image_size//2-1, None, -1), axis=-1)
l_4ch_right = nn.layers.SliceLayer(l_4chr, indices=slice(image_size//2, None, 1), axis=-1)
l_2ch_left = nn.layers.SliceLayer(l_2chr, indices=slice(image_size//2-1, None, -1), axis=-1)
l_2ch_right = nn.layers.SliceLayer(l_2chr, indices=slice(image_size//2, None, 1), axis=-1)
# Concatenate over second axis
l_24lr = nn.layers.ConcatLayer([l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1)
# b, 4, t, h, w
# Subsample frames
SUBSAMPLING_FACTOR = 2
nr_subsampled_frames = nr_frames // SUBSAMPLING_FACTOR
l_24lr_ss = nn.layers.SliceLayer(l_24lr, indices=slice(None, None, SUBSAMPLING_FACTOR), axis=2)
# Move frames and halves to batch, process them all in the same way, add channel axis
l_halves = nn.layers.ReshapeLayer(l_24lr_ss, (batch_size * 4 * nr_subsampled_frames, 1, image_size, image_size//2))
# First, do some convolutions in all directions
num_channels = 64
l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=num_channels, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=num_channels, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
# Then, put an rnn over the last axis
l1_shuffle = nn.layers.DimshuffleLayer(l1b, pattern=(0, 2, 3, 1))
l1_r = nn.layers.ReshapeLayer(l1_shuffle, (batch_size * 4 * nr_subsampled_frames * image_size, image_size//2, num_channels))
l_rnn = rnn_layer(l1_r, 1024)
ld3mu = nn.layers.DenseLayer(l_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(16.0), nonlinearity=None)
ld3sigma = nn.layers.DenseLayer(l_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(4.0), nonlinearity=lb_softplus(.01))
ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1)
# Get the four halves back
l_24lr_musigma = nn.layers.ReshapeLayer(ld3musigma, (batch_size, 4, nr_subsampled_frames, image_size, 2))
l_24lr_musigma_shuffle = nn.layers.DimshuffleLayer(l_24lr_musigma, pattern=(0, 2, 1, 3, 4))
l_24lr_musigma_re = nn.layers.ReshapeLayer(l_24lr_musigma_shuffle, (batch_size * nr_subsampled_frames, 4, image_size, 2))
l_4ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=0, axis=1)
l_4ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=1, axis=1)
l_2ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=2, axis=1)
l_2ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=3, axis=1)
l_4ch_musigma = layers.SumGaussLayer([l_4ch_left_musigma, l_4ch_right_musigma])
l_2ch_musigma = layers.SumGaussLayer([l_2ch_left_musigma, l_2ch_right_musigma])
l_musigma_frames = layers.IraLayerNoTime(l_4ch_musigma, l_2ch_musigma)
# Minmax over time
print(l_musigma_frames.output_shape)
l_musigmas = nn.layers.ReshapeLayer(l_musigma_frames, (-1, nr_subsampled_frames, 2))
l_musigma_sys = layers.ArgmaxAndMaxLayer(l_musigmas, mode='min')
l_musigma_dia = layers.ArgmaxAndMaxLayer(l_musigmas, mode='max')
l_systole = layers.MuSigmaErfLayer(l_musigma_sys)
l_diastole = layers.MuSigmaErfLayer(l_musigma_dia)
return {
"inputs":{
"sliced:data:chanzoom:4ch": l_4ch,
"sliced:data:chanzoom:2ch": l_2ch,
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
},
"meta_outputs": {
}
}
def build_model():
import j6_2ch_gauss, j6_4ch_gauss
meta_2ch = j6_2ch_gauss.build_model()
meta_4ch = j6_4ch_gauss.build_model()
l_meta_2ch_systole = nn.layers.DenseLayer(
meta_2ch["meta_outputs"]["systole"],
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_meta_2ch_diastole = nn.layers.DenseLayer(
meta_2ch["meta_outputs"]["diastole"],
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_meta_4ch_systole = nn.layers.DenseLayer(
meta_4ch["meta_outputs"]["systole"],
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_meta_4ch_diastole = nn.layers.DenseLayer(
meta_4ch["meta_outputs"]["diastole"],
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:sax"]
input_size_mask = data_sizes["sliced:data:sax:is_not_padded"]
input_size_locations = data_sizes["sliced:data:sax:locations"]
l0 = nn.layers.InputLayer(input_size)
lin_slice_mask = nn.layers.InputLayer(input_size_mask)
lin_slice_locations = nn.layers.InputLayer(input_size_locations)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers and some dense layers are defined in a submodel
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
import je_ss_jonisc64small_360_gauss_longer
submodel = je_ss_jonisc64small_360_gauss_longer.build_model(l0_slices)
# Systole Dense layers
l_sys_mu = submodel["meta_outputs"]["systole:mu"]
l_sys_sigma = submodel["meta_outputs"]["systole:sigma"]
l_sys_meta = submodel["meta_outputs"]["systole"]
# Diastole Dense layers
l_dia_mu = submodel["meta_outputs"]["diastole:mu"]
l_dia_sigma = submodel["meta_outputs"]["diastole:sigma"]
l_dia_meta = submodel["meta_outputs"]["diastole"]
# AGGREGATE SLICES PER PATIENT
l_scaled_slice_locations = layers.TrainableScaleLayer(
lin_slice_locations, scale=nn.init.Constant(0.1), trainable=False)
# Systole
l_pat_sys_ss_mu = nn.layers.ReshapeLayer(l_sys_mu, (-1, nr_slices))
l_pat_sys_ss_sigma = nn.layers.ReshapeLayer(l_sys_sigma, (-1, nr_slices))
l_pat_sys_aggr_mu_sigma = layers.JeroenLayer([
l_pat_sys_ss_mu, l_pat_sys_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=100.)
l_systole = layers.MuSigmaErfLayer(l_pat_sys_aggr_mu_sigma)
l_sys_meta = nn.layers.DenseLayer(nn.layers.ReshapeLayer(
l_sys_meta, (-1, nr_slices, 512)),
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_meta_systole = nn.layers.ConcatLayer(
[l_meta_2ch_systole, l_meta_4ch_systole, l_sys_meta])
l_weights = nn.layers.DenseLayer(l_meta_systole,
num_units=512,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_weights = nn.layers.DenseLayer(l_weights,
num_units=3,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
systole_output = layers.WeightedMeanLayer(l_weights, [
l_systole, meta_2ch["outputs"]["systole"],
meta_4ch["outputs"]["systole"]
])
# Diastole
l_pat_dia_ss_mu = nn.layers.ReshapeLayer(l_dia_mu, (-1, nr_slices))
l_pat_dia_ss_sigma = nn.layers.ReshapeLayer(l_dia_sigma, (-1, nr_slices))
l_pat_dia_aggr_mu_sigma = layers.JeroenLayer([
l_pat_dia_ss_mu, l_pat_dia_ss_sigma, lin_slice_mask,
l_scaled_slice_locations
],
rescale_input=100.)
l_diastole = layers.MuSigmaErfLayer(l_pat_dia_aggr_mu_sigma)
l_dia_meta = nn.layers.DenseLayer(nn.layers.ReshapeLayer(
l_dia_meta, (-1, nr_slices, 512)),
num_units=64,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_meta_diastole = nn.layers.ConcatLayer(
[l_meta_2ch_diastole, l_meta_4ch_diastole, l_dia_meta])
l_weights = nn.layers.DenseLayer(l_meta_diastole,
num_units=512,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.rectify)
l_weights = nn.layers.DenseLayer(l_weights,
num_units=3,
W=nn.init.Orthogonal(),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.identity)
diastole_output = layers.WeightedMeanLayer(l_weights, [
l_diastole, meta_2ch["outputs"]["diastole"],
meta_4ch["outputs"]["diastole"]
])
submodels = [submodel, meta_2ch, meta_4ch]
return {
"inputs":
dict(
{
"sliced:data:sax": l0,
"sliced:data:sax:is_not_padded": lin_slice_mask,
"sliced:data:sax:locations": lin_slice_locations,
}, **{
k: v
for d in [model["inputs"] for model in [meta_2ch, meta_4ch]]
for k, v in d.items()
}),
"outputs": {
"systole": systole_output,
"diastole": diastole_output,
},
"regularizable":
dict({}, **{
k: v
for d in [
model["regularizable"] for model in submodels
if "regularizable" in model
] for k, v in d.items()
}),
"pretrained": {
je_ss_jonisc64small_360_gauss_longer.__name__: submodel["outputs"],
j6_2ch_gauss.__name__: meta_2ch["outputs"],
j6_4ch_gauss.__name__: meta_4ch["outputs"],
},
#"cutoff_gradients": [
#] + [ v for d in [model["meta_outputs"] for model in [meta_2ch, meta_4ch] if "meta_outputs" in model]
# for v in d.values() ]
}
def build_model():
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:randomslices"]
l0 = nn.layers.InputLayer(input_size)
# PREPROCESS SLICES SEPERATELY
# Convolutional layers
l0_slices = nn.layers.ReshapeLayer(l0, (-1, [2], [3], [4]))
l1a = nn.layers.dnn.Conv2DDNNLayer(l0_slices, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2,2), stride=(2,2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2,2), stride=(2,2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2,2), stride=(2,2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2,2), stride=(2,2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2,2), stride=(2,2))
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(l5, num_units=512, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop, num_units=256, W=nn.init.Orthogonal("relu"),b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(l5, num_units=512, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop, num_units=256, W=nn.init.Orthogonal("relu"),b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsys2, (-1, nr_slices, [1]))
input_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal())
forget_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal(), b=nn.init.Constant(5.0))
output_gate_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal())
cell_sys = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal(), W_cell=None, nonlinearity=nn.nonlinearities.tanh)
ldsys_lstm = nn.layers.LSTMLayer(ldsys_pat_in, num_units=256,
ingate=input_gate_sys, forgetgate=forget_gate_sys,
cell=cell_sys, outgate=output_gate_sys,
peepholes=False, precompute_input=False,
grad_clipping=5, only_return_final=True,
learn_init=True,)
ldsys_lstm_drop = nn.layers.dropout(ldsys_lstm, p=0.5)
ldsys3mu = nn.layers.DenseLayer(ldsys_lstm_drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(200.0), nonlinearity=None)
ldsys3sigma = nn.layers.DenseLayer(ldsys_lstm_drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(100.0), nonlinearity=lb_softplus(3))
ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1)
l_systole = layers.MuSigmaErfLayer(ldsys3musigma)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddia2, (-1, nr_slices, [1]))
input_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal())
forget_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal(), b=nn.init.Constant(5.0))
output_gate_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal())
cell_dia = nn.layers.Gate(W_in=nn.init.GlorotUniform(), W_hid=nn.init.Orthogonal(), W_cell=None, nonlinearity=nn.nonlinearities.tanh)
lddia_lstm = nn.layers.LSTMLayer(lddia_pat_in, num_units=256,
ingate=input_gate_dia, forgetgate=forget_gate_dia,
cell=cell_dia, outgate=output_gate_dia,
peepholes=False, precompute_input=False,
grad_clipping=5, only_return_final=True,
learn_init=True,)
lddia_lstm_drop = nn.layers.dropout(lddia_lstm, p=0.5)
lddia3mu = nn.layers.DenseLayer(lddia_lstm_drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(200.0), nonlinearity=None)
lddia3sigma = nn.layers.DenseLayer(lddia_lstm_drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(100.0), nonlinearity=lb_softplus(3))
lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1)
l_diastole = layers.MuSigmaErfLayer(lddia3musigma)
return {
"inputs":{
"sliced:data:randomslices": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
ldsys3mu: l2_weight_out,
ldsys3sigma: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
lddia3mu: l2_weight_out,
lddia3sigma: l2_weight_out,
},
}
