def encoder_model_200(input_shape=(160, 192, 160, 1), bottleneck=200):
enc = Sequential()
enc.add(Conv3D(64, 5, padding='same', strides=2, input_shape=input_shape))
enc.add(LeakyReLU(alpha=.2))
enc.add(Conv3D(128, 5, padding='same', strides=2))
enc.add(LeakyReLU(alpha=.2))
enc.add(Conv3D(128, 5, padding='same', strides=2))
enc.add(LeakyReLU(alpha=.2))
enc.add(Conv3D(256, 5, padding='same', strides=2))
enc.add(LeakyReLU(alpha=.2))
enc.add(Conv3D(256, 5, padding='same', strides=2))
enc.add(LeakyReLU(alpha=.2))
enc.add(Flatten())
enc.add(Dense(bottleneck, activation='sigmoid'))
enc.add(Dense(256 * 5 * 6 * 5))
enc.add(Reshape((5, 6, 5, 256)))
enc.add(
Deconvolution3D(filters=256,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=256,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=128,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=64,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=1,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.summary()
return enc
def get_up_convolution(n_filters, pool_size, kernel_size=(2, 2, 2), strides=(2, 2, 2),
deconvolution=False):
if deconvolution:
return Deconvolution3D(filters=n_filters, kernel_size=kernel_size,
strides=strides, data_format="channels_last")
else:
return UpSampling3D(size=pool_size, data_format="channels_last")
def get_up_convolution(n_filters, pool_size, kernel_size=(2, 2, 2), strides=(2, 2, 2),
deconvolution=False):
if deconvolution:
return Deconvolution3D(filters=n_filters, kernel_size=kernel_size,
strides=strides)
else:
return UpSampling3D(size=pool_size)
def CAE3D_deconv(img_width, img_height, win_length):
"""
int win_length: Length of window of frames
Replace Upsampling with Deconv
"""
input_shape = (win_length, img_width, img_height, 1)
input_window = Input(shape=input_shape)
temp_pool = 2
temp_depth = 5
x = Conv3D(16, (temp_depth, 3, 3), activation='relu',
padding='same')(input_window)
x = MaxPooling3D((2, 2, 2), padding='same')(x)
#x = Conv3D(8, (temp_depth, 3, 3), activation='relu', padding='same')(x)
#x = MaxPooling3D((temp_pool, 2, 2), padding='same')(x)
x = Dropout(0.25)(x)
x = Conv3D(8, (temp_depth, 3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling3D((temp_pool, 2, 2), padding='same')(x)
x = Deconvolution3D(8, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(encoded)
x = Deconvolution3D(16, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(x)
decoded = Conv3D(1, (temp_depth, 3, 3), activation='tanh',
padding='same')(x)
autoencoder = Model(input_window, decoded)
autoencoder.compile(optimizer='adadelta', loss='mean_squared_error')
model_type = 'conv'
model_name = 'CAE3D_Deconv-pooling-win_{}'.format(win_length)
model = autoencoder
return model, model_name, model_type
def unet_inference(model_weight_file,
loss_func=dice_coefficient_loss_gen,
eval_metric=dice_coefficient,
base_filter=8,
patch_size=(1, 128, 128, 128),
depth=3,
final_activation='sigmoid'):
base_filter = base_filter
inputs = Input(patch_size)
conv_kernal = (3, 3, 3)
padding = 'same'
strides = (1, 1, 1)
pool_size = (2, 2, 2)
upsample_kernal = (2, 2, 2)
#Downsampling block
layers_downsample = []
current_layer = inputs
current_filter_size = base_filter * 2
for layer in range(depth + 1):
layer_conv = conv_block(current_filter_size, current_layer,
conv_kernal, padding, strides)
if (layer < depth):
current_layer = MaxPooling3D(pool_size=pool_size)(layer_conv)
layers_downsample.append([layer_conv, current_layer])
current_filter_size = current_filter_size * 2
else:
current_layer = layer_conv
layers_downsample.append([layer_conv])
#Upsampling block
for layer in range(depth - 1, -1, -1):
deconv = Deconvolution3D(filters=current_filter_size,
kernel_size=upsample_kernal,
strides=upsample_kernal)(current_layer)
concat = concatenate([deconv, layers_downsample[layer][0]], axis=1)
current_filter_size = current_filter_size // 2
current_layer = conv_block(current_filter_size, concat, conv_kernal,
padding, strides)
final_layer = Conv3D(5, (1, 1, 1))(current_layer)
act = Activation(final_activation)(final_layer)
model = Model(inputs=inputs, outputs=act)
model.load_weights(model_weight_file)
model.compile(optimizer=Adam(learning_rate=0.00001),
loss=loss_func,
metrics=[eval_metric])
#print(model.summary())
return model
def create_up_convolution(input_layer, n_filters, strided_conv_size, kernel_size=(2, 2, 2), strides=(2, 2, 2),
deconvolution=False):
'''
Construct upsampling block.
:param deconvolution: Boolean - If True use deconvolution (transposed3D convolution), if False use Upsampling (default is False)
'''
if deconvolution:
return Deconvolution3D(filters=n_filters, kernel_size=kernel_size,
strides=strides, kernel_initializer='he_normal', name='DeConv'+str(n_filters))(input_layer)
else:
return UpSampling3D(size=strided_conv_size)(input_layer)
def upward_layer(cls, input0, input1, n_convolutions, n_output_channels, kernel_size=(2, 2, 2), strides=(2, 2, 2)):
merged = concatenate([input0, input1], axis=4)
inl = merged
for _ in range(n_convolutions - 1):
inl = PReLU()(
Conv3D(n_output_channels * 4, (5, 5, 5), padding='same')(inl)
)
conv = Conv3D(n_output_channels * 4, (5, 5, 5), padding='same')(inl)
add_u = add([conv, merged])
upsample = Deconvolution3D(filters=n_output_channels, kernel_size=kernel_size, strides=strides)(add_u)
return PReLU()(upsample)
def get_upconv(depth, nb_filters, pool_size, image_shape, kernel_size=(2, 2, 2), strides=(2, 2, 2),
deconvolution=False):
if deconvolution:
return Deconvolution3D(filters=nb_filters, kernel_size=kernel_size,
output_shape=compute_level_output_shape(filters=nb_filters, depth=depth,
pool_size=pool_size, image_shape=image_shape),
strides=strides, input_shape=compute_level_output_shape(filters=nb_filters,
depth=depth+1,
pool_size=pool_size,
image_shape=image_shape))
else:
return UpSampling3D(size=pool_size)
def brain_enc_model(input_shape=(160, 192, 160, 1)):
enc = Sequential()
enc.add(
Conv3D(8, (3, 3, 3),
padding='same',
activation='relu',
input_shape=input_shape))
enc.add(
MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same'))
enc.add(Conv3D(8, (3, 3, 3), padding='same', activation='relu'))
enc.add(
MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same'))
enc.add(Conv3D(8, (3, 3, 3), padding='same', activation='relu'))
enc.add(
MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same'))
enc.add(
Deconvolution3D(filters=8,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=8,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.add(
Deconvolution3D(filters=8,
kernel_size=4,
padding='same',
strides=2,
activation='relu'))
enc.summary()
return enc
def decode_layer(self, kernel_num, kernel_size, input, code_layer):
deconv = Deconvolution3D(kernel_num, kernel_size, strides=(1, 2, 2), activation='relu', padding='same',
kernel_initializer='he_normal')(input)
# deconv = Conv3D(kernel_num, kernel_size, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling3D(size=(1, 2, 2))(input))
merge = Concatenate(axis=4)([deconv, code_layer])
conv = Conv3D(kernel_num, kernel_size, activation='relu', padding='same',
kernel_initializer='he_normal')(merge)
conv = Dropout(self.drop)(conv)
res = layers.add([deconv, conv])
return res
def up_convolution_block(self,
name,
input_layer,
n_filters,
pool_size,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
deconvolution=False):
if deconvolution:
return Deconvolution3D(filters=n_filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='he_normal',
name=name + '_deconv')(input_layer)
return UpSampling3D(size=pool_size,
name=name + '_Upsampling')(input_layer)
def get_up_convolution(inputs,
filter_num,
deconv=False,
weight_decay=0.0,
batch_norm=False):
if deconv:
deconv = Deconvolution3D(filters=filter_num,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(inputs)
if batch_norm:
deconv = BatchNormalization(axis=-1)(deconv)
return deconv
else:
return UpSampling3D(size=(2, 2, 2))(inputs)
def vnet_struct(self, input_layer):
# Layer 1
conv_1 = Conv3D(16, (5, 5, 5), padding='same')(input_layer)
repeat_1 = concatenate([input_layer] * 16)
add_1 = add([conv_1, repeat_1])
# prelu_1_1 = PReLU()(add_1)
downsample_1 = Conv3D(filters=32, kernel_size=(1, 4, 4), strides=(1, 4, 4))(add_1)
prelu_1_2 = PReLU()(downsample_1)
# Layer 2,3,4
out2, left2 = self.downward_layer(input_layer=prelu_1_2, n_convolutions=2, n_output_channels=64)
out3, left3 = self.downward_layer(out2, 3, 128)
out4, left4 = self.downward_layer(out3, 3, 256)
# Layer 5
conv_5_1 = Conv3D(256, (5, 5, 5), padding='same')(out4)
prelu_5_1 = PReLU()(conv_5_1)
conv_5_2 = Conv3D(256, (5, 5, 5), padding='same')(prelu_5_1)
prelu_5_2 = PReLU()(conv_5_2)
conv_5_3 = Conv3D(256, (5, 5, 5), padding='same')(prelu_5_2)
add_5 = add([conv_5_3, out4])
prelu_5_1 = PReLU()(add_5)
downsample_5 = Deconvolution3D(filters=128, kernel_size=(2, 2, 2), strides=(2, 2, 2))(prelu_5_1)
prelu_5_2 = PReLU()(downsample_5)
# Layer 6,7,8
out6 = self.upward_layer(input0=prelu_5_2, input1=left4, n_convolutions=3, n_output_channels=64)
out7 = self.upward_layer(out6, left3, 3, 32)
out8 = self.upward_layer(out7, left2, 2, 16, kernel_size=(1, 4, 4), strides=(1, 4, 4))
# Layer 9
merged_9 = concatenate([out8, add_1], axis=4)
conv_9_1 = Conv3D(32, (5, 5, 5), padding='same')(merged_9)
add_9 = add([conv_9_1, merged_9])
conv_9_2 = Conv3D(4, (1, 1, 1), padding='same')(add_9)
softmax = Softmax()(conv_9_2)
return softmax
def get_up_convolution(inputs,
n_filters,
pool_size,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
deconvolution=False,
activation=None,
batch_normalization=False,
instance_normalization=False,
training=False):
if deconvolution:
layer = Deconvolution3D(filters=n_filters,
kernel_size=kernel_size,
strides=strides)(inputs)
if batch_normalization:
layer = BatchNormalization(axis=-1)(layer, training=training)
elif instance_normalization:
layer = InstanceNormalization(axis=-1)(layer, training=training)
if activation is None:
return Activation('relu')(layer)
else:
return get_activation(activation, layer)
else:
return UpSampling3D(size=pool_size)(inputs)
def build_model_alt(self,
num_layers,
n_base_filters,
deconvolution,
use_bn=False):
"""
Create a 3D Unet model with a variable number of layers and initial number of filters
:param num_layers: number of layers (i.e. number of skip connections + 1)
:param n_base_filters: number of filters to use in the first conv layer
:param deconvolution: True for Deconvolution3D, False for UpSampling3D
:param use_bn: True to use BatchNormalisation, False otherwise
:return: Keras model
"""
POOL_SIZE = (2, 2, 2)
POOL_STRIDE = (2, 2, 2)
CONV_KERNEL = (3, 3, 3)
CONV_STRIDE = (1, 1, 1)
DECONV_KERNEL = (2, 2, 2)
DECONV_STRIDE = (2, 2, 2)
UPSAMPLE_SIZE = (2, 2, 2)
FEATURE_AXIS = -1
self._title = "UNet3D_{}layer_{}flt_deconv{}".format(
num_layers, n_base_filters, int(deconvolution))
self._title += "_BN" if use_bn else ""
inputs = self._input
current_layer = inputs
layers = list()
# Contracting path
for layer_ix in range(num_layers):
# Two conv layers, note the difference in the number of filters
contr_conv1 = Conv3D(filters=n_base_filters * (2**layer_ix),
kernel_size=CONV_KERNEL,
strides=CONV_STRIDE,
padding="same",
activation="relu",
kernel_initializer="he_normal")(current_layer)
if use_bn:
contr_conv1 = BatchNormalization(
axis=FEATURE_AXIS)(contr_conv1)
contr_conv2 = Conv3D(filters=n_base_filters * (2**layer_ix) * 2,
kernel_size=CONV_KERNEL,
strides=CONV_STRIDE,
padding="same",
activation="relu",
kernel_initializer="he_normal")(contr_conv1)
if use_bn:
contr_conv2 = BatchNormalization(
axis=FEATURE_AXIS)(contr_conv2)
# Do not include maxpooling in the final bottom layer
if layer_ix < num_layers - 1:
current_layer = MaxPooling3D(pool_size=POOL_SIZE,
strides=POOL_STRIDE,
padding="same")(contr_conv2)
layers.append([contr_conv1, contr_conv2, current_layer])
else:
current_layer = contr_conv2
layers.append([contr_conv1, contr_conv2])
# Expanding path
for layer_ix in range(num_layers - 2, -1, -1):
if deconvolution:
exp_deconv = Deconvolution3D(
filters=current_layer._keras_shape[-1],
kernel_size=DECONV_KERNEL,
strides=DECONV_STRIDE)(current_layer)
else:
exp_deconv = UpSampling3D(size=UPSAMPLE_SIZE)(current_layer)
concat_layer = Concatenate(axis=FEATURE_AXIS)(
[exp_deconv, layers[layer_ix][1]])
current_layer = Conv3D(
filters=layers[layer_ix][1]._keras_shape[FEATURE_AXIS],
kernel_size=CONV_KERNEL,
strides=CONV_STRIDE,
padding="same",
activation="relu",
kernel_initializer="he_normal")(concat_layer)
if use_bn:
current_layer = BatchNormalization(
axis=FEATURE_AXIS)(current_layer)
current_layer = Conv3D(
filters=layers[layer_ix][1]._keras_shape[FEATURE_AXIS],
kernel_size=CONV_KERNEL,
strides=CONV_STRIDE,
padding="same",
activation="relu",
kernel_initializer="he_normal")(current_layer)
if use_bn:
current_layer = BatchNormalization(
axis=FEATURE_AXIS)(current_layer)
act = Conv3D(self._num_classes, (1, 1, 1),
activation="softmax",
padding="same",
kernel_initializer="he_normal")(current_layer)
self._model = Model(inputs=[inputs], outputs=[act])
return self._model
activation='relu')(in_layer)
cn2 = Conv3D(8, kernel_size=(3, 3, 3), padding='same',
activation='linear')(cn1)
bn2 = Activation('relu')(cn2)
dn1 = MaxPooling3D((2, 2, 2))(bn2)
cn3 = Conv3D(16, kernel_size=(3, 3, 3), padding='same',
activation='linear')(dn1)
bn3 = Activation('relu')(cn3)
dn2 = MaxPooling3D((1, 2, 2))(bn3)
cn4 = Conv3D(32, kernel_size=(3, 3, 3), padding='same',
activation='linear')(dn2)
bn4 = Activation('relu')(cn4)
up1 = Deconvolution3D(16,
kernel_size=(3, 3, 3),
strides=(1, 2, 2),
padding='same')(bn4)
cat1 = concatenate([up1, bn3])
up2 = Deconvolution3D(8,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(cat1)
pre_out = concatenate([up2, bn2])
pre_out = Conv3D(1,
kernel_size=(1, 1, 1),
padding='same',
activation='sigmoid')(pre_out)
def C3D_AE_no_pool(img_width,
img_height,
win_length,
regularizer_list=[],
channels=1):
"""
3DCAE model
"""
input_shape = (win_length, img_width, img_height, channels)
input_window = Input(shape=input_shape)
temp_pool = 2
temp_depth = 5
x = Conv3D(16, (5, 3, 3), activation='relu', padding='same')(input_window)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
x = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(1, 2, 2),
padding='same')(x)
if 'Dropout' in regularizer_list:
x = Dropout(0.25)(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
x = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(2, 2, 2),
padding='same')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
encoded = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(2, 2, 2),
padding='same')(x)
x = Deconvolution3D(8, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(encoded)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
#Double all the dimensions if win_length is even other wise double the H and W, change T to 2*T-1
if win_length % 2 == 0:
x = Deconvolution3D(8, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
else:
#Deconvolution formula for valid padding
#out=stride*input-stride+kernel_size
input_temporal_size = int((win_length + 1) / 2)
# print(input_temporal_size)
x = Deconvolution3D(8, (input_temporal_size, 2, 2),
strides=(1, 2, 2),
activation='relu',
padding='valid')(x)
# if 'BN' in regularizer_list:
# x= BatchNormalization()(x)
x = Deconvolution3D(16, (temp_depth, 3, 3),
strides=(1, 2, 2),
activation='relu',
padding='same')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
decoded = Conv3D(channels, (5, 3, 3),
activation='tanh',
padding='same',
name='decoded')(x)
autoencoder = Model(input_window, decoded, name="R")
autoencoder.compile(optimizer='adadelta', loss='mean_squared_error')
model_type = '3Dconv'
model_name = 'C3DAE-no_pool'
for reg in regularizer_list:
model_name += '-' + reg
model = autoencoder
return model, model_name, model_type
def diff_ROI_C3D_AE_no_pool(img_width,
img_height,
win_length,
regularizer_list=[],
channels=1,
lambda_S=1,
lambda_T=1,
d_type=None):
"""
diff-ROI-3DCAE model
"""
def multiply(x):
image, mask = x #could be K.stack([mask]*3, axis=-1) too
return mask * image
input_shape = (win_length, img_width, img_height, channels)
input_diff_shape = (win_length - 1, img_width, img_height, channels)
input_window = Input(shape=input_shape)
input_mask = Input(shape=input_shape)
input_diff_mask = Input(shape=input_diff_shape)
temp_pool = 2
temp_depth = 5
x = Conv3D(16, (5, 3, 3), activation='relu', padding='same')(input_window)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
x = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(1, 2, 2),
padding='same')(x)
if 'Dropout' in regularizer_list:
x = Dropout(0.25)(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
x = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(2, 2, 2),
padding='same')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
encoded = Conv3D(8, (5, 3, 3),
activation='relu',
strides=(2, 2, 2),
padding='same')(x)
x = Deconvolution3D(8, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(encoded)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
#Double all the dimensions if win_length is even other wise double the H and W, change T to 2*T-1
if win_length % 2 == 0:
x = Deconvolution3D(8, (temp_depth, 3, 3),
strides=(2, 2, 2),
activation='relu',
padding='same')(x)
else:
#Deconvolution formula for valid padding
#out=stride*input-stride+kernel_size
input_temporal_size = int((win_length + 1) / 2)
# print(input_temporal_size)
x = Deconvolution3D(8, (input_temporal_size, 2, 2),
strides=(1, 2, 2),
activation='relu',
padding='valid')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
x = Deconvolution3D(16, (temp_depth, 3, 3),
strides=(1, 2, 2),
activation='relu',
padding='same')(x)
if 'BN' in regularizer_list:
x = BatchNormalization()(x)
layer_name = 'decoded'
if d_type != None:
layer_name = d_type + '_' + layer_name
decoded = Conv3D(channels, (5, 3, 3),
activation='tanh',
padding='same',
name=layer_name)(x)
#Model_name
model_name = "R"
if d_type != None:
model_name = d_type + '_AE'
autoencoder = Model(inputs=[input_window, input_mask, input_diff_mask],
outputs=decoded,
name="R")
autoencoder.compile(optimizer='adadelta', loss=ROI_diff_mse_joint_loss(input_mask,input_diff_mask,lambda_S,lambda_T), \
metrics=[ROI_mean_squared_error_loss(input_mask),ROI_diff_temporal_loss(input_mask,input_diff_mask)])
# autoencoder.compile(optimizer='adadelta', loss='mean_squared_error')
model_type = '3Dconv'
model_name = 'diff_ROI_C3DAE_no_pool'
for reg in regularizer_list:
model_name += '-' + reg
model = autoencoder
return model, model_name, model_type
def get_vnet(self):
inputs = Input((self.img_depth, self.img_rows, self.img_cols, self.img_channel))
# 卷积层1
conv1 = self.encode_layer(32, [1, 3, 3], inputs)
# 下采样1
down1 = self.down_operation(64, [1, 3, 3], conv1)
# 卷积层2
conv2 = self.encode_layer(64, [1, 3, 3], down1)
# 下采样2
down2 = self.down_operation(128, [1, 3, 3], conv2)
# 卷积层3
conv3 = self.encode_layer(128, [1, 3, 3], down2)
# 下采样3
down3 = self.down_operation(256, [1, 3, 3], conv3)
# 卷积层4
conv4 = self.encode_layer(256, [1, 3, 3], down3)
# 下采样4
down4 = self.down_operation(512, [1, 3, 3], conv4)
# 卷积层5
conv5 = self.encode_layer(512, [1, 3, 3], down4)
conv5 = Conv3D(512, [3, 1, 1], activation='relu', padding='valid',
kernel_initializer='he_normal')(conv5)
#######################################################################################################################
# 反卷积6
deconv6 = Deconvolution3D(256, [1, 3, 3], strides=(1, 2, 2), activation='relu', padding='same',
kernel_initializer='he_normal')(conv5)
conv4 = Conv3D(256, [3, 1, 1], activation='relu', padding='valid',
kernel_initializer='he_normal')(conv4)
merge6 = Concatenate(axis=4)([deconv6, conv4])
conv6 = Conv3D(256, [1, 3, 3], activation='relu', padding='same',
kernel_initializer='he_normal')(merge6)
conv6 = Dropout(self.drop)(conv6)
res6 = layers.add([deconv6, conv6])
#######################################################################################################################
#######################################################################################################################
# 反卷积7
deconv7 = Deconvolution3D(128, [1, 3, 3], strides=(1, 2, 2), activation='relu', padding='same',
kernel_initializer='he_normal')(res6)
conv3 = Conv3D(128, [3, 1, 1], activation='relu', padding='valid',
kernel_initializer='he_normal')(conv3)
# conv3 = Conv3D(128, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv3)
merge7 = Concatenate(axis=4)([deconv7, conv3])
conv7 = Conv3D(128, [1, 3, 3], activation='relu', padding='same',
kernel_initializer='he_normal')(merge7)
conv7 = Dropout(self.drop)(conv7)
res7 = layers.add([deconv7, conv7])
#######################################################################################################################
#######################################################################################################################
# 反卷积8
deconv8 = Deconvolution3D(64, [1, 3, 3], strides=(1, 2, 2), activation='relu', padding='same',
kernel_initializer='he_normal')(res7)
conv2 = Conv3D(64, [3, 1, 1], activation='relu', padding='valid',
kernel_initializer='he_normal')(conv2)
# conv2 = Conv3D(64, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv2)
# conv2 = Conv3D(64, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv2)
merge8 = Concatenate(axis=4)([deconv8, conv2])
conv8 = Conv3D(64, [1, 3, 3], activation='relu', padding='same',
kernel_initializer='he_normal')(merge8)
conv8 = Dropout(self.drop)(conv8)
res8 = layers.add([deconv8, conv8])
#######################################################################################################################
#######################################################################################################################
# 反卷积9
deconv9 = Deconvolution3D(32, [1, 3, 3], strides=(1, 2, 2), activation='relu', padding='same',
kernel_initializer='he_normal')(res8)
conv1 = Conv3D(32, [3, 1, 1], activation='relu', padding='valid',
kernel_initializer='he_normal')(conv1)
# conv1 = Conv3D(32, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv1)
# conv1 = Conv3D(32, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv1)
# conv1 = Conv3D(32, [3, 1, 1], activation='relu', padding='valid',
# kernel_initializer='he_normal')(conv1)
merge9 = Concatenate(axis=4)([deconv9, conv1])
conv9 = Conv3D(32, [1, 3, 3], activation='relu', padding='same',
kernel_initializer='he_normal')(merge9)
conv9 = Dropout(self.drop)(conv9)
res9 = layers.add([deconv9, conv9])
#######################################################################################################################
conv10 = Conv3D(1, [1, 1, 1], activation='sigmoid')(res9)
model = Model(inputs=inputs, outputs=conv10)
# 在这里可以自定义损失函数loss和准确率函数accuracy
# model.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy'])
losses = WeightedBinaryCrossEntropy()
model.compile(optimizer=Adam(lr=1e-4), loss=losses.weighted_binary_crossentropy, metrics=['accuracy',dice_coef])
# model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss, metrics=['accuracy',dice_coef])
# model.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy',dice_coef])
print('model compile')
return model
def CNN_3D_AE(input_shape=(160, 192, 160, 1), bottleneck=200):
filters = [4, 8, 16, 32, 64]
model = Sequential()
model.add(
Conv3D(filters=filters[0],
kernel_size=(3, 3, 3),
padding='same',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(Conv3D(filters=filters[0], kernel_size=(3, 3, 3),
padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=2, padding='valid'))
model.add(Conv3D(filters=filters[1], kernel_size=(3, 3, 3),
padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(filters=filters[1], kernel_size=(3, 3, 3),
padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=2, padding='valid'))
model.add(Conv3D(filters=filters[2], kernel_size=(3, 3, 3),
padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(filters=filters[2], kernel_size=(3, 3, 3),
padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=2, padding='valid'))
model.add(Conv3D(filters=filters[3], kernel_size=(3, 3, 3),
padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(filters=filters[3], kernel_size=(3, 3, 3),
padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=2, padding='valid'))
model.add(Conv3D(filters=filters[4], kernel_size=(3, 3, 3),
padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(filters=filters[4], kernel_size=(3, 3, 3),
padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=2, padding='valid'))
model.add(Flatten())
model.add(Dense(bottleneck, activation='sigmoid'))
model.add(Dense(64 * 5 * 6 * 5))
model.add(Reshape((5, 6, 5, 64)))
model.add(
Deconvolution3D(filters=64,
kernel_size=3,
padding='same',
strides=2,
activation='relu'))
model.add(
Deconvolution3D(filters=32,
kernel_size=3,
padding='same',
strides=2,
activation='relu'))
model.add(
Deconvolution3D(filters=16,
kernel_size=3,
padding='same',
strides=2,
activation='relu'))
model.add(
Deconvolution3D(filters=8,
kernel_size=3,
padding='same',
strides=2,
activation='relu'))
model.add(
Deconvolution3D(filters=1,
kernel_size=3,
padding='same',
strides=2,
activation='relu'))
model.summary()
return model
