def u_net(self, inputs, prefix, squeeze=4):
x = inputs
skip_connections = []
for i in range(squeeze):
x = Conv2D(self.filters * (i + 1),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + f'contract_Conv1_{i}')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + f'contract_BN1_{i}')(x)
x = Activation('relu', name=prefix + f'contract_relu1_{i}')(x)
x = Conv2D(self.filters * (i + 1),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + f'contract_Conv2_{i}')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + f'contract_BN2_{i}')(x)
x = Activation('relu', name=prefix + f'contract_relu2_{i}')(x)
skip_connections.append(x)
x = Conv2D(self.filters * (i + 1) * 2,
kernel_size=4,
strides=2,
padding='same',
use_bias=False,
activation='relu',
name=prefix + f'contract_Conv3_{i}')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + f'contract_BN3_{i}')(x)
#expand out width
x = Conv2D(self.filters * squeeze**2,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'mid_1')(x)
x = Conv2D(self.filters * squeeze**2,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'mid_2')(x)
for i in range(squeeze):
#up conv2x2
x = Conv2DTranspose(self.filters * (squeeze - i),
kernel_size=4,
strides=2,
padding='same',
activation='relu',
name=prefix + f'expand_Conv1_{i}')(x)
x = Concatenate(name=prefix + f'concat{i}',
axis=-1)([skip_connections.pop(), x])
x = Conv2D(self.filters * (squeeze - i),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + f'expand_Conv2_{i}')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + f'expand_BN1_{i}')(x)
x = Activation('relu', name=prefix + f'expand_relu_1_{i}')(x)
x = Conv2D(self.filters * (squeeze - i),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + f'expand_Conv3_{i}')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + f'expand_BN2_{i}')(x)
x = Activation('relu', name=prefix + f'expand_relu_2_{i}')(x)
return x
c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(inputs) c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(c1) p1 = MaxPooling2D((2, 2))(c1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(p1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(c2) p2 = MaxPooling2D((2, 2))(c2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(p2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(c3) p3 = MaxPooling2D((2, 2))(c3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(p3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(c4) u5 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(c4) u5 = concatenate([u5, c3]) c5 = Conv2D(32, (3, 3), activation='relu', padding='same')(u5) c5 = Conv2D(32, (3, 3), activation='relu', padding='same')(c5) u6 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same')(c5) u6 = concatenate([u6, c2]) c6 = Conv2D(16, (3, 3), activation='relu', padding='same')(u6) c6 = Conv2D(16, (3, 3), activation='relu', padding='same')(c6) u7 = Conv2DTranspose(8, (2, 2), strides=(2, 2), padding='same')(c6) u7 = concatenate([u7, c1], axis=3) c7 = Conv2D(8, (3, 3), activation='relu', padding='same')(u7) c7 = Conv2D(8, (3, 3), activation='relu', padding='same')(c7) outputs = Conv2D(1, (1, 1), activation='sigmoid')(c7)
conv2d_6 = Conv2D(128, 1, padding='same')(ac_5)
bn_6 = BatchNormalization()(conv2d_6)
ac_6 = ReLU()(bn_6)
flat2 = Flatten()(ac_6)
return flat2
dense1 = Dense(128)
dense2 = Dense(128 * 8 * 8)
reshape = Reshape((8, 8, 128))
conv1 = Conv2D(256, 3, padding='same')
conv2 = Conv2D(1, 3, activation='relu', padding='same')
relu = ReLU()
convtans1 = Conv2DTranspose(128, 3, strides=2, padding='same')
convtans2 = Conv2DTranspose(64, 3, strides=2, padding='same')
def generate(inp3):
x = dense1(inp3)
x = dense2(x)
x = relu(x)
x = reshape(x)
x = conv1(x)
x = relu(x)
x = convtans1(x)
x = relu(x)
# GENERATOR
g = Sequential()
g.add(
Dense(units=7 * 7 * 512,
input_dim=latent_dim,
activation=LeakyReLU(alpha=LEAKY_RELU_ALPHA)))
g.add(BatchNormalization())
g.add(Reshape(target_shape=(7, 7, 512)))
g.add(
Conv2DTranspose(filters=128,
kernel_size=[4, 4],
strides=2,
padding="same",
activation=LeakyReLU(alpha=LEAKY_RELU_ALPHA)))
g.add(BatchNormalization())
g.add(Dropout(rate=DROPOUT_RATE))
g.add(
Conv2DTranspose(filters=32,
kernel_size=[4, 4],
strides=2,
padding="same",
activation=LeakyReLU(alpha=LEAKY_RELU_ALPHA)))
g.add(BatchNormalization())
def upsample_conv(filters, kernel_size, strides, padding):
return Conv2DTranspose(filters, kernel_size, strides=strides, padding=padding)
def conv2dtranspose(filters: int):
return Conv2DTranspose(filters=filters,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')
def __init__(
self,
n_scales=4,
n_filters=128,
kernel_size=3,
bn=False,
n_convs_per_scale=DEFAULT_N_CONVS_PER_SCALE,
communications_between_scales=DEFAULT_COMMUNICATION_BETWEEN_SCALES,
beta=0.2,
n_outputs=1,
**kwargs,
):
super(FocNet, self).__init__(**kwargs)
self.n_scales = n_scales
self.n_filters = n_filters
self.kernel_size = kernel_size
self.bn = bn
self.n_convs_per_scale = n_convs_per_scale
self.communications_between_scales = communications_between_scales
self.beta = beta
self.n_outputs = n_outputs
self.pooling = AveragePooling2D(padding='same')
self.unpoolings_per_scale = [[
Conv2DTranspose(
self.n_filters,
self.kernel_size,
strides=(2, 2),
padding='same',
) for _ in range(
len(self.communications_between_scales[i_scale]) // 2)
] for i_scale in range(self.n_scales - 1)]
# unpooling is not specified in the paper, but in the code
# you can see a deconv is used
# https://github.com/hsijiaxidian/FOCNet/blob/master/FracDCNN.m#L415
self.n_switches_per_scale = []
self.compute_n_switches_per_scale()
self.switches_per_scale = [[
SwitchLayer() for _ in range(self.n_switches_per_scale[i_scale])
] for i_scale in range(self.n_scales)]
self.first_conv = Conv2D(
self.n_filters, # we output a grayscale image
self.
kernel_size, # we simply do a linear combination of the features
padding='same',
use_bias=True,
)
self.conv_blocks_per_scale = [[
FocConvBlock(
n_filters=self.n_filters,
kernel_size=self.kernel_size,
bn=self.bn,
) for _ in range(n_conv_blocks)
] for n_conv_blocks in self.n_convs_per_scale]
self.final_conv = Conv2D(
self.n_outputs,
1, # we simply do a linear combination of the features
padding='same',
use_bias=True,
)
self.needs_to_compute = {}
self.build_needs_to_compute()
def SE_U_Net_2D(image_shape,
activation='elu',
feature_maps=[16, 32, 64, 128, 256],
depth=4,
drop_values=[0.1, 0.1, 0.2, 0.2, 0.3],
spatial_dropout=False,
batch_norm=False,
k_init='he_normal',
loss_type="bce",
optimizer="sgd",
lr=0.002,
n_classes=1):
"""Create 2D U-Net with squeeze-excite blocks.
Reference `Squeeze and Excitation Networks <https://arxiv.org/abs/1709.01507>`_.
Parameters
----------
image_shape : 2D tuple
Dimensions of the input image.
activation : str, optional
Keras available activation type.
feature_maps : array of ints, optional
Feature maps to use on each level. Must have the same length as the
``depth+1``.
depth : int, optional
Depth of the network.
drop_values : float, optional
Dropout value to be fixed. If no value is provided the default
behaviour will be to select a piramidal value starting from ``0.1``
and reaching ``0.3`` value.
spatial_dropout : bool, optional
Use spatial dropout instead of the `normal` dropout.
batch_norm : bool, optional
Make batch normalization.
k_init : string, optional
Kernel initialization for convolutional layers.
loss_type : str, optional
Loss type to use, three type available: ``bce`` (Binary Cross Entropy)
, ``w_bce`` (Weighted BCE, based on weigth maps) and ``w_bce_dice``
(Weighted loss: ``weight1*BCE + weight2*Dice``).
optimizer : str, optional
Optimizer used to minimize the loss function. Posible options:
``sgd`` or ``adam``.
lr : float, optional
Learning rate value.
n_classes: int, optional
Number of classes.
Returns
-------
model : Keras model
Model containing the U-Net.
Calling this function with its default parameters returns the following
network:
.. image:: img/unet.png
:width: 100%
:align: center
Image created with `PlotNeuralNet <https://github.com/HarisIqbal88/PlotNeuralNet>`_.
"""
if len(feature_maps) != depth + 1:
raise ValueError("feature_maps dimension must be equal depth+1")
if len(drop_values) != depth + 1:
raise ValueError("'drop_values' dimension must be equal depth+1")
dinamic_dim = (None, ) * (len(image_shape) - 1) + (image_shape[-1], )
x = Input(dinamic_dim)
#x = Input(image_shape)
inputs = x
if loss_type == "w_bce":
weights = Input(image_shape)
# List used to access layers easily to make the skip connections of the U-Net
l = []
# ENCODER
for i in range(depth):
x = Conv2D(feature_maps[i], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
x = squeeze_excite_block(x)
if drop_values is not None:
if spatial_dropout:
x = SpatialDropout2D(drop_values[i])(x)
else:
x = Dropout(drop_values[i])(x)
x = Conv2D(feature_maps[i], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
x = squeeze_excite_block(x)
l.append(x)
x = MaxPooling2D((2, 2))(x)
# BOTTLENECK
x = Conv2D(feature_maps[depth], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
if drop_values is not None:
if spatial_dropout:
x = SpatialDropout2D(drop_values[depth])(x)
else:
x = Dropout(drop_values[depth])(x)
x = Conv2D(feature_maps[depth], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
# DECODER
for i in range(depth - 1, -1, -1):
x = Conv2DTranspose(feature_maps[i], (2, 2),
strides=(2, 2),
padding='same')(x)
x = concatenate([x, l[i]])
x = Conv2D(feature_maps[i], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
x = squeeze_excite_block(x)
if drop_values is not None:
if spatial_dropout:
x = SpatialDropout2D(drop_values[i])(x)
else:
x = Dropout(drop_values[i])(x)
x = Conv2D(feature_maps[i], (3, 3),
activation=None,
kernel_initializer=k_init,
padding='same')(x)
x = BatchNormalization()(x) if batch_norm else x
x = Activation(activation)(x)
x = squeeze_excite_block(x)
outputs = Conv2D(n_classes, (1, 1), activation='sigmoid')(x)
# Loss type
if loss_type == "w_bce":
model = Model(inputs=[inputs, weights], outputs=[outputs])
else:
model = Model(inputs=[inputs], outputs=[outputs])
# Select the optimizer
if optimizer == "sgd":
opt = tf.keras.optimizers.SGD(lr=lr,
momentum=0.99,
decay=0.0,
nesterov=False)
elif optimizer == "adam":
opt = tf.keras.optimizers.Adam(lr=lr,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
else:
raise ValueError("Error: optimizer value must be 'sgd' or 'adam'")
# Compile the model
if loss_type == "bce":
if n_classes > 1:
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=[jaccard_index_softmax])
else:
model.compile(optimizer=opt,
loss='binary_crossentropy',
metrics=[jaccard_index])
elif loss_type == "w_bce":
model.compile(optimizer=opt,
loss=binary_crossentropy_weighted(weights),
metrics=[jaccard_index])
elif loss_type == "w_bce_dice":
model.compile(optimizer=opt,
loss=weighted_bce_dice_loss(w_dice=0.66, w_bce=0.33),
metrics=[jaccard_index])
else:
raise ValueError("'loss_type' must be 'bce', 'w_bce' or 'w_bce_dice'")
return model
def unet(num_classes, input_shape, lr_init, lr_decay):
img_input = Input(input_shape)
# Block 1
x = Conv2D(64, (3, 3), padding='same', name='block1_conv1')(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x)
x = BatchNormalization()(x)
block_1_out = Activation('relu')(x)
x = MaxPooling2D()(block_1_out)
# Block 2
x = Conv2D(128, (3, 3), padding='same', name='block2_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, (3, 3), padding='same', name='block2_conv2')(x)
x = BatchNormalization()(x)
block_2_out = Activation('relu')(x)
x = MaxPooling2D()(block_2_out)
# Block 3
x = Conv2D(256, (3, 3), padding='same', name='block3_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv3')(x)
x = BatchNormalization()(x)
block_3_out = Activation('relu')(x)
x = MaxPooling2D()(block_3_out)
# Block 4
x = Conv2D(512, (3, 3), padding='same', name='block4_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv3')(x)
x = BatchNormalization()(x)
block_4_out = Activation('relu')(x)
x = MaxPooling2D()(block_4_out)
# Block 5
x = Conv2D(512, (3, 3), padding='same', name='block5_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# UP 1
x = Conv2DTranspose(512, (2, 2), strides=(2, 2), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = concatenate([x, block_4_out])
x = Conv2D(512, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# UP 2
x = Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = concatenate([x, block_3_out])
x = Conv2D(256, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# UP 3
x = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = concatenate([x, block_2_out])
x = Conv2D(128, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# UP 4
x = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = concatenate([x, block_1_out])
x = Conv2D(64, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# last conv
x = Conv2D(num_classes, (3, 3), activation='softmax', padding='same')(x)
model = Model(img_input, x)
model.compile(optimizer=Adam(lr=lr_init, decay=lr_decay),
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
model.summary()
return model
c4 = BatchNormalization()(c4)
p4 = MaxPooling2D(pool_size=(2, 2))(c4)
c5 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p4)
c5 = BatchNormalization()(c5)
c5 = Dropout(0.3)(c5)
c5 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c5)
c5 = BatchNormalization()(c5)
u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c5)
u6 = concatenate([u6, c4])
c6 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u6)
c6 = BatchNormalization()(c6)
c6 = Dropout(0.2)(c6)
c6 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c6)
c6 = BatchNormalization()(c6)
u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c6)
u7 = concatenate([u7, c3])
def get_unet(hyperparameters):
inputs = Input(hyperparameters['input_shape'])
conv1 = Conv2D(hyperparameters['base'], (3, 3), padding='same')(inputs)
if hyperparameters['batch_norm']:
conv1 = BatchNormalization()(conv1)
conv1 = Activation('relu')(conv1)
conv1 = Conv2D(hyperparameters['base'], (3, 3), padding='same')(conv1)
if hyperparameters['batch_norm']:
conv1 = BatchNormalization()(conv1)
conv1 = Activation('relu')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
if hyperparameters['dropout'] != 0:
pool1 = Dropout(hyperparameters['dropout'])(pool1)
conv2 = Conv2D(hyperparameters['base'] * 2, (3, 3), padding='same')(pool1)
if hyperparameters['batch_norm']:
conv2 = BatchNormalization()(conv2)
conv2 = Activation('relu')(conv2)
conv2 = Conv2D(hyperparameters['base'] * 2, (3, 3), padding='same')(conv2)
if hyperparameters['batch_norm']:
conv2 = BatchNormalization()(conv2)
conv2 = Activation('relu')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
if hyperparameters['dropout'] != 0:
pool2 = Dropout(hyperparameters['dropout'])(pool2)
conv3 = Conv2D(hyperparameters['base'] * 4, (3, 3), padding='same')(pool2)
if hyperparameters['batch_norm']:
conv3 = BatchNormalization()(conv3)
conv3 = Activation('relu')(conv3)
conv3 = Conv2D(hyperparameters['base'] * 4, (3, 3), padding='same')(conv3)
if hyperparameters['batch_norm']:
conv3 = BatchNormalization()(conv3)
conv3 = Activation('relu')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
if hyperparameters['dropout'] != 0:
pool3 = Dropout(hyperparameters['dropout'])(pool3)
conv4 = Conv2D(hyperparameters['base'] * 8, (3, 3), padding='same')(pool3)
if hyperparameters['batch_norm']:
conv4 = BatchNormalization()(conv4)
conv4 = Activation('relu')(conv4)
conv4 = Conv2D(hyperparameters['base'] * 8, (3, 3), padding='same')(conv4)
if hyperparameters['batch_norm']:
conv4 = BatchNormalization()(conv4)
conv4 = Activation('relu')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
if hyperparameters['dropout'] != 0:
pool4 = Dropout(hyperparameters['dropout'])(pool4)
conv5 = Conv2D(hyperparameters['base'] * 16, (3, 3), padding='same')(pool4)
if hyperparameters['batch_norm']:
conv5 = BatchNormalization()(conv5)
conv5 = Activation('relu')(conv5)
conv5 = Conv2D(hyperparameters['base'] * 16, (3, 3), padding='same')(conv5)
if hyperparameters['batch_norm']:
conv5 = BatchNormalization()(conv5)
conv5 = Activation('relu')(conv5)
up6 = concatenate([
Conv2DTranspose(hyperparameters['base'] * 8, (2, 2),
strides=(2, 2),
padding='same')(conv5), conv4
],
axis=3)
conv6 = Conv2D(hyperparameters['base'] * 8, (3, 3), padding='same')(up6)
if hyperparameters['batch_norm']:
conv6 = BatchNormalization()(conv6)
conv6 = Activation('relu')(conv6)
conv6 = Conv2D(hyperparameters['base'] * 8, (3, 3), padding='same')(conv6)
if hyperparameters['batch_norm']:
conv6 = BatchNormalization()(conv6)
conv6 = Activation('relu')(conv6)
up7 = concatenate([
Conv2DTranspose(128,
(2, 2), strides=(2, 2), padding='same')(conv6), conv3
],
axis=3)
conv7 = Conv2D(hyperparameters['base'] * 4, (3, 3), padding='same')(up7)
if hyperparameters['batch_norm']:
conv7 = BatchNormalization()(conv7)
conv7 = Activation('relu')(conv7)
conv7 = Conv2D(hyperparameters['base'] * 4, (3, 3), padding='same')(conv7)
if hyperparameters['batch_norm']:
conv7 = BatchNormalization()(conv7)
conv7 = Activation('relu')(conv7)
up8 = concatenate([
Conv2DTranspose(hyperparameters['base'] * 2, (2, 2),
strides=(2, 2),
padding='same')(conv7), conv2
],
axis=3)
conv8 = Conv2D(hyperparameters['base'] * 2, (3, 3), padding='same')(up8)
if hyperparameters['batch_norm']:
conv8 = BatchNormalization()(conv8)
conv8 = Activation('relu')(conv8)
conv8 = Conv2D(hyperparameters['base'] * 2, (3, 3), padding='same')(conv8)
if hyperparameters['batch_norm']:
conv8 = BatchNormalization()(conv8)
conv8 = Activation('relu')(conv8)
up9 = concatenate([
Conv2DTranspose(
hyperparameters['base'],
(2, 2), strides=(2, 2), padding='same')(conv8), conv1
],
axis=3)
conv9 = Conv2D(hyperparameters['base'], (3, 3), padding='same')(up9)
if hyperparameters['batch_norm']:
conv9 = BatchNormalization()(conv9)
conv9 = Activation('relu')(conv9)
conv9 = Conv2D(hyperparameters['base'], (3, 3), padding='same')(conv9)
if hyperparameters['batch_norm']:
conv9 = BatchNormalization()(conv9)
conv9 = Activation('relu')(conv9)
conv10 = Conv2D(hyperparameters['last_layer_units'], (1, 1),
activation=hyperparameters['last_layer_activation'])(conv9)
model = Model(inputs=[inputs], outputs=[conv10])
print(model.summary())
model.compile(
loss=hyperparameters['loss'],
optimizer=hyperparameters['optimizer'](lr=hyperparameters['lr']),
metrics=hyperparameters['metrics_func'])
return model
def Nest_Net2(input_shape, num_class=1, deep_supervision=False):
nb_filter = [32, 64, 128, 256, 512]
# nb_filter = [16, 32, 64, 128, 256]
mode = 'residual' # mode='residual' seems to improve better than DS
# Handle Dimension Ordering for different backends
bn_axis = 3
inputs = Input(shape=input_shape)
conv1_1 = standard_unit(inputs, stage='11', nb_filter=nb_filter[0]) # add 要求输入输出维度相同
pool1 = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(conv1_1) # (?,128,128,32)
conv2_1 = standard_unit(pool1, stage='21', nb_filter=nb_filter[1], mode=mode)
pool2 = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(conv2_1) # (?,64,64,64)
up1_2 = Conv2DTranspose(nb_filter[0], (2, 2), strides=(2, 2), name='up12', padding='same')(conv2_1)
conv1_2 = concatenate([up1_2, conv1_1], name='merge12', axis=bn_axis) # (?,256,256,64)
conv1_2 = standard_unit(conv1_2, stage='12', nb_filter=nb_filter[0], mode=mode) # (?,256,256,32)
conv3_1 = standard_unit(pool2, stage='31', nb_filter=nb_filter[2], mode=mode)
pool3 = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(conv3_1)
up2_2 = Conv2DTranspose(nb_filter[1], (2, 2), strides=(2, 2), name='up22', padding='same')(conv3_1)
conv2_2 = concatenate([up2_2, conv2_1], name='merge22', axis=bn_axis)
conv2_2 = standard_unit(conv2_2, stage='22', nb_filter=nb_filter[1], mode=mode)
up1_3 = Conv2DTranspose(nb_filter[0], (2, 2), strides=(2, 2), name='up13', padding='same')(conv2_2)
conv1_3 = concatenate([up1_3, conv1_1, conv1_2], name='merge13', axis=bn_axis)
conv1_3 = standard_unit(conv1_3, stage='13', nb_filter=nb_filter[0], mode=mode) # (?,256,256,32)
conv4_1 = standard_unit(pool3, stage='41', nb_filter=nb_filter[3], mode=mode)
pool4 = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(conv4_1)
up3_2 = Conv2DTranspose(nb_filter[2], (2, 2), strides=(2, 2), name='up32', padding='same')(conv4_1)
conv3_2 = concatenate([up3_2, conv3_1], name='merge32', axis=bn_axis)
conv3_2 =standard_unit(conv3_2, stage='32', nb_filter=nb_filter[2], mode=mode)
up2_3 = Conv2DTranspose(nb_filter[1], (2, 2), strides=(2, 2), name='up23', padding='same')(conv3_2)
conv2_3 = concatenate([up2_3, conv2_1, conv2_2], name='merge23', axis=bn_axis)
conv2_3 = standard_unit(conv2_3, stage='23', nb_filter=nb_filter[1], mode=mode)
up1_4 = Conv2DTranspose(nb_filter[0], (2, 2), strides=(2, 2), name='up14', padding='same')(conv2_3)
conv1_4 = concatenate([up1_4, conv1_1, conv1_2, conv1_3], name='merge14', axis=bn_axis)
conv1_4 =standard_unit(conv1_4, stage='14', nb_filter=nb_filter[0], mode=mode)
conv5_1 = standard_unit(pool4, stage='51', nb_filter=nb_filter[4], mode=mode)
up4_2 = Conv2DTranspose(nb_filter[3], (2, 2), strides=(2, 2), name='up42', padding='same')(conv5_1)
conv4_2 = concatenate([up4_2, conv4_1], name='merge42', axis=bn_axis)
conv4_2 = standard_unit(conv4_2, stage='42', nb_filter=nb_filter[3], mode=mode)
up3_3 = Conv2DTranspose(nb_filter[2], (2, 2), strides=(2, 2), name='up33', padding='same')(conv4_2)
conv3_3 = concatenate([up3_3, conv3_1, conv3_2], name='merge33', axis=bn_axis)
conv3_3 = standard_unit(conv3_3, stage='33', nb_filter=nb_filter[2], mode=mode)
up2_4 = Conv2DTranspose(nb_filter[1], (2, 2), strides=(2, 2), name='up24', padding='same')(conv3_3)
conv2_4 = concatenate([up2_4, conv2_1, conv2_2, conv2_3], name='merge24', axis=bn_axis)
conv2_4 = standard_unit(conv2_4, stage='24', nb_filter=nb_filter[1], mode=mode)
up1_5 = Conv2DTranspose(nb_filter[0], (2, 2), strides=(2, 2), name='up15', padding='same')(conv2_4)
conv1_5 = concatenate([up1_5, conv1_1, conv1_2, conv1_3, conv1_4], name='merge15', axis=bn_axis)
conv1_5 =standard_unit(conv1_5, stage='15', nb_filter=nb_filter[0], mode=mode)
nestnet_output_1 = Conv2D(num_class, (1, 1), activation='sigmoid', name='output_1',
kernel_initializer='he_normal', padding='same', kernel_regularizer=l2(1e-4))(conv1_2)
nestnet_output_2 = Conv2D(num_class, (1, 1), activation='sigmoid', name='output_2',
kernel_initializer='he_normal', padding='same', kernel_regularizer=l2(1e-4))(conv1_3)
nestnet_output_3 = Conv2D(num_class, (1, 1), activation='sigmoid', name='output_3',
kernel_initializer='he_normal', padding='same', kernel_regularizer=l2(1e-4))(conv1_4)
nestnet_output_4 = Conv2D(num_class, (1, 1), activation='sigmoid', name='output_4',
kernel_initializer='he_normal', padding='same', kernel_regularizer=l2(1e-4))(conv1_5)
# using combined loss
conv_fuse = concatenate([conv1_2, conv1_3, conv1_4, conv1_5], name='merge_fuse', axis=bn_axis)
nestnet_output_5 = Conv2D(num_class, (1, 1), activation='sigmoid', name='output_5',
kernel_initializer='he_normal', padding='same', kernel_regularizer=l2(1e-4))(conv_fuse)
if deep_supervision:
model = Model(inputs=inputs, outputs=[nestnet_output_1,
nestnet_output_2,
nestnet_output_3,
nestnet_output_4, nestnet_output_5])
model.compile(optimizer=Adam(lr=1e-4),
#loss=['binary_crossentropy','binary_crossentropy','binary_crossentropy','binary_crossentropy'],
loss=[weighted_bce_dice_loss, weighted_bce_dice_loss, weighted_bce_dice_loss,
weighted_bce_dice_loss, weighted_bce_dice_loss],
loss_weights=[0.5, 0.5, 0.75, 0.5, 1.0],
metrics=[Recall(), Precision()]
)
else:
model = Model(inputs=inputs, outputs=[nestnet_output_4])
model.compile(optimizer=Adam(lr=1e-4), loss=weighted_bce_dice_loss,
metrics=[Recall(), Precision()])
model.summary()
return model
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(8, (1, 1), activation='relu', padding='same')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Conv2D(4, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(2, (1, 1), activation='relu', padding='same')(x)
B = Conv2D(1, (1, 1), activation='relu', padding='same')(x)
encoder = Model(A, B)
encoder.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(lr=0.1),
metrics=['accuracy'])
encoder.summary()
#decoder
A0 = tf.keras.layers.Input(shape=(7, 7, 1))
x = Conv2DTranspose(2, (1, 1), activation='relu', padding='same')(A0)
x = Conv2DTranspose(4, (3, 3), activation='relu', padding='same')(x)
x = Conv2DTranspose(8, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(16, (3, 3), activation='relu', padding='same')(x)
x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)
x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x)
x = Conv2DTranspose(256, (3, 3), activation='relu', padding='same')(x)
B0 = Conv2DTranspose(1, (3, 3), activation='tanh', padding='same')(x)
decoder = Model(A0, B0)
decoder.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(lr=0.1),
metrics=['accuracy'])
print(merged)
merged_model = Model([first_input, second_input, third_input],
merged,
name='merged_model')
# build decoder model
latent_inputs = Input(shape=(latent_dim + 3, ), name='z_sampling')
x = Dense(shape[1] * shape[2] * shape[3], activation='relu')(latent_inputs)
x = Reshape((shape[1], shape[2], shape[3]))(x)
filters //= 2
for i in range(3 - 1):
filters //= 2
x = Conv2DTranspose(filters=filters,
kernel_size=kernel_size,
activation='relu',
strides=strides,
padding='same')(x)
# clip_activation
outputs = Conv2DTranspose(filters=1,
kernel_size=kernel_size,
activation=clip_activation(0, 1),
padding='same',
strides=strides,
name='decoder_output')(x)
# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
plot_model(decoder, to_file='vae_cnn_decoder.png', show_shapes=True)
model = Sequential()
model.add(
Conv2D(strides=1,
kernel_size=3,
filters=12,
use_bias=True,
bias_initializer=tf.keras.initializers.RandomUniform(minval=0.05,
maxval=0.05),
padding="valid",
activation=tf.nn.relu))
model.add(
Conv2DTranspose(strides=1,
kernel_size=3,
filters=12,
use_bias=True,
bias_initializer=tf.keras.initializers.RandomUniform(
minval=0.05, maxval=0.05),
padding="valid",
activation=tf.nn.relu))
model.add(LeakyReLU(0.6))
model.add(Dropout(0.4))
model.add(
Conv2D(strides=1,
kernel_size=3,
filters=12,
use_bias=True,
bias_initializer=tf.keras.initializers.RandomUniform(minval=0.05,
maxval=0.05),
padding="valid",
activation=tf.nn.relu))
def build_model(inputs):
#---------contraction path----------
#convolutional layers
#Conv2D(filters, seed, activation, kernel_init)(in)
#he_normal - normal distribution (centered on 0)
#padding = same -> output img has the same dimentions
#in have to be float
c1 = Conv2D(16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(inputs)
c1 = Dropout(0.1)(c1)
c1 = Conv2D(16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c1)
p1 = MaxPooling2D((2, 2))(c1)
c2 = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p1)
c2 = Dropout(0.1)(c2)
c2 = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c2)
p2 = MaxPooling2D((2, 2))(c2)
c3 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p2)
c3 = Dropout(0.2)(c3)
c3 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c3)
p3 = MaxPooling2D((2, 2))(c3)
c4 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p3)
c4 = Dropout(0.2)(c4)
c4 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c4)
p4 = MaxPooling2D((2, 2))(c4)
c5 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p4)
c5 = Dropout(0.3)(c5)
c5 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c5)
p5 = MaxPooling2D((2, 2))(c5)
#---------expansive path----------
u6x = Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(p5)
u6x = concatenate([u6x, c5])
c6x = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u6x)
c6x = Dropout(0.2)(c6x)
c6x = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c6x)
u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c6x)
u6 = concatenate([u6, c4])
c6 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u6)
c6 = Dropout(0.2)(c6)
c6 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c6)
u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c6)
u7 = concatenate([u7, c3])
c7 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u7)
c7 = Dropout(0.2)(c7)
c7 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c7)
u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(c7)
u8 = concatenate([u8, c2])
c8 = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u8)
c8 = Dropout(0.1)(c8)
c8 = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c8)
u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same')(c8)
u9 = concatenate([u9, c1], axis=3)
c9 = Conv2D(16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u9)
c9 = Dropout(0.1)(c9)
c9 = Conv2D(16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c9)
outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9)
return outputs
Dense(1, activation='sigmoid')
])
opt = tf.keras.optimizers.Adam(lr=2e-4, beta_1=0.5)
discriminator.compile(loss='binary_crossentropy',
optimizer=opt,
metrics=['accuracy'])
discriminator.summary()
#Generator
generator = Sequential([
Dense(256, activation='relu', input_shape=(noise_dim, )),
Reshape((1, 1, 256)),
Conv2DTranspose(256, 5, activation='relu'),
BatchNormalization(),
Conv2DTranspose(128, 5, activation='relu'),
BatchNormalization(),
Conv2DTranspose(64, 5, strides=2, activation='relu'),
BatchNormalization(),
Conv2DTranspose(32, 5, activation='relu'),
BatchNormalization(),
Conv2DTranspose(1, 4, activation='sigmoid')
])
generator.summary()
noise = np.random.randn(1, noise_dim)
gen_image = generator.predict(noise)[0]
c14 = SpatialDropout2D(0.5)(c13)
c15 = Conv2D(filters=11,
kernel_size=(1, 1),
strides=(1, 1),
use_bias=True,
data_format="channels_last",
padding="same",
activation=None,
activity_regularizer=None,
kernel_initializer='glorot_normal',
name='conv10')(c14)
c16 = Conv2DTranspose(filters=11,
kernel_size=(32, 32),
strides=(16, 16),
data_format="channels_last",
padding="same",
activation=None,
kernel_initializer='glorot_normal',
name='conv11')(c15)
c17 = Reshape((-1, 11))(c16)
c18 = Activation('softmax')(c17)
rms = Adam(lr=1e-5)
mymodel = Model(inputs=c0, outputs=c18)
mymodel.compile(loss='sparse_categorical_crossentropy',
optimizer=rms,
metrics=['sparse_categorical_accuracy'])
print('ready to goo!!!')
mymodel.summary()
def get_model(IMG_HEIGHT,
IMG_WIDTH,
IMG_CHANNELS,
do_compile=False,
out_activation='sigmoid'):
tf.compat.v1.reset_default_graph()
tf.random.set_seed(42424242)
tf.compat.v1.set_random_seed(42424242)
"""
:param IMG_HEIGHT:
:param IMG_WIDTH:
:param IMG_CHANNELS:
:param do_compile: whether or not to compile the model yet
:return:
"""
inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
#s = Lambda(lambda x: x / 255)(inputs)
c1 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(inputs)
c1 = BatchNormalization()(c1)
c1 = Dropout(0.1)(c1)
c1 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c1)
c1 = BatchNormalization()(c1)
p1 = MaxPooling2D((2, 2))(c1)
c2 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p1)
c2 = BatchNormalization()(c2)
c2 = Dropout(0.1)(c2)
c2 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c2)
c2 = BatchNormalization()(c2)
p2 = MaxPooling2D((2, 2))(c2)
c3 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p2)
c3 = BatchNormalization()(c3)
c3 = Dropout(0.2)(c3)
c3 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c3)
c3 = BatchNormalization()(c3)
p3 = MaxPooling2D((2, 2))(c3)
c4 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p3)
c4 = BatchNormalization()(c4)
c4 = Dropout(0.2)(c4)
c4 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c4)
c4 = BatchNormalization()(c4)
p4 = MaxPooling2D(pool_size=(2, 2))(c4)
c5 = Conv2D(1024, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(p4)
c5 = BatchNormalization()(c5)
c5 = Dropout(0.3)(c5)
c5 = Conv2D(1024, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c5)
c5 = BatchNormalization()(c5)
u6 = Conv2DTranspose(512, (2, 2), strides=(2, 2), padding='same')(c5)
u6 = concatenate([u6, c4])
c6 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u6)
c6 = BatchNormalization()(c6)
c6 = Dropout(0.2)(c6)
c6 = Conv2D(512, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c6)
c6 = BatchNormalization()(c6)
u7 = Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(c6)
u7 = concatenate([u7, c3])
c7 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u7)
c7 = BatchNormalization()(c7)
c7 = Dropout(0.2)(c7)
c7 = Conv2D(256, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c7)
c7 = BatchNormalization()(c7)
u8 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c7)
u8 = concatenate([u8, c2])
c8 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u8)
c8 = BatchNormalization()(c8)
c8 = Dropout(0.1)(c8)
c8 = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c8)
c8 = BatchNormalization()(c8)
u9 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c8)
u9 = concatenate([u9, c1], axis=3)
c9 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(u9)
c9 = BatchNormalization()(c9)
c9 = Dropout(0.1)(c9)
c9 = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(c9)
c9 = BatchNormalization()(c9)
outputs = Conv2D(1, (1, 1), activation=out_activation)(c9)
model = Model(inputs=[inputs], outputs=[outputs])
if do_compile:
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
#model.summary()
return model
def PSPNet50(
input_shape=(512, 512, 3),
n_labels=20,
output_stride=16,
num_blocks=4,
multigrid=[1, 1, 1],
levels=[6, 3, 2, 1],
use_se=True,
output_mode="softmax",
upsample_type="deconv",
):
# Input shape
img_input = Input(shape=input_shape)
# compute input shape
if K.image_data_format() == "channels_last":
bn_axis = 3
else:
bn_axis = 1
x = Conv2D(64, (7, 7), strides=(2, 2), padding="same", name="conv1")(img_input)
x = BatchNormalization(axis=bn_axis, name="bn_conv1")(x)
x = Activation("relu")(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(
x, 3, [64, 64, 256], stage=2, block="a", strides=(1, 1), use_se=use_se
)
x = identity_block(x, 3, [64, 64, 256], stage=2, block="b", use_se=use_se)
x = identity_block(x, 3, [64, 64, 256], stage=2, block="c", use_se=use_se)
x = conv_block(x, 3, [128, 128, 512], stage=3, block="a", use_se=use_se)
x = identity_block(x, 3, [128, 128, 512], stage=3, block="b", use_se=use_se)
x = identity_block(x, 3, [128, 128, 512], stage=3, block="c", use_se=use_se)
x = identity_block(x, 3, [128, 128, 512], stage=3, block="d", use_se=use_se)
if output_stride == 8:
rate_scale = 2
elif output_stride == 16:
rate_scale = 1
x = conv_block(
x,
3,
[256, 256, 1024],
stage=4,
block="a",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[256, 256, 1024],
stage=4,
block="b",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[256, 256, 1024],
stage=4,
block="c",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[256, 256, 1024],
stage=4,
block="d",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[256, 256, 1024],
stage=4,
block="e",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[256, 256, 1024],
stage=4,
block="f",
dilation_rate=1 * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
init_rate = 2
for block in range(4, num_blocks + 1):
if block == 4:
block = ""
x = conv_block(
x,
3,
[512, 512, 2048],
stage=5,
block="a%s" % block,
dilation_rate=init_rate * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[512, 512, 2048],
stage=5,
block="b%s" % block,
dilation_rate=init_rate * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
x = identity_block(
x,
3,
[512, 512, 2048],
stage=5,
block="c%s" % block,
dilation_rate=init_rate * rate_scale,
multigrid=multigrid,
use_se=use_se,
)
init_rate *= 2
x = pyramid_pooling_module(
x,
num_filters=512,
input_shape=input_shape,
output_stride=output_stride,
levels=levels,
)
# x = merge([
# x1,
# x2,
# ], mode='concat', concat_axis=3)
# upsample_type
if upsample_type == "duc":
x = duc(
x,
factor=output_stride,
output_shape=(input_shape[0], input_shape[1], n_labels),
)
out = _conv(
filters=n_labels,
kernel_size=(1, 1),
padding="same",
block="out_duc_%s" % output_stride,
)(x)
elif upsample_type == "bilinear":
x = _conv(
filters=n_labels,
kernel_size=(1, 1),
padding="same",
block="out_bilinear_%s" % output_stride,
)(x)
out = BilinearUpSampling2D(
(n_labels, input_shape[0], input_shape[1]), factor=output_stride
)(x)
elif upsample_type == "deconv":
out = Conv2DTranspose(
filters=n_labels,
kernel_size=(output_stride * 2, output_stride * 2),
strides=(output_stride, output_stride),
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=None,
use_bias=False,
name="upscore_{}".format("out"),
)(x)
out = Reshape(
(input_shape[0] * input_shape[1], n_labels),
input_shape=(input_shape[0], input_shape[1], n_labels),
)(out)
# default "softmax"
out = Activation(output_mode)(out)
model = Model(inputs=img_input, outputs=out)
return model
def get_encoder_model(input_shape=(None, 1566, 257)):
"""
Get the Encoder Model
@param input_shape [BATCH_SIZE, no. of frames, no. of freq bins, 1 channel]
"""
NFFT = (input_shape[2] - 1) * 2
SAMPLES = input_shape[1]
BATCH_SIZE = input_shape[0]
# Conv2D with 32 kernels and ReLu, 3x3in time
input_layer = tf.keras.layers.Input(shape=input_shape, name='encoder_input')
il_expand_dims = tf.expand_dims(input_layer, axis=1)
enc_C1D_1 = TimeDistributed(Conv1D(filters=32, kernel_size=3, strides=2, use_bias=True, name='Enc_Conv_1'))(il_expand_dims)
enc_BN_1 = TimeDistributed(BatchNormalization(name='Enc_Batch_Norm_1'))(enc_C1D_1)
enc_Act_1 = TimeDistributed(Activation("relu", name='Enc_ReLU_1'))(enc_BN_1)
enc_C1D_2 = TimeDistributed(Conv1D(filters=32, kernel_size=3, strides=2, use_bias=True, name='Enc_Conv_2'))(enc_Act_1)
enc_BN_2 = TimeDistributed(BatchNormalization(name='Enc_Batch_Norm_2'))(enc_C1D_2)
enc_Act_2 = TimeDistributed(Activation("relu", name='Enc_ReLU_2'))(enc_BN_2)
# ConvLSTM1D -> Try and make this Bidirectional
# int_input_layer = tf.reshape(tf.expand_dims(enc_Act_2, axis=1), [-1, enc_Act_2.shape[1], enc_Act_2.shape[2], 1], name='Enc_Expand_Dims')
ConvLSTM1D = Conv2D(1, (1, 3), use_bias=False, name='Enc_ConvLSTM1D', data_format='channels_first')(enc_Act_2)
print(ConvLSTM1D.shape)
int_C1DLSTM_out = tf.squeeze(ConvLSTM1D, axis=[1])
# 3 Stacked Bidirectional LSTMs
enc_BiLSTM_1 = Bidirectional(LSTM(NFFT // 4, return_sequences=True), name='Enc_BiLSTM_1')(int_C1DLSTM_out)
# enc_BiLSTM_2 = Bidirectional(LSTM(NFFT // 4, return_sequences=True), name='Enc_BiLSTM_2')(enc_BiLSTM_1)
# enc_BiLSTM_3 = Bidirectional(LSTM(NFFT // 4, return_sequences=True), name='Enc_BiLSTM_3')(enc_BiLSTM_2)
# Linear Projection into NFFT/2 and batchnorm and ReLU
enc_Dense_1 = Dense(NFFT // 8, name='Enc_Linear_Projection')(enc_BiLSTM_1)
enc_BN_3 = BatchNormalization(name='Enc_Batch_Norm_3')(enc_Dense_1)
enc_Act_3 = Activation("relu", name='Enc_ReLU_3')(enc_BN_3)
encoder = tf.keras.Model(inputs=input_layer, outputs=[enc_Act_3], name='Encoder')
# Begin DeConvolution
deConv_input_expand_dims = tf.reshape(tf.expand_dims(enc_Act_3, axis=1), [-1, 1, enc_Act_3.shape[1], enc_Act_3.shape[2]])
DeC1D_filters = enc_Act_3.shape[2]
Act = deConv_input_expand_dims
for i in range(2):
DeC1D = Conv2DTranspose(
filters=DeC1D_filters * 2,
kernel_size=(1,
3),
strides=(1,
2),
data_format='channels_last',
output_padding=(0,
1),
padding='valid',
name='DeConv1D_{}'.format(i + 1)
)(Act)
# DeC1D = TimeDistributed()
BN = TimeDistributed(BatchNormalization(name='DeConv_Batch_norm_{}'.format(i + 1)))(DeC1D)
Act = TimeDistributed(Activation("relu", name='DeConv_ReLU_{}'.format(i + 1)))(BN)
DeC1D_filters *= 2
# DeConvReshape = Conv2D(filters=1, kernel_size=(1, 1), data_format='channels_first', name='DC1D_Reshape')(Act)
int_DeConv_out = tf.squeeze(Act, axis=[1])
# Linear Projection into NFFT/2 and batchnorm and ReLU
deConv_Dense_1 = Dense(NFFT//2 + 1, name='DeConv_Linear_Projection')(int_DeConv_out)
deConv_BN_3 = BatchNormalization(name='DeConv_Batch_Norm_{}'.format(i + 1))(deConv_Dense_1)
# deConv_Act_3 = Activation("tanh", name='DeConv_Tanh')(deConv_BN_3)
output_layer = deConv_BN_3
# if input_layer.shape[1] > output_layer.shape[1]:
# shape = [input_layer.shape[1] - output_layer.shape[1], output_layer.shape[2]]
# zero_padding = tf.zeros(shape, dtype=output_layer.dtype)
# output_layer = tf.reshape(tf.concat([output_layer, zero_padding], 1), input_layer.shape)
ConvDeConvModel = tf.keras.Model(inputs=input_layer, outputs=[output_layer], name='ConvDeConv')
ConvDeConvModel.summary()
return ConvDeConvModel
def PoseMobileNetV2(cfg, alpha):
# Setup base Mobilenet V2 NN
IMG_SHAPE = (cfg.MODEL.IMAGE_SIZE[0], cfg.MODEL.IMAGE_SIZE[1], 3)
base_model = MobileNetV2(input_shape=IMG_SHAPE,
include_top=False,
alpha=alpha,
weights='imagenet')
base_model.trainable = False
# Drop final set of layers to reduce output from 1280 to 320
# Reduces trainable parameters from 9.5m to 5.2m
base_model_output = base_model.get_layer('block_16_project_BN').output
extra = cfg.MODEL.EXTRA
deconv_with_bias = extra.DECONV_WITH_BIAS
kernel_initializer = RandomNormal(stddev=0.001)
bias_initializer = Constant(0.)
# Each layer created manually due to nuances between original Pytorch code and tf.keras version
# Deconv layer 0
planes = extra.NUM_DECONV_FILTERS[0]
deconv_0 = Conv2DTranspose(
filters=planes,
kernel_size=4,
strides=2,
padding='same',
use_bias=deconv_with_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)(base_model_output)
batchnorm_0 = BatchNormalization(momentum=BN_MOMENTUM)(deconv_0)
relu_0 = ReLU()(batchnorm_0)
# Deconv layer 1
planes = extra.NUM_DECONV_FILTERS[1]
deconv_1 = Conv2DTranspose(filters=planes,
kernel_size=4,
strides=2,
padding='same',
use_bias=deconv_with_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)(relu_0)
batchnorm_1 = BatchNormalization(momentum=BN_MOMENTUM)(deconv_1)
relu_1 = ReLU()(batchnorm_1)
# Deconv layer 2
planes = extra.NUM_DECONV_FILTERS[2]
deconv_2 = Conv2DTranspose(filters=planes,
kernel_size=4,
strides=2,
padding='same',
use_bias=deconv_with_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)(relu_1)
batchnorm_2 = BatchNormalization(momentum=BN_MOMENTUM)(deconv_2)
relu_2 = ReLU()(batchnorm_2)
# Final layer
padding = 'same' if extra.FINAL_CONV_KERNEL == 3 else 'valid'
final_layer = Conv2D(filters=cfg.MODEL.NUM_JOINTS,
kernel_size=extra.FINAL_CONV_KERNEL,
strides=1,
padding=padding,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)(relu_2)
# Build complete model
model = Model(inputs=base_model.inputs,
outputs=final_layer,
name='pose_mobilenetv2_%0.2f' % alpha)
return model
def runAutoencoder(x_train, x_test, x_train_noisy, x_test_noisy):
np.random.seed(1337)
# MNIST dataset
# (x_train, _), (x_test, _) = mnist.load_data()
image_size = x_train.shape[1]
x_train = np.reshape(x_train, [-1, image_size, image_size, 1])
x_test = np.reshape(x_test, [-1, image_size, image_size, 1])
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
x_train_noisy = np.reshape(x_train_noisy, [-1, image_size, image_size, 1])
x_test_noisy = np.reshape(x_test_noisy, [-1, image_size, image_size, 1])
x_train_noisy = x_train_noisy.astype('float32') / 255
x_test_noisy = x_test_noisy.astype('float32') / 255
# Generate corrupted MNIST images by adding noise with normal dist
# centered at 0.5 and std=0.5
# noise = np.random.normal(loc=0.5, scale=0.5, size=x_train.shape)
# x_train_noisy = x_train + noise
# noise = np.random.normal(loc=0.5, scale=0.5, size=x_test.shape)
# x_test_noisy = x_test + noise
# x_train_noisy = np.clip(x_train_noisy, 0., 1.)
# x_test_noisy = np.clip(x_test_noisy, 0., 1.)
# Network parameters
input_shape = (image_size, image_size, 1)
batch_size = 128
kernel_size = 3
latent_dim = 16
# Encoder/Decoder number of CNN layers and filters per layer
layer_filters = [32, 64]
# Build the Autoencoder Model
# First build the Encoder Model
inputs = Input(shape=input_shape, name='encoder_input')
x = inputs
# Stack of Conv2D blocks
# Notes:
# 1) Use Batch Normalization before ReLU on deep networks
# 2) Use MaxPooling2D as alternative to strides>1
# - faster but not as good as strides>1
for filters in layer_filters:
x = Conv2D(filters=filters,
kernel_size=kernel_size,
strides=2,
activation='relu',
padding='same')(x)
# Shape info needed to build Decoder Model
shape = K.int_shape(x)
# Generate the latent vector
x = Flatten()(x)
latent = Dense(latent_dim, name='latent_vector')(x)
# Instantiate Encoder Model
encoder = Model(inputs, latent, name='encoder')
encoder.summary()
# Build the Decoder Model
latent_inputs = Input(shape=(latent_dim, ), name='decoder_input')
x = Dense(shape[1] * shape[2] * shape[3])(latent_inputs)
x = Reshape((shape[1], shape[2], shape[3]))(x)
# Stack of Transposed Conv2D blocks
# Notes:
# 1) Use Batch Normalization before ReLU on deep networks
# 2) Use UpSampling2D as alternative to strides>1
# - faster but not as good as strides>1
for filters in layer_filters[::-1]:
x = Conv2DTranspose(filters=filters,
kernel_size=kernel_size,
strides=2,
activation='relu',
padding='same')(x)
x = Conv2DTranspose(filters=1, kernel_size=kernel_size, padding='same')(x)
outputs = Activation('sigmoid', name='decoder_output')(x)
# Instantiate Decoder Model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
# Autoencoder = Encoder + Decoder
# Instantiate Autoencoder Model
autoencoder = Model(inputs, decoder(encoder(inputs)), name='autoencoder')
autoencoder.summary()
autoencoder.compile(loss='mse', optimizer='adam')
# Train the autoencoder
autoencoder.fit(x_train_noisy,
x_train,
validation_data=(x_test_noisy, x_test),
epochs=30,
batch_size=batch_size)
# Predict the Autoencoder output from corrupted test images
x_decoded = autoencoder.predict(x_test_noisy)
# Display the 1st 8 corrupted and denoised images
rows, cols = 10, 30
num = rows * cols
imgs = np.concatenate([x_test[:num], x_test_noisy[:num], x_decoded[:num]])
imgs = imgs.reshape((rows * 3, cols, image_size, image_size))
imgs = np.vstack(np.split(imgs, rows, axis=1))
imgs = imgs.reshape((rows * 3, -1, image_size, image_size))
imgs = np.vstack([np.hstack(i) for i in imgs])
imgs = (imgs * 255).astype(np.uint8)
plt.figure()
plt.axis('off')
plt.title('Original images: top rows, '
'Corrupted Input: middle rows, '
'Denoised Input: third rows')
plt.imshow(imgs, interpolation='none', cmap='gray')
Image.fromarray(imgs).save('corrupted_and_denoised.png')
plt.show()
def unet(inputs, n=32):
bn = BatchNormalization()(inputs)
conv1 = Conv2D(n, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(bn)
conv1 = Conv2D(n, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
pool1 = Dropout(0.1)(pool1)
conv2 = Conv2D(n * 2, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(pool1)
conv2 = Conv2D(n * 2, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
pool2 = Dropout(0.1)(pool2)
conv3 = Conv2D(n * 4, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(pool2)
conv3 = Conv2D(n * 4, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
pool3 = Dropout(0.1)(pool3)
conv4 = Conv2D(n * 8, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(pool3)
conv4 = Conv2D(n * 8, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
pool4 = Dropout(0.1)(pool4)
convm = Conv2D(n * 16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(pool4)
convm = Conv2D(n * 16, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(convm)
up6 = Conv2DTranspose(n * 8, (2, 2), strides=(2, 2), padding='same')(convm)
conv6 = concatenate([up6, conv4])
conv6 = Dropout(0.1)(conv6)
conv6 = Conv2D(n * 8, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv6)
conv6 = Conv2D(n * 8, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv6)
up7 = Conv2DTranspose(n * 4, (2, 2), strides=(2, 2), padding='same')(conv6)
conv7 = concatenate([up7, conv3])
conv7 = Dropout(0.1)(conv7)
conv7 = Conv2D(n * 4, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv7)
conv7 = Conv2D(n * 4, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv7)
up8 = Conv2DTranspose(n * 2, (2, 2), strides=(2, 2), padding='same')(conv7)
conv8 = concatenate([up8, conv2])
conv8 = Dropout(0.1)(conv8)
conv8 = Conv2D(n * 2, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv8)
conv8 = Conv2D(n * 2, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv8)
up9 = Conv2DTranspose(n, (2, 2), strides=(2, 2), padding='same')(conv8)
conv9 = concatenate([up9, conv1])
conv9 = Dropout(0.1)(conv9)
conv9 = Conv2D(n, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv9)
conv9 = Conv2D(n, (3, 3),
activation='relu',
kernel_initializer='he_normal',
padding='same')(conv9)
output = Conv2D(1, (1, 1), activation='sigmoid')(conv9)
return Model(inputs=[inputs], outputs=[output])
def FCN8_VGG16(mean, stddev, config):
print(mean, stddev)
"""
Implementation of FCN8 with VGG16 backend based on arXiv:1411.4038 [cs.CV]
"""
input = Input(shape=config.input_shape)
vgg16_input = ZeroPadding2D(padding=(100, 100))(input)
vgg16 = VGG16(include_top=False,
weights=config.init_weights,
input_tensor=vgg16_input,
input_shape=config.input_shape,
pooling=None)
vgg16_block3 = vgg16.get_layer(name="block3_pool").output
vgg16_block4 = vgg16.get_layer(name="block4_pool").output
vgg16_block5 = vgg16.get_layer(name="block5_pool").output
# Fully connected from VGG16
fc1_conv = BatchNormalization()(Conv2D(
4096, (7, 7),
activation="relu",
padding="valid",
kernel_regularizer=l2(config.l2_constant))(vgg16_block5))
dropout1 = Dropout(config.dropout)(fc1_conv)
fc2_conv = BatchNormalization()(Conv2D(4096, (1, 1),
activation="relu",
padding="valid",
kernel_regularizer=l2(
config.l2_constant))(dropout1))
dropout2 = Dropout(config.dropout)(fc2_conv)
# 2 = number of classes
fcn32_conv = BatchNormalization()(Conv2D(
2, (1, 1), kernel_regularizer=l2(config.l2_constant))(dropout2))
fcn32_deconv = BatchNormalization()(Conv2DTranspose(
2,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False,
kernel_regularizer=l2(config.l2_constant))(fcn32_conv))
fcn16_conv = BatchNormalization()(Conv2D(
2, (1, 1), kernel_regularizer=l2(config.l2_constant))(vgg16_block4))
fcn16_crop = crop(fcn16_conv, fcn32_deconv)
fcn16_add = Add()([fcn32_deconv, fcn16_crop])
fcn16_deconv = BatchNormalization()(Conv2DTranspose(
2,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False,
kernel_regularizer=l2(config.l2_constant))(fcn16_add))
fcn8_conv = BatchNormalization()(Conv2D(
2, (1, 1), kernel_regularizer=l2(config.l2_constant))(vgg16_block3))
fcn8_crop = crop(fcn8_conv, fcn16_deconv)
fcn8_add = Add()([fcn16_deconv, fcn8_crop])
fcn8_deconv = BatchNormalization()(Conv2DTranspose(
2,
kernel_size=(16, 16),
strides=(8, 8),
use_bias=False,
kernel_regularizer=l2(config.l2_constant))(fcn8_add))
final = crop(fcn8_deconv, input)
final = Activation("softmax")(final)
# Use Z-scores as a form of normalization
model = Model(input, final)
return model
def BaseUnet_modeling(kernel_size=4,dropout=0.5):
initializer = tf.random_normal_initializer(0.,0.02)
inputs = Input(shape=(256,256,3))
layer1 = Conv2D(filters=64,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(inputs)
layer1 = LeakyReLU()(layer1)
layer1_ = layer1
layer2 = Conv2D(filters=128,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer1)
layer2_ = BatchNormalization()(layer2)
layer2 = LeakyReLU()(layer2_)
layer3 = Conv2D(filters=256,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer2)
layer3_ = BatchNormalization()(layer3)
layer3 = LeakyReLU()(layer3_)
layer4 = Conv2D(filters=512,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer3)
layer4_ = BatchNormalization()(layer4)
layer4 = LeakyReLU()(layer4_)
layer5 = Conv2D(filters=512,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer4)
layer5_ = BatchNormalization()(layer5)
layer5 = LeakyReLU()(layer5_)
layer6 = Conv2D(filters=512,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer5)
layer6_ = BatchNormalization()(layer6)
layer6 = LeakyReLU()(layer6_)
layer7 = Conv2D(filters=512,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer6)
layer7_ = BatchNormalization()(layer7)
layer7 = LeakyReLU()(layer7_)
layer8 = Conv2D(filters=512,kernel_size=kernel_size,strides=2,padding='same',use_bias=False,kernel_initializer=initializer)(layer7)
layer8_ = BatchNormalization()(layer8)
layer8 = LeakyReLU()(layer8_)
layer9 = Conv2DTranspose(filters=512,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer8)
layer9 = BatchNormalization()(layer9)
layer9 = layer9+layer7_
layer9 = Dropout(dropout)(layer9)
layer9 = ReLU()(layer9)
layer10 = Conv2DTranspose(filters=512,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer9)
layer10 = BatchNormalization()(layer10)
layer10 = concatenate([layer10,layer6_])
layer10 = Dropout(dropout)(layer10)
layer10 = ReLU()(layer10)
layer11 = Conv2DTranspose(filters=512,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer10)
layer11 = BatchNormalization()(layer11)
layer11 = layer11+layer5_
layer11 = Dropout(dropout)(layer11)
layer11 = ReLU()(layer11)
layer12 = Conv2DTranspose(filters=512,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer11)
layer12 = BatchNormalization()(layer12)
layer12 = layer12+layer4_
layer12 = ReLU()(layer12)
layer13 = Conv2DTranspose(filters=256,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer12)
layer13 = BatchNormalization()(layer13)
layer13 = layer13+layer3_
layer13 = ReLU()(layer13)
layer14 = Conv2DTranspose(filters=128,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer13)
layer14 = BatchNormalization()(layer14)
layer14 = layer14+layer2_
layer14 = ReLU()(layer14)
layer15 = Conv2DTranspose(filters=64,kernel_size=kernel_size,strides=2,padding='same',kernel_initializer=initializer,use_bias=False)(layer14)
layer15 = BatchNormalization()(layer15)
layer15 = layer15+layer1_
layer15 = ReLU()(layer15)
outputs = Conv2DTranspose(3,4,strides=2,padding='same',kernel_initializer=initializer,activation='tanh')(layer15)
Generator = Model(inputs=inputs,outputs=outputs)
return Generator
def default_latent(num_outputs, input_shape):
# TODO: this auto-encoder should run the standard cnn in encoding and
# have corresponding decoder. Also outputs should be reversed with
# images at end.
drop = 0.2
img_in = Input(shape=input_shape, name='img_in')
x = img_in
x = Convolution2D(24, (5, 5),
strides=(2, 2),
activation='relu',
name="conv2d_1")(x)
x = Dropout(drop)(x)
x = Convolution2D(32, (5, 5),
strides=(2, 2),
activation='relu',
name="conv2d_2")(x)
x = Dropout(drop)(x)
x = Convolution2D(32, (5, 5),
strides=(2, 2),
activation='relu',
name="conv2d_3")(x)
x = Dropout(drop)(x)
x = Convolution2D(32, (3, 3),
strides=(1, 1),
activation='relu',
name="conv2d_4")(x)
x = Dropout(drop)(x)
x = Convolution2D(32, (3, 3),
strides=(1, 1),
activation='relu',
name="conv2d_5")(x)
x = Dropout(drop)(x)
x = Convolution2D(64, (3, 3),
strides=(2, 2),
activation='relu',
name="conv2d_6")(x)
x = Dropout(drop)(x)
x = Convolution2D(64, (3, 3),
strides=(2, 2),
activation='relu',
name="conv2d_7")(x)
x = Dropout(drop)(x)
x = Convolution2D(64, (1, 1),
strides=(2, 2),
activation='relu',
name="latent")(x)
y = Conv2DTranspose(filters=64,
kernel_size=(3, 3),
strides=2,
name="deconv2d_1")(x)
y = Conv2DTranspose(filters=64,
kernel_size=(3, 3),
strides=2,
name="deconv2d_2")(y)
y = Conv2DTranspose(filters=32,
kernel_size=(3, 3),
strides=2,
name="deconv2d_3")(y)
y = Conv2DTranspose(filters=32,
kernel_size=(3, 3),
strides=2,
name="deconv2d_4")(y)
y = Conv2DTranspose(filters=32,
kernel_size=(3, 3),
strides=2,
name="deconv2d_5")(y)
y = Conv2DTranspose(filters=1,
kernel_size=(3, 3),
strides=2,
name="img_out")(y)
x = Flatten(name='flattened')(x)
x = Dense(256, activation='relu')(x)
x = Dropout(drop)(x)
x = Dense(100, activation='relu')(x)
x = Dropout(drop)(x)
x = Dense(50, activation='relu')(x)
x = Dropout(drop)(x)
outputs = [y]
for i in range(num_outputs):
outputs.append(
Dense(1, activation='linear', name='n_outputs' + str(i))(x))
model = Model(inputs=[img_in], outputs=outputs)
return model
def vae_model(input_shape):
# network parameters
# input_shape = (image_size, image_size, 1)
# batch_size = 128
blocks = 2
kernel_size = 5
filters = 16
latent_dim = 2
# epochs = 30
# VAE model = encoder + decoder
# build encoder model
inputs = Input(shape=input_shape, name='encoder_input')
x = inputs
for i in range(blocks):
filters *= 2
x = Conv2D(filters=filters,
kernel_size=kernel_size,
activation='relu',
strides=2,
padding='same')(x)
# shape info needed to build decoder model
shape = K.int_shape(x)
# generate latent vector Q(z|X)
x = Flatten()(x)
x = Dense(16, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
# use reparameterization trick to push the sampling out as input
# note that "output_shape" isn't necessary with the TensorFlow backend
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])
# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
# plot_model(encoder, to_file='vae_cnn_encoder.png', show_shapes=True)
# build decoder model
latent_inputs = Input(shape=(latent_dim,), name='z_sampling')
x = Dense(shape[1] * shape[2] * shape[3], activation='relu')(latent_inputs)
x = Reshape((shape[1], shape[2], shape[3]))(x)
for i in range(blocks):
x = Conv2DTranspose(filters=filters,
kernel_size=kernel_size,
activation='relu',
strides=2,
padding='same')(x)
filters //= 2
outputs = Conv2DTranspose(filters=1,
kernel_size=kernel_size,
activation='sigmoid',
padding='same',
name='decoder_output')(x)
# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
# plot_model(decoder, to_file='vae_cnn_decoder.png', show_shapes=True)
# instantiate VAE model
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae')
return vae, z_mean, z_log_var
def build_generator(self):
dropout = 0.4
model = Sequential()
model.add(
Dense(64 * 32 * 32, kernel_initializer=RandomNormal(stddev=0.02)))
model.add(BatchNormalization(momentum=0.9))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(dropout))
model.add(Reshape((32, 32, 64)))
# model.add(UpSampling2D(interpolation='bilinear'))
# # model.add(Conv2DTranspose(512, 5, 2, padding='same', kernel_initializer=RandomNormal(stddev=0.02)))
# model.add(Conv2D(256, 5, 1, padding='same', kernel_initializer=RandomNormal(stddev=0.02)))
# model.add(BatchNormalization(momentum=0.9))
# model.add(LeakyReLU(alpha=0.2))
# model.add(Dropout(dropout))
# model.add(UpSampling2D(interpolation='bilinear'))
# model.add(Conv2DTranspose(128, 5, 2, padding='same', kernel_initializer=RandomNormal(stddev=0.02)))
model.add(
Conv2D(64,
5,
1,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02)))
model.add(BatchNormalization(momentum=0.9))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(dropout))
# model.add(UpSampling2D(interpolation='bilinear'))
# model.add(Conv2DTranspose(64, 5, 2, padding='same', kernel_initializer=RandomNormal(stddev=0.02)))
model.add(
Conv2DTranspose(64,
5,
2,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02)))
model.add(
Conv2D(64,
5,
1,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02)))
model.add(BatchNormalization(momentum=0.9))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(dropout))
# model.add(UpSampling2D(interpolation='bilinear'))
model.add(
Conv2D(32,
5,
1,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02)))
model.add(BatchNormalization(momentum=0.9))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(dropout))
model.add(
Conv2DTranspose(3,
5,
1,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02)))
model.add(Activation('tanh'))
noiseInput = Input(shape=(100, ))
imageOutput = model(noiseInput)
self.G = Model(noiseInput, imageOutput)
print('==============Generator=============')
model.summary()
print('====================================')
def generator():
init = TruncatedNormal(mean=0.0, stddev=0.02)
model = tf.keras.Sequential()
# ----------------------------------------------------------------
size = 26
filters = 512
model.add(Dense(units=size*size*filters,
use_bias=False,
kernel_initializer=init,
input_shape=(NOISE_DIM,)))
# model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.2))
# ----------------------------------------------------------------
model.add(Reshape(target_shape=(size, size, filters)))
# ----------------------------------------------------------------
model.add(Conv2DTranspose(filters=512,
kernel_size=(4, 4),
kernel_initializer=init,
strides=(2, 2),
padding='same',
use_bias=False))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.2))
# ----------------------------------------------------------------
# Upsample 8x8
model.add(Conv2DTranspose(filters=128,
kernel_size=(4, 4),
kernel_initializer=init,
strides=(2, 2),
padding='same',
use_bias=False))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(rate=0.4))
# ----------------------------------------------------------------
# Upsample 8x8
model.add(Conv2DTranspose(filters=128,
kernel_size=(4, 4),
kernel_initializer=init,
strides=(2, 2),
padding='same',
use_bias=False))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.2))
# Upsample 8x8
model.add(Conv2DTranspose(filters=128,
kernel_size=(4, 4),
kernel_initializer=init,
strides=(2, 2),
padding='same',
use_bias=False))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.2))
# ----------------------------------------------------------------
# Output: 416x416x3
model.add(Conv2D(filters=3,
kernel_size=(4, 4),
kernel_initializer=init,
activation='tanh',
padding='same'))
assert model.output_shape == (None, 416, 416, 3)
return model
