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_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, mask_input=lin_slice_mask)
# 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, mask_input=lin_slice_mask)
# 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: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(
{
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: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: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
submodel = je_ss_jonisc64small_360.build_model(l0_slices)
# Systole Dense layers
ldsysout = submodel["outputs"]["systole"]
# Diastole Dense layers
lddiaout = submodel["outputs"]["diastole"]
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsysout, (-1, nr_slices, [1]))
ldsys_rnn = rnn_layer(ldsys_pat_in, num_units=256, mask_input=lin_slice_mask)
# ldsys_rnn_drop = nn.layers.dropout(ldsys_rnn, p=0.5)
ldsys3 = nn.layers.DenseLayer(ldsys_rnn, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
ldsys3drop = nn.layers.dropout(ldsys3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
ldsys3dropnorm = layers.NormalisationLayer(ldsys3drop)
l_systole = layers.CumSumLayer(ldsys3dropnorm)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddiaout, (-1, nr_slices, [1]))
lddia_rnn = rnn_layer(lddia_pat_in, num_units=256, mask_input=lin_slice_mask)
# lddia_rnn_drop = nn.layers.dropout(lddia_rnn, p=0.5)
lddia3 = nn.layers.DenseLayer(lddia_rnn, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
lddia3drop = nn.layers.dropout(lddia3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
lddia3dropnorm = layers.NormalisationLayer(lddia3drop)
l_diastole = layers.CumSumLayer(lddia3dropnorm)
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(
{
lddia3: l2_weight_out,
ldsys3: 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():
#import here, such that our global variables are not overridden!
import j6_2ch_128mm, j6_4ch, je_ss_jonisc64small_360
sax_input = nn.layers.InputLayer(data_sizes["sliced:data:sax"])
sax_slices = nn.layers.ReshapeLayer(sax_input, (-1, [2], [3], [4]))
meta_sax = je_ss_jonisc64small_360.build_model(input_layer = sax_slices)
#reduce the number of parameters BEFORE reshaping! Keep 16 numbers per slice.
meta_sax_systole_reduced = nn.layers.DenseLayer(meta_sax["meta_outputs"]["systole"], num_units=16, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
meta_sax_diastole_reduced = nn.layers.DenseLayer(meta_sax["meta_outputs"]["diastole"], num_units=16, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
l_sax_systole = nn.layers.ReshapeLayer(meta_sax_systole_reduced, (-1, nr_slices, [1]))
l_sax_diastole = nn.layers.ReshapeLayer(meta_sax_diastole_reduced, (-1, nr_slices, [1]))
l_sax_systole_flat = nn.layers.DenseLayer(l_sax_systole, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
l_sax_diastole_flat = nn.layers.DenseLayer(l_sax_diastole, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
meta_2ch = j6_2ch_128mm.build_model()
meta_4ch = j6_4ch.build_model()
l_age = nn.layers.InputLayer(data_sizes["sliced:meta:PatientAge"])
l_sex = nn.layers.InputLayer(data_sizes["sliced:meta:PatientSex"])
l_locations = nn.layers.InputLayer(data_sizes["sliced:data:sax:locations"])
l_meta_2ch_systole = nn.layers.DenseLayer(meta_2ch["meta_outputs"]["systole"], num_units=64, W=nn.init.Orthogonal("relu"), 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("relu"), 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("relu"), 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("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
l_meta_systole = nn.layers.ConcatLayer([l_age, l_sex, l_meta_2ch_systole, l_meta_4ch_systole, l_locations, l_sax_systole_flat])
l_meta_diastole = nn.layers.ConcatLayer([l_age, l_sex, l_meta_2ch_diastole, l_meta_4ch_diastole, l_locations, l_sax_diastole_flat])
ldsys1 = nn.layers.DenseLayer(l_meta_systole, 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)
ldsys3 = nn.layers.DenseLayer(ldsys2drop, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
ldsys3drop = nn.layers.dropout(ldsys3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
ldsys3dropnorm = layers.NormalisationLayer(ldsys3drop)
l_systole = layers.CumSumLayer(ldsys3dropnorm)
lddia1 = nn.layers.DenseLayer(l_meta_diastole, 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)
lddia3 = nn.layers.DenseLayer(lddia2drop, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
lddia3drop = nn.layers.dropout(lddia3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
lddia3dropnorm = layers.NormalisationLayer(lddia3drop)
l_diastole = layers.CumSumLayer(lddia3dropnorm)
submodels = [meta_2ch, meta_4ch, meta_sax]
return {
"inputs": dict({
"sliced:data:sax": sax_input,
"sliced:meta:PatientAge": l_age,
"sliced:meta:PatientSex": l_sex,
"sliced:data:sax:locations": l_locations,
}, **{ k: v for d in [model["inputs"] for model in [meta_2ch, meta_4ch]]
for k, v in d.items() }
),
"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":{
j6_2ch_128mm.__name__: meta_2ch["outputs"],
j6_4ch.__name__: meta_4ch["outputs"],
je_ss_jonisc64small_360.__name__: meta_sax["outputs"],
},
"cutoff_gradients": [
] + [ v for d in [model["meta_outputs"] for model in submodels 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 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]))
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 d.items() }
),
# "pretrained":{
# je_ss_jonisc64small_360.__name__: submodel["outputs"],
# }
}
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: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
submodel = je_ss_jonisc64small_360.build_model(l0_slices)
# Systole Dense layers
ldsysout = submodel["outputs"]["systole"]
# Diastole Dense layers
lddiaout = submodel["outputs"]["diastole"]
# AGGREGATE SLICES PER PATIENT
# Systole
ldsys_pat_in = nn.layers.ReshapeLayer(ldsysout, (-1, nr_slices, [1]))
ldsys_rnn = rnn_layer(ldsys_pat_in,
num_units=256,
mask_input=lin_slice_mask)
# ldsys_rnn_drop = nn.layers.dropout(ldsys_rnn, p=0.5)
ldsys3 = nn.layers.DenseLayer(ldsys_rnn,
num_units=600,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.softmax)
ldsys3drop = nn.layers.dropout(
ldsys3, p=0.5
) # dropout at the output might encourage adjacent neurons to correllate
ldsys3dropnorm = layers.NormalisationLayer(ldsys3drop)
l_systole = layers.CumSumLayer(ldsys3dropnorm)
# Diastole
lddia_pat_in = nn.layers.ReshapeLayer(lddiaout, (-1, nr_slices, [1]))
lddia_rnn = rnn_layer(lddia_pat_in,
num_units=256,
mask_input=lin_slice_mask)
# lddia_rnn_drop = nn.layers.dropout(lddia_rnn, p=0.5)
lddia3 = nn.layers.DenseLayer(lddia_rnn,
num_units=600,
W=nn.init.Orthogonal("relu"),
b=nn.init.Constant(0.1),
nonlinearity=nn.nonlinearities.softmax)
lddia3drop = nn.layers.dropout(
lddia3, p=0.5
) # dropout at the output might encourage adjacent neurons to correllate
lddia3dropnorm = layers.NormalisationLayer(lddia3drop)
l_diastole = layers.CumSumLayer(lddia3dropnorm)
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({
lddia3: l2_weight_out,
ldsys3: 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"],
}
}
