def FCN_VGG19(input_shape, classes,
trainable_encoder=True, weights='imagenet'):
"""Fully Convolutional Networks for semantic segmentation with VGG16.
# Arguments
input_shape: input image shape
classes: number of classes
trainable_encoder: Bool whether the weights of encoder are trainable
weights: pre-trained weights to load (None for training from scratch)
# Returns
A Keras model instance
"""
# input
inputs = Input(shape=input_shape)
# Get the feature pyramid [drop7, pool4, pool3] from the VGG16 encoder
pyramid_layers = 3
encoder = VGG19(inputs, weights='imagenet', trainable=trainable_encoder)
feat_pyramid = encoder.outputs[:pyramid_layers]
# Append image to the end of feature pyramid
feat_pyramid.append(inputs)
# Decode feature pyramid
outputs = VGGUpsampler(feat_pyramid, scales=[1, 1e-2, 1e-4], classes=21)
# Activation TODO{jihong} work only for channels_last
outputs = Activation('softmax')(outputs)
# return model
return Model(inputs=inputs, outputs=outputs)
def test_vgg19():
for data_format in ['channels_first', 'channels_last']:
K.set_image_data_format(data_format)
if K.image_data_format() == 'channels_first':
x = Input(shape=(3, 500, 500))
pool1_shape = (None, 64, 250, 250)
pool2_shape = (None, 128, 125, 125)
pool3_shape = (None, 256, 63, 63)
pool4_shape = (None, 512, 32, 32)
drop7_shape = (None, 4096, 16, 16)
conv1_weight = -0.35009676
else:
x = Input(shape=(500, 500, 3))
pool1_shape = (None, 250, 250, 64)
pool2_shape = (None, 125, 125, 128)
pool3_shape = (None, 63, 63, 256)
pool4_shape = (None, 32, 32, 512)
drop7_shape = (None, 16, 16, 4096)
conv1_weight = 0.429471
encoder = VGG19(x, weights='imagenet', trainable=False)
feat_pyramid = encoder.outputs
assert len(feat_pyramid) == 5
assert K.int_shape(feat_pyramid[0]) == drop7_shape
assert K.int_shape(feat_pyramid[1]) == pool4_shape
assert K.int_shape(feat_pyramid[2]) == pool3_shape
assert K.int_shape(feat_pyramid[3]) == pool2_shape
assert K.int_shape(feat_pyramid[4]) == pool1_shape
for layer in encoder.layers:
if layer.name == 'block1_conv1':
assert layer.trainable is False
weights = K.eval(layer.weights[0])
assert np.allclose(weights[0, 0, 0, 0], conv1_weight)
encoder_from_scratch = VGG19(x, weights=None, trainable=True)
for layer in encoder_from_scratch.layers:
if layer.name == 'block1_conv1':
assert layer.trainable is True
weights = K.eval(layer.weights[0])
assert not np.allclose(weights[0, 0, 0, 0], conv1_weight)