def betaVAE_bn(x,
s_oh,
zdim_0,
training,
scope_reuse=False,
norm=tfnorm.batch_norm,
**kwargs):
resolution_levels = kwargs.get('resolution_levels', 5)
image_size = x.get_shape().as_list()[1:3]
final_kernel_size = [s // (2**(resolution_levels - 1)) for s in image_size]
# POSTERIOR ####################
with tf.variable_scope('posterior') as scope:
if scope_reuse:
scope.reuse_variables()
n0 = kwargs.get('n0', 32)
mu_z = []
sigma_z = []
z = []
# Generate pre_z's
net = tf.concat([x, s_oh - 0.5], axis=-1)
for ii in range(resolution_levels - 1):
net = layers.conv2D(net,
'q_z_%d' % ii,
num_filters=n0 * (ii // 2 + 1),
kernel_size=(4, 4),
strides=(2, 2),
normalisation=norm,
training=training)
net = layers.conv2D(net,
'q_z_%d' % resolution_levels,
num_filters=n0 * 8,
kernel_size=final_kernel_size,
strides=(1, 1),
padding='VALID',
normalisation=norm,
training=training)
mu_z.append(
layers.dense_layer(net,
'z_mu',
hidden_units=zdim_0,
activation=tf.identity))
sigma_z.append(
layers.dense_layer(net,
'z_sigma',
hidden_units=zdim_0,
activation=tf.nn.softplus))
z.append(mu_z[0] + sigma_z[0] *
tf.random_normal(tf.shape(mu_z[0]), 0, 1, dtype=tf.float32))
return z, mu_z, sigma_z
def jia_xi_net(images,
training,
nlabels,
scope_name='classifier',
scope_reuse=False):
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
conv1_1 = layers.conv3D_layer(images, 'conv1_1', num_filters=32)
pool1 = layers.max_pool_layer3d(conv1_1)
conv2_1 = layers.conv3D_layer(pool1, 'conv2_1', num_filters=64)
pool2 = layers.max_pool_layer3d(conv2_1)
conv3_1 = layers.conv3D_layer(pool2, 'conv3_1', num_filters=128)
conv3_2 = layers.conv3D_layer(conv3_1, 'conv3_2', num_filters=128)
pool3 = layers.max_pool_layer3d(conv3_2)
conv4_1 = layers.conv3D_layer(pool3, 'conv4_1', num_filters=256)
conv4_2 = layers.conv3D_layer(conv4_1, 'conv4_2', num_filters=256)
pool4 = layers.max_pool_layer3d(conv4_2)
dense1 = layers.dense_layer(pool4, 'dense1', hidden_units=512)
dense2 = layers.dense_layer(dense1,
'dense2',
hidden_units=nlabels,
activation=tf.identity)
return dense2
def betaVAE_bn(z_list,
training,
image_size,
n_classes,
scope_reuse=False,
norm=tfnorm.batch_norm,
**kwargs):
"""
This is a U-NET like arch with skips before and after latent space and a rather simple decoder
"""
resolution_levels = kwargs.get('resolution_levels', 5)
final_kernel_size = [
s // (2**(resolution_levels - 1)) for s in image_size[0:2]
]
logging.info('@ likelihood final kernel size')
logging.info(final_kernel_size)
n0 = kwargs.get('n0', 32)
with tf.variable_scope('likelihood') as scope:
if scope_reuse:
scope.reuse_variables()
lat_ups = layers.dense_layer(z_list[0],
'z_ups_1',
hidden_units=8 * n0,
normalisation=norm,
training=training)
lat_ups = layers.dense_layer(lat_ups,
'z_ups_2',
hidden_units=n0 * 4 *
np.prod(final_kernel_size),
normalisation=norm,
training=training)
z_reshaped = tf.reshape(
lat_ups,
tf.stack([-1, final_kernel_size[0], final_kernel_size[1], 4 * n0]))
net = z_reshaped
for ii in reversed(range(resolution_levels - 2)):
net = layers.transposed_conv2D(net,
num_filters=n0 * (ii // 2 + 1),
name='deconv%d' % ii,
normalisation=norm,
training=training)
s = [
layers.transposed_conv2D(net,
num_filters=n_classes,
name='deconv_out_s',
activation=tf.identity)
]
return s
def CAM_net2D(x, nlabels, training, scope_reuse=False):
with tf.variable_scope('classifier') as scope:
if scope_reuse:
scope.reuse_variables()
init_filters = 32
conv1_1 = layers.conv2D_layer_bn(x, 'conv1_1', num_filters=init_filters, training=training)
pool1 = layers.maxpool2D_layer(conv1_1)
conv2_1 = layers.conv2D_layer_bn(pool1, 'conv2_1', num_filters=init_filters*2, training=training)
pool2 = layers.maxpool2D_layer(conv2_1)
conv3_1 = layers.conv2D_layer_bn(pool2, 'conv3_1', num_filters=init_filters*4, training=training)
conv3_2 = layers.conv2D_layer_bn(conv3_1, 'conv3_2', num_filters=init_filters*4, training=training)
conv4_1 = layers.conv2D_layer_bn(conv3_2, 'conv4_1', num_filters=init_filters*8, training=training)
conv4_2 = layers.conv2D_layer_bn(conv4_1, 'conv4_2', num_filters=init_filters*8, training=training)
conv5_1 = layers.conv2D_layer_bn(conv4_2, 'conv5_1', num_filters=init_filters*16, training=training)
conv5_2 = layers.conv2D_layer_bn(conv5_1, 'conv5_2', num_filters=init_filters*16, training=training)
convD_1 = layers.conv2D_layer_bn(conv5_2, 'feature_maps', num_filters=init_filters*16, training=training)
fm_averages = layers.averagepool2D_layer(convD_1, name='fm_averages')
logits = layers.dense_layer(fm_averages, 'weight_layer', hidden_units=nlabels, activation=tf.identity, add_bias=False)
return logits
def jia_xi_net_multitask_ordinal(images,
training,
nlabels,
n_age_thresholds=5,
scope_name='classifier',
scope_reuse=False):
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
conv1_1 = layers.conv3D_layer(images, 'conv1_1', num_filters=32)
pool1 = layers.max_pool_layer3d(conv1_1)
conv2_1 = layers.conv3D_layer(pool1, 'conv2_1', num_filters=64)
pool2 = layers.max_pool_layer3d(conv2_1)
conv3_1 = layers.conv3D_layer(pool2, 'conv3_1', num_filters=128)
conv3_2 = layers.conv3D_layer(conv3_1, 'conv3_2', num_filters=128)
pool3 = layers.max_pool_layer3d(conv3_2)
conv4_1 = layers.conv3D_layer(pool3, 'conv4_1', num_filters=256)
conv4_2 = layers.conv3D_layer(conv4_1, 'conv4_2', num_filters=256)
pool4 = layers.max_pool_layer3d(conv4_2)
dense1 = layers.dense_layer(pool4, 'dense1', hidden_units=512)
diagnosis = layers.dense_layer(dense1,
'dense2',
hidden_units=nlabels,
activation=tf.identity)
dense_ages = layers.dense_layer(pool4, 'dense_ages', hidden_units=512)
ages_logits = []
for ii in range(n_age_thresholds):
ages_logits.append(
layers.dense_layer(dense_ages,
'age_%s' % str(ii),
hidden_units=2,
activation=tf.identity))
return diagnosis, ages_logits
def only_conv_generator(z,
training,
residual=True,
batch_normalization=False,
hidden_layers=2,
filters=16,
input_noise_dim=0,
scope_name='generator',
scope_reuse=False):
# batch size 2: hidden_layers=2, filters=16
# batch size 1: hidden_layers=3, filters=32
# only residual connection from beginning to end possible
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
previous_layer = z
if input_noise_dim >= 1:
# create noise, push it through a fc layer and concatenate it as a new channel
noise_in = tf.random_uniform(shape=[
previous_layer.get_shape().as_list()[0], input_noise_dim
],
minval=-1,
maxval=1)
# make sure the last dimension is 1 but the others agree with the image input
noise_channel_shape = previous_layer.shape[:-1]
# the batchsize stays constant
fc_hidden_units = np.prod(noise_channel_shape[1:])
fc_noise_layer = layers.dense_layer(noise_in,
'fc_noise_layer',
hidden_units=fc_hidden_units,
activation=tf.identity)
noise_channel = tf.reshape(fc_noise_layer, noise_channel_shape)
noise_channel = tf.expand_dims(noise_channel, axis=-1)
previous_layer = tf.concat([previous_layer, noise_channel],
axis=-1)
for depth in range(1, hidden_layers + 1):
if (batch_normalization):
previous_layer = layers.conv3D_layer_bn(previous_layer,
'gconv%d' % depth,
training,
num_filters=filters,
activation=tf.nn.relu)
else:
previous_layer = layers.conv3D_layer(previous_layer,
'gconv%d' % depth,
num_filters=32,
activation=tf.nn.relu)
last_layer = layers.conv3D_layer(previous_layer,
'gconv%d_last' % (hidden_layers + 1),
num_filters=1,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
activation=tf.identity)
if residual:
return last_layer + z
else:
return last_layer
def unet_T_L(x,
s_oh,
zdim_0,
training,
scope_reuse=False,
norm=tfnorm.batch_norm,
**kwargs):
# POSTERIOR ####################
with tf.variable_scope('posterior') as scope:
if scope_reuse:
scope.reuse_variables()
full_cov_list = kwargs.get('full_cov_list', None)
n0 = kwargs.get('n0', 32)
max_channel_power = kwargs.get('max_channel_power', 4)
max_channels = n0 * 2**max_channel_power
latent_levels = kwargs.get('latent_levels', 4)
resolution_levels = kwargs.get('resolution_levels', 6)
spatial_xdim = x.get_shape().as_list()[1:3]
full_latent_dependencies = kwargs.get('full_latent_dependencies',
False)
pre_z = [None] * resolution_levels
mu = [None] * latent_levels
sigma = [None] * latent_levels
z = [None] * latent_levels
z_ups_mat = []
for i in range(latent_levels):
z_ups_mat.append(
[None] *
latent_levels) # encoding [original resolution][upsampled to]
# Generate pre_z's
for i in range(resolution_levels):
if i == 0:
net = tf.concat([x, s_oh - 0.5], axis=-1)
else:
net = layers.reshape_pool2D_layer(pre_z[i - 1])
net = layers.conv2D(net,
'z%d_pre_1' % i,
num_filters=n0 * (i // 2 + 1),
normalisation=norm,
training=training)
net = layers.conv2D(net,
'z%d_pre_2' % i,
num_filters=n0 * (i // 2 + 1),
normalisation=norm,
training=training)
pre_z[i] = net
# Generate z's
for i in reversed(range(latent_levels)):
spatial_zdim = [
d // 2**(i + resolution_levels - latent_levels)
for d in spatial_xdim
]
spatial_cov_dim = spatial_zdim[0] * spatial_zdim[1]
if i == latent_levels - 1:
mu[i] = layers.conv2D(pre_z[i + resolution_levels -
latent_levels],
'z%d_mu' % i,
num_filters=zdim_0,
activation=tf.identity)
if full_cov_list[i] == True:
l = layers.dense_layer(
pre_z[i + resolution_levels - latent_levels],
'z%d_sigma' % i,
hidden_units=zdim_0 * spatial_cov_dim *
(spatial_cov_dim + 1) // 2,
activation=tf.identity)
l = tf.reshape(l, [
-1, zdim_0, spatial_cov_dim *
(spatial_cov_dim + 1) // 2
])
Lp = tf.contrib.distributions.fill_triangular(l)
L = tf.linalg.set_diag(
Lp, tf.nn.softplus(tf.linalg.diag_part(Lp))
) # Cholesky factors must have positive diagonal
sigma[i] = L
eps = tf.random_normal(tf.shape(mu[i]))
eps = tf.transpose(eps, perm=[0, 3, 1, 2])
bs = tf.shape(x)[0]
eps = tf.reshape(eps, tf.stack([bs, zdim_0, -1, 1]))
eps_tmp = tf.matmul(sigma[i], eps)
eps_tmp = tf.transpose(eps_tmp, perm=[0, 2, 3, 1])
eps_tmp = tf.reshape(
eps_tmp,
[bs, spatial_zdim[0], spatial_zdim[1], zdim_0])
z[i] = mu[i] + eps_tmp
else:
sigma[i] = layers.conv2D(pre_z[i + resolution_levels -
latent_levels],
'z%d_sigma' % i,
num_filters=zdim_0,
activation=tf.nn.softplus,
kernel_size=(1, 1))
z[i] = mu[i] + sigma[i] * tf.random_normal(
tf.shape(mu[i]), 0, 1, dtype=tf.float32)
else:
for j in reversed(range(0, i + 1)):
z_below_ups = layers.nearest_neighbour_upsample2D(
z_ups_mat[j + 1][i + 1], factor=2)
z_below_ups = layers.conv2D(z_below_ups,
name='z%d_ups_to_%d_c_1' %
((i + 1), (j + 1)),
num_filters=zdim_0 * n0,
normalisation=norm,
training=training)
z_below_ups = layers.conv2D(z_below_ups,
name='z%d_ups_to_%d_c_2' %
((i + 1), (j + 1)),
num_filters=zdim_0 * n0,
normalisation=norm,
training=training)
z_ups_mat[j][i + 1] = z_below_ups
if full_latent_dependencies:
z_input = tf.concat(
[pre_z[i + resolution_levels - latent_levels]] +
z_ups_mat[i][(i + 1):latent_levels],
axis=3,
name='concat_%d' % i)
else:
z_input = tf.concat([
pre_z[i + resolution_levels - latent_levels],
z_ups_mat[i][i + 1]
],
axis=3,
name='concat_%d' % i)
z_input = layers.conv2D(z_input,
'z%d_input_1' % i,
num_filters=n0 * (i // 2 + 1),
normalisation=norm,
training=training)
z_input = layers.conv2D(z_input,
'z%d_input_2' % i,
num_filters=n0 * (i // 2 + 1),
normalisation=norm,
training=training)
mu[i] = layers.conv2D(z_input,
'z%d_mu' % i,
num_filters=zdim_0,
activation=tf.identity,
kernel_size=(1, 1))
if full_cov_list[i] == True:
l = layers.dense_layer(z_input,
'z%d_sigma' % i,
hidden_units=zdim_0 *
spatial_cov_dim *
(spatial_cov_dim + 1) // 2,
activation=tf.identity)
l = tf.reshape(l, [
-1, zdim_0, spatial_cov_dim *
(spatial_cov_dim + 1) // 2
])
Lp = tf.contrib.distributions.fill_triangular(l)
L = tf.linalg.set_diag(
Lp, tf.nn.softplus(tf.linalg.diag_part(Lp)))
sigma[i] = L
eps = tf.random_normal(tf.shape(mu[i]))
eps = tf.transpose(eps, perm=[0, 3, 1, 2])
bs = tf.shape(x)[0]
eps = tf.reshape(eps, tf.stack([bs, zdim_0, -1, 1]))
eps_tmp = tf.matmul(sigma[i], eps)
eps_tmp = tf.transpose(eps_tmp, perm=[0, 2, 3, 1])
eps_tmp = tf.reshape(
eps_tmp,
[bs, spatial_zdim[0], spatial_zdim[1], zdim_0])
z[i] = mu[i] + eps_tmp
else:
sigma[i] = layers.conv2D(z_input,
'z%d_sigma' % i,
num_filters=zdim_0,
activation=tf.nn.softplus,
kernel_size=(1, 1))
z[i] = mu[i] + sigma[i] * tf.random_normal(
tf.shape(mu[i]), 0, 1, dtype=tf.float32)
z_ups_mat[i][i] = z[i]
return z, mu, sigma
def segvae_const_latent(x,
s_oh,
zdim_0,
training,
scope_reuse=False,
norm=tfnorm.batch_norm,
**kwargs):
n0 = kwargs.get('n0', 32)
max_channel_power = kwargs.get('max_channel_power', 4)
max_channels = n0 * 2**max_channel_power
full_cov_list = kwargs.get('full_cov_list', None)
resolution_levels = kwargs.get('resolution_levels', 5)
def reduce_resolution(x, times, name):
with tf.variable_scope(name):
nett = x
for ii in range(times):
nett = layers.reshape_pool2D_layer(nett)
nC = nett.get_shape().as_list()[3]
nett = layers.conv2D(nett,
'down_%d' % ii,
num_filters=min(nC // 4, max_channels),
normalisation=norm,
training=training)
return nett
with tf.variable_scope('posterior') as scope:
spatial_xdim = x.get_shape().as_list()[1:3]
spatial_zdim = [d // 2**(resolution_levels - 1) for d in spatial_xdim]
spatial_cov_dim = spatial_zdim[0] * spatial_zdim[1]
if scope_reuse:
scope.reuse_variables()
n0 = kwargs.get('n0', 32)
levels = resolution_levels
full_latent_dependencies = kwargs.get('full_latent_dependencies',
False)
pre_z = [None] * levels
mu = [None] * levels
sigma = [None] * levels
z = [None] * levels
z_mat = []
for i in range(levels):
z_mat.append(
[None] *
levels) # encoding [original resolution][upsampled to]
# Generate pre_z's
for i in range(levels):
if i == 0:
net = tf.concat([x, s_oh - 0.5], axis=-1)
else:
net = layers.maxpool2D(pre_z[i - 1])
net = layers.conv2D(net,
'z%d_pre_1' % i,
num_filters=n0 * (i // 2 + 1),
normalisation=norm,
training=training)
pre_z[i] = net
# Generate z's
for i in reversed(range(levels)):
z_input = reduce_resolution(pre_z[i],
levels - i - 1,
name='reduction_%d' % i)
logging.info('z_input.shape')
logging.info(z_input.get_shape().as_list())
if i == levels - 1:
mu[i] = layers.conv2D(z_input,
'z%d_mu' % i,
num_filters=zdim_0,
activation=tf.identity)
if full_cov_list[i] == True:
l = layers.dense_layer(z_input,
'z%d_sigma' % i,
hidden_units=zdim_0 *
spatial_cov_dim *
(spatial_cov_dim + 1) // 2,
activation=tf.identity)
l = tf.reshape(l, [
-1, zdim_0, spatial_cov_dim *
(spatial_cov_dim + 1) // 2
])
Lp = tf.contrib.distributions.fill_triangular(l)
L = tf.linalg.set_diag(
Lp, tf.nn.softplus(tf.linalg.diag_part(Lp))
) # Cholesky factors must have positive diagonal
logging.info('L%d.shape ==========' % i)
logging.info(L.get_shape().as_list())
sigma[i] = L
eps = tf.random_normal(tf.shape(mu[i]))
eps = tf.transpose(eps, perm=[0, 3, 1, 2])
bs = tf.shape(x)[0]
eps = tf.reshape(eps, tf.stack([bs, zdim_0, -1, 1]))
eps_tmp = tf.matmul(sigma[i], eps)
eps_tmp = tf.transpose(eps_tmp, perm=[0, 2, 3, 1])
eps_tmp = tf.reshape(
eps_tmp,
[bs, spatial_zdim[0], spatial_zdim[1], zdim_0])
z[i] = mu[i] + eps_tmp
else:
sigma[i] = layers.conv2D(z_input,
'z%d_sigma' % i,
num_filters=zdim_0,
activation=tf.nn.softplus,
kernel_size=(1, 1))
z[i] = mu[i] + sigma[i] * tf.random_normal(
tf.shape(mu[i]), 0, 1, dtype=tf.float32)
else:
for j in reversed(range(0, i + 1)):
z_connect = layers.conv2D(z_mat[j + 1][i + 1],
name='double_res_%d_to_%d' %
((i + 1), (j)),
num_filters=2 * zdim_0,
normalisation=norm,
training=training)
z_mat[j][i + 1] = z_connect
if full_latent_dependencies:
z_input = tf.concat([z_input] + z_mat[i][(i + 1):levels],
axis=3,
name='concat_%d' % i)
else:
z_input = tf.concat([z_input, z_mat[i][(i + 1)]],
axis=3,
name='concat_%d' % i)
mu[i] = layers.conv2D(z_input,
'z%d_mu' % i,
num_filters=zdim_0,
activation=tf.identity)
if full_cov_list[i] == True:
l = layers.dense_layer(z_input,
'z%d_sigma' % i,
hidden_units=zdim_0 *
spatial_cov_dim *
(spatial_cov_dim + 1) // 2,
activation=tf.identity)
l = tf.reshape(l, [
-1, zdim_0, spatial_cov_dim *
(spatial_cov_dim + 1) // 2
])
Lp = tf.contrib.distributions.fill_triangular(l)
L = tf.linalg.set_diag(
Lp, tf.nn.softplus(tf.linalg.diag_part(Lp)))
sigma[i] = L
eps = tf.random_normal(tf.shape(mu[i]))
eps = tf.transpose(eps, perm=[0, 3, 1, 2])
bs = tf.shape(x)[0]
eps = tf.reshape(eps, tf.stack([bs, zdim_0, -1, 1]))
eps_tmp = tf.matmul(sigma[i], eps)
eps_tmp = tf.transpose(eps_tmp, perm=[0, 2, 3, 1])
eps_tmp = tf.reshape(
eps_tmp,
[bs, spatial_zdim[0], spatial_zdim[1], zdim_0])
z[i] = mu[i] + eps_tmp
else:
sigma[i] = layers.conv2D(z_input,
'z%d_sigma' % i,
num_filters=zdim_0,
activation=tf.nn.softplus)
z[i] = mu[i] + sigma[i] * tf.random_normal(
tf.shape(mu[i]), 0, 1, dtype=tf.float32)
z_mat[i][i] = z[i]
return z, mu, sigma
def pool_fc_discriminator_bs2(x,
training,
scope_name='discriminator',
scope_reuse=False):
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
conv1_1 = layers.conv3D_layer(x,
'dconv1_1',
kernel_size=(3, 3, 3),
num_filters=8,
strides=(1, 1, 1),
activation=layers.leaky_relu)
pool1 = layers.max_pool_layer3d(conv1_1)
conv2_1 = layers.conv3D_layer(pool1,
'dconv2_1',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
pool2 = layers.max_pool_layer3d(conv2_1)
conv3_1 = layers.conv3D_layer(pool2,
'dconv3_1',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
conv3_2 = layers.conv3D_layer_bn(conv3_1,
'dconv3_2',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu,
training=training)
pool3 = layers.max_pool_layer3d(conv3_2)
conv4_1 = layers.conv3D_layer(pool3,
'dconv4_1',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
conv4_2 = layers.conv3D_layer(conv4_1,
'dconv4_2',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
pool4 = layers.max_pool_layer3d(conv4_2)
conv5_1 = layers.conv3D_layer(pool4,
'dconv5_1',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
conv5_2 = layers.conv3D_layer(conv5_1,
'dconv5_2',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
pool5 = layers.max_pool_layer3d(conv5_2)
conv6_1 = layers.conv3D_layer(pool5,
'dconv6_1',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
conv6_2 = layers.conv3D_layer(conv6_1,
'dconv6_2',
kernel_size=(3, 3, 3),
num_filters=16,
strides=(1, 1, 1),
activation=layers.leaky_relu)
pool6 = layers.max_pool_layer3d(conv6_2)
dense1 = layers.dense_layer(pool6,
'ddense1',
hidden_units=256,
activation=layers.leaky_relu)
dense2 = layers.dense_layer(dense1,
'ddense2',
hidden_units=1,
activation=tf.identity)
return dense2
def bousmalis_discriminator(x,
training,
batch_normalization,
middle_layers,
initial_filters,
dropout_start=3,
scope_name='discriminator',
scope_reuse=False):
# leaky relu has the same parameter as in the paper
leaky_relu = lambda x: layers.leaky_relu(x, alpha=0.2)
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
if batch_normalization:
previous_layer = layers.conv3D_layer_bn(
x,
'convs1_1',
kernel_size=(3, 3, 3),
num_filters=initial_filters,
strides=(1, 1, 1),
activation=leaky_relu,
training=training)
else:
previous_layer = layers.conv3D_layer(x,
'convs1_1',
kernel_size=(3, 3, 3),
num_filters=initial_filters,
strides=(1, 1, 1),
activation=leaky_relu)
for current_layer in range(2, 2 + middle_layers):
num_filters = initial_filters * (2**(current_layer - 1))
if batch_normalization:
previous_layer = layers.conv3D_layer_bn(
previous_layer,
'convs2_' + str(current_layer),
kernel_size=(3, 3, 3),
num_filters=num_filters,
strides=(2, 2, 2),
activation=leaky_relu,
training=training)
else:
previous_layer = layers.conv3D_layer(previous_layer,
'convs2_' +
str(current_layer),
kernel_size=(3, 3, 3),
num_filters=num_filters,
strides=(2, 2, 2),
activation=leaky_relu)
if current_layer >= dropout_start:
previous_layer = layers.dropout_layer(previous_layer,
'dropout_' +
str(current_layer),
training,
keep_prob=0.9)
dense_out = layers.dense_layer(previous_layer,
'dense_out',
hidden_units=1,
activation=tf.identity)
return dense_out
def bousmalis_generator(x,
z_noise,
training,
batch_normalization,
residual_blocks,
nfilters,
last_activation=tf.nn.tanh,
scope_name='generator',
scope_reuse=False):
kernel_size = (3, 3, 3)
strides = (1, 1, 1)
# define layer for the residual blocks
if batch_normalization:
conv_layer = lambda bottom, name, activation: layers.conv3D_layer_bn(
bottom,
name,
training=training,
kernel_size=kernel_size,
num_filters=nfilters,
strides=strides,
activation=activation)
else:
conv_layer = lambda bottom, name, activation: layers.conv3D_layer(
bottom,
name,
kernel_size=kernel_size,
num_filters=nfilters,
strides=strides,
activation=activation)
with tf.variable_scope(scope_name) as scope:
if scope_reuse:
scope.reuse_variables()
x_conv_in = x
if z_noise is not None:
# make sure the last dimension is 1 but the others agree with the image input
noise_channel_shape = x.shape[:-1]
# the batchsize stays constant
fc_hidden_units = np.prod(noise_channel_shape[1:])
fc_noise_layer = layers.dense_layer(z_noise,
'fc_noise_layer',
hidden_units=fc_hidden_units,
activation=tf.identity)
noise_channel = tf.reshape(fc_noise_layer, noise_channel_shape)
noise_channel = tf.expand_dims(noise_channel, axis=-1)
x_conv_in = tf.concat([x, noise_channel], axis=-1)
previous_layer = layers.conv3D_layer(x_conv_in,
'conv1',
kernel_size=kernel_size,
num_filters=nfilters,
strides=strides,
activation=tf.nn.relu)
# place residual blocks
for block_num in range(1, 1 + residual_blocks):
previous_layer = layers.residual_block_original(
previous_layer,
'res_block_' + str(block_num),
conv_layer,
activation=tf.nn.relu,
nlayers=2)
conv_out = layers.conv3D_layer(previous_layer,
'conv_out',
kernel_size=kernel_size,
num_filters=1,
strides=strides,
activation=last_activation)
return conv_out
def C3D_32_bn(x,
nlabels,
training,
n0=32,
norm=tfnorm.batch_norm,
scope_reuse=False):
with tf.variable_scope('classifier') as scope:
if scope_reuse:
scope.reuse_variables()
add_bias = False if norm == tfnorm.batch_norm else True
conv1_1 = layers.conv3D(x,
'conv1_1',
num_filters=n0,
training=training,
normalisation=norm,
add_bias=add_bias)
pool1 = layers.maxpool3D(conv1_1)
conv2_1 = layers.conv3D(pool1,
'conv2_1',
num_filters=n0 * 2,
training=training,
normalisation=norm,
add_bias=add_bias)
pool2 = layers.maxpool3D(conv2_1)
conv3_1 = layers.conv3D(pool2,
'conv3_1',
num_filters=n0 * 4,
training=training,
normalisation=norm,
add_bias=add_bias)
conv3_2 = layers.conv3D(conv3_1,
'conv3_2',
num_filters=n0 * 4,
training=training,
normalisation=norm,
add_bias=add_bias)
pool3 = layers.maxpool3D(conv3_2)
conv4_1 = layers.conv3D(pool3,
'conv4_1',
num_filters=n0 * 8,
training=training,
normalisation=norm,
add_bias=add_bias)
conv4_2 = layers.conv3D(conv4_1,
'conv4_2',
num_filters=n0 * 8,
training=training,
normalisation=norm,
add_bias=add_bias)
pool4 = layers.maxpool3D(conv4_2)
dense1 = layers.dense_layer(pool4,
'dense1',
hidden_units=n0 * 16,
training=training,
normalisation=norm,
add_bias=add_bias)
diag_logits = layers.dense_layer(dense1,
'diag_logits',
hidden_units=nlabels,
activation=tf.identity,
training=training,
normalisation=norm,
add_bias=add_bias)
return diag_logits
