def make_encode_decode_net(inputs,
num_classes,
n_blocks,
base=32,
filter_list=None):
"""Flexible semantic segmentation architecture using seperable convolutions"""
if filter_list is None:
filter_list = list()
for i in range(n_blocks):
filter_list.append(base * (2**i))
x0 = l.Conv2D(base, 3, activation='relu', padding='same')(inputs)
x0 = l.BatchNormalization()(x0)
encode_layers = list()
for i in range(n_blocks):
if i == 0:
encode_layers.append(encode_block(x0, filter_list[i]))
else:
encode_layers.append(
encode_block(encode_layers[i - 1], filter_list[i]))
encode_layers = [x0] + encode_layers
encode_layers = list(reversed(encode_layers))
filter_list = list(reversed(filter_list))
for e, layer in enumerate(encode_layers[1:]):
if e == 0:
x = decode_block(encode_layers[0], layer, filter_list[e])
else:
x = decode_block(x, layer, filter_list[e])
return l.Conv2D(num_classes, 3, activation='sigmoid', padding='same')(x)
def separable2d_layer(x, filters, kernel_size=3, strides=1, batch_norm=True):
x = SeparableConv2DKeras(filters,
kernel_size,
strides=strides,
padding='same')(x)
if batch_norm:
x = l.BatchNormalization()(x)
return x
def conv2d_batchnorm(input_layer, filters, kernel_size=3, strides=1):
output_layer = layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding='same',
activation='relu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
def separable_conv2d_batchnorm(input_layer, filters, strides=1, kernel=3):
output_layer = SeparableConv2DKeras(filters=filters,
kernel_size=kernel,
strides=strides,
padding='same',
activation='elu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
def conv2d_layer(x, filters, kernel_size=3, strides=1, batch_norm=True):
x = l.Conv2D(filters, kernel_size, strides=strides, padding='same')(x)
if batch_norm:
x = l.BatchNormalization()(x)
return x
