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 conv1d(x,
filters,
kernel_size=3,
stride=1,
padding='same',
activation_=None,
is_training=True):
"""
:param x: (bs, length, channel)
:param filters: int
:param kernel_size: int
:param stride: int
:param padding: same or valid
:param activation_:
:param is_training:
:return: (bs, length, new_channel)
"""
_x = tf.expand_dims(x, axis=2)
_x = activation(
kl.Conv2D(filters, (kernel_size, 1), (stride, 1),
padding,
activation=None,
trainable=is_training)(_x), activation_)
_x = tf.squeeze(_x, axis=2)
return _x
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
encoded_layer1 = encoder_block(inputs, filters=16, strides=2)
encoded_layer2 = encoder_block(encoded_layer1, filters=32, strides=2)
encoded_layer3 = encoder_block(encoded_layer2, filters=64, strides=2)
print(' | -> encoded_layer1:', encoded_layer1)
print(' | -> encoded_layer2:', encoded_layer2)
print(' | -> encoded_layer3:', encoded_layer3)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
layer_1x1 = conv2d_batchnorm(encoded_layer3, 128, kernel_size=1, strides=1)
print(' | -> layer_1x1:', layer_1x1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
decoded_layer1 = decoder_block(layer_1x1, encoded_layer2, filters=64)
decoded_layer2 = decoder_block(decoded_layer1, encoded_layer1, filters=32)
decoded_layer3 = decoder_block(decoded_layer2, inputs, filters=16)
print(' | -> decoded_layer1:', decoded_layer1)
print(' | -> decoded_layer2:', decoded_layer2)
print(' | -> decoded_layer3:', decoded_layer3)
x = decoded_layer3
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
# hint: new_height = (input_height/S + 1
# new_width = (input_width)/S + 1
# 128x128x3 -> 64x64x32
encoder_1 = encoder_block(inputs, 32, 2)
# 64x64x32 -> 32x32x64
encoder_2 = encoder_block(encoder_1, 64, 2)
# 32x32x64-> 16x16x128
encoder_3 = encoder_block(encoder_2, 128, 2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
comprimed = conv2d_batchnorm(encoder_3, 128, kernel_size=1, strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
# 16x16x128 -> 32x32x128
decoder_1 = decoder_block(comprimed, encoder_2, 128)
# 32x32x128 -> 64x64x64
decoder_2 = decoder_block(decoder_1, encoder_1, 64)
# 64x64x3 -> 128x128x32
decoder_3 = decoder_block(decoder_2, inputs, 32)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax',
padding='same')(decoder_3)
def fcn_model(inputs, num_classes):
filters = 36
strides = 2
#Input size:
# Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
# Layer 1 size:
layer_1 = encoder_block(inputs, filters, strides)
# Layer 2 size:
layer_2 = encoder_block(layer_1, filters * 2, strides)
# Layer 3 size:
layer_3 = encoder_block(layer_2, filters * 4, strides)
# 1x1 Convolution layer using conv2d_batchnorm()
# Convolution layer size:
convolution_layer = conv2d_batchnorm(layer_3,
filters * 16,
kernel_size=1,
strides=1)
# Decoder Blocks
# Layer 4 size:
layer_4 = decoder_block(convolution_layer, layer_2, filters * 4)
# Layer 5 size
layer_5 = decoder_block(layer_4, layer_1, filters * 2)
# Layer 6 size:
layer_6 = decoder_block(layer_5, inputs, filters)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(layer_6)
def fcn_model_best(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
encod1 = encoder_block(inputs, 32, 2)
encod2 = encoder_block(encod1, 64, 2)
encod3 = encoder_block(encod2, 128, 2)
encod4 = encoder_block(encod3, 256, 2)
print('encod1 layer size',encod1.get_shape().as_list())
print('encod2 layer size',encod2.get_shape().as_list())
print('encod3 layer size',encod3.get_shape().as_list())
print('encod4 layer size',encod4.get_shape().as_list())
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
conv_layer = conv2d_batchnorm(encod4, 256, kernel_size=1, strides=1)
print('conv_layer layer size',conv_layer.get_shape().as_list())
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
decod1 = decoder_block(conv_layer, encod3, 256)
decod2 = decoder_block(decod1, encod2, 128)
decod3 = decoder_block(decod2, encod1, 64)
decod4 = decoder_block(decod3, inputs, 32)
print('decoder1 layer size',decod1.get_shape().as_list())
print('decoder2 layer size',decod2.get_shape().as_list())
print('decoder3 layer size',decod3.get_shape().as_list())
print('decoder4 layer size',decod4.get_shape().as_list())
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(decod4)
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
filters=[16,32,64, 96, 128]
strides=[2]
outputs = [None]*(len(filters)+1)
outputs[0] = inputs
for i,filter in enumerate(filters):
outputs[i+1] = encoder_block(outputs[i], filter, strides[0])
print ('encoder_{} shape:{}'.format(i, outputs[i+1].get_shape().as_list()))
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
final_output = conv2d_batchnorm(outputs[-1], 128, kernel_size=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
# The advise was to concatenate the higher blocks not all.
# 3rd and fifth block
decoded_output = final_output
reversed_arr = list(range(len(filters)))[::-1]
for i in reversed_arr:
print ('decoder_{}'.format(i))
decoded_output = decoder_block(decoded_output, outputs[i], filters[i])
x = decoded_output
# x = decoder_block(decoded_output,inputs,filters[0])
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(x)
def fcn_model_9layer(inputs, num_classes, filter_set):
enc1_filter_num = filter_set[0]
enc2_filter_num = filter_set[1]
enc3_filter_num = filter_set[2]
enc4_filter_num = filter_set[3]
one_by_one_filter_num = filter_set[4]
dec1_filter_num = filter_set[3]
dec2_filter_num = filter_set[2]
dec3_filter_num = filter_set[1]
encoder_block1 = encoder_block(inputs, enc1_filter_num, strides=2)
encoder_block2 = encoder_block(encoder_block1, enc2_filter_num, strides=2)
encoder_block3 = encoder_block(encoder_block2, enc3_filter_num, strides=2)
encoder_block4 = encoder_block(encoder_block3, enc4_filter_num, strides=2)
one_by_one_conv = conv2d_batchnorm(encoder_block4,
one_by_one_filter_num,
kernel_size=1,
strides=1)
decoder_block1 = decoder_block(one_by_one_conv, encoder_block3,
dec1_filter_num)
decoder_block2 = decoder_block(decoder_block1, encoder_block2,
dec2_filter_num)
decoder_block3 = decoder_block(decoder_block2, encoder_block1,
dec3_filter_num)
x = decoder_block(decoder_block3, inputs, num_classes)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
# 160x160x3 -> 80x80x32
encoder_1 = encoder_block(inputs,32,2)
# encoder_1 = encoder_block(encoder_1,32,1)
# 80x80x32 -> 40x40x64
encoder_2 = encoder_block(encoder_1,64,2)
# encoder_2 = encoder_block(encoder_2,64,1)
# 40x40x64-> 20x20x128
encoder_3 = encoder_block(encoder_2,128,2)
# encoder_3 = encoder_block(encoder_3,128,1)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
comprimed = conv2d_batchnorm(encoder_3,256,kernel_size=1,strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
# 20x20x256 -> 40x40x128
decoder_1 = decoder_block(comprimed,encoder_2,128)
# 40x40x128 -> 80x80x64
decoder_2 = decoder_block(decoder_1,encoder_1,64)
# 80x80x64 -> 128x128x32
decoder_3 = decoder_block(decoder_2,inputs,32)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(decoder_3)
def build_segmentation_network(config_dict):
lists = process_maybe_lists(config_dict)
n_blocks = config_dict['n_blocks_per_side']
im_edge = config_dict['image_resolution']
inputs = l.Input((im_edge, im_edge, 3))
encode_blocks = list()
x = conv2d_layer(inputs, lists[0][0], True)
encode_blocks.append(x)
for e, tup in enumerate(lists):
if e < n_blocks:
layer_fn = make_partial_layer(config_dict['convolution_type'],
tup[0], tup[2])
x = encode_block(x, layer_fn, config_dict['downsample_method'],
tup[1])
encode_blocks.append(x)
else:
layer_fn = make_partial_layer(config_dict['convolution_type'],
tup[0], tup[2])
skip_layer = encode_blocks[n_blocks - e - 2]
x = decode_block(x, skip_layer, layer_fn,
config_dict['upsample_method'], tup[1])
x = l.Conv2D(config_dict['n_classes'],
1,
activation=config_dict['last_layer_activation'],
padding='same')(x)
return x, inputs
def fcn_model(inputs, num_classes):
# print("num_classes", num_classes)
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
encoder_block1 = encoder_block(inputs, 8, strides=2)
encoder_block2 = encoder_block(encoder_block1, 16, strides=2)
# encoder_block3 = encoder_block(encoder_block2, 32, strides=2)
# encoder_block4 = encoder_block(encoder_block3, 64, strides=2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
one_by_one_conv = conv2d_batchnorm(encoder_block2,
32,
kernel_size=1,
strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
decoder_block1 = decoder_block(one_by_one_conv, encoder_block1, 16)
# print("done decode 1")
# decoder_block2 = decoder_block(decoder_block1, encoder_block2, 32)
# print("done decode 2")
# decoder_block3 = decoder_block(decoder_block2, encoder_block1, 16)
# print("done decode 3")
x = decoder_block(decoder_block1, inputs, num_classes)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
filters = 16
keep_prob = 1
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
l1 = encoder_block(inputs, filters)
l1 = keras.layers.core.Dropout(keep_prob)(l1)
l2 = encoder_block(l1, filters * 2)
l2 = keras.layers.core.Dropout(keep_prob)(l2)
l3 = encoder_block(l2, filters * 3)
l3 = keras.layers.core.Dropout(keep_prob)(l3)
l4 = encoder_block(l3, filters * 4)
fcn = conv2d_batchnorm(l4, filters * 4, strides=1, kernel=1)
# decoder
x = decoder_block(fcn, filters * 4)
x = decoder_block(x, filters * 3)
x = keras.layers.core.Dropout(keep_prob)(x)
x = decoder_block(x, filters * 2)
x = layers.concatenate([x, l1])
x = keras.layers.core.Dropout(keep_prob)(x)
x = decoder_block(x, filters)
x = layers.concatenate([x, inputs])
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax',
padding='same')(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 conv2d(x,
filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation_=None):
return activation(
kl.Conv2D(filters, kernel_size, strides, padding, activation=None)(x),
activation_)
def fcn_model2(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
encod1 = encoder_block(inputs, 2, 2)
input_shape = inputs.get_shape().as_list()
conv_layer = conv2d_batchnorm(encod1, 2, kernel_size=1, strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
decod1 = decoder_block(conv_layer, inputs, 2)
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(decod1)
def fcn_model_3layer(inputs, num_classes, filter_set):
enc1_filter_num = filter_set[0]
one_by_one_filter_num = filter_set[1]
encoder_block1 = encoder_block(inputs, enc1_filter_num, strides=2)
one_by_one_conv = conv2d_batchnorm(encoder_block1,
one_by_one_filter_num,
kernel_size=1,
strides=1)
x = decoder_block(one_by_one_conv, inputs, num_classes)
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
encode_layer_1 = encoder_block(inputs, 32, 2)
encode_layer_2 = encoder_block(encode_layer_1, 64, 2)
encode_layer_3 = encoder_block(encode_layer_2, 128, 2)
convol_layer_1 = conv2d_batchnorm(encode_layer_3,
256,
kernel_size=1,
strides=1)
decode_layer_1 = decoder_block(convol_layer_1, encode_layer_2, 128)
decode_layer_2 = decoder_block(decode_layer_1, encode_layer_1, 64)
decode_layer_3 = decoder_block(decode_layer_2, inputs, 32)
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(decode_layer_3)
def conv2d(x,
filters,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation_=None,
is_training=True):
return activation(
kl.Conv2D(filters,
kernel_size,
strides,
padding,
activation=None,
trainable=is_training)(x), activation_)
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
en_L1 = encoder_block(inputs, 64, 2)
en_L2 = encoder_block(en_L1, 128, 2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
conv1 = conv2d_batchnorm(en_L2, 256, 1, 1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
dec_L1 = decoder_block(conv1, en_L1, 128)
x = decoder_block(dec_L1, inputs, 64)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
# Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
skip_0 = inputs
x = encoder_block(inputs, 32, 2)
skip_1 = x
x = encoder_block(x, 64, 2)
# Add 1x1 Convolution layer using conv2d_batchnorm().
x = conv2d_batchnorm(x, 128, kernel_size=1, strides=1)
# Add the same number of Decoder Blocks as the number of Encoder Blocks
x = decoder_block(x, skip_1, 64)
x = decoder_block(x, skip_0, 32)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax',
padding='same')(x)
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
enc1 = encoder_block(inputs, filters=32, strides=2)
enc2 = encoder_block(enc1, filters=64, strides=2)
enc3 = encoder_block(enc2, filters=128, strides=2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
conv1x1 = conv2d_batchnorm(enc3, filters=64, kernel_size=1, strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
dec1 = decoder_block(conv1x1, enc2, filters=128)
dec2 = decoder_block(dec1, enc1, filters=64)
dec3 = decoder_block(dec2, inputs, filters=32)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax', padding='same')(dec3)
def fcn_model(inputs, num_classes, filters=32):
logging.info('inputs : {}'.format(inputs.shape))
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
input_layer1 = encoder_block(inputs, filters, 2)
input_layer2 = encoder_block(input_layer1, filters * 2, 2)
input_layer3 = encoder_block(input_layer2, filters * 4, 2)
input_layer4 = encoder_block(input_layer3, filters * 8, 2)
input_layer5 = encoder_block(input_layer4, filters * 16, 2)
input_layer6 = encoder_block(input_layer5, filters * 32, 2)
# print out
logging.info('input_layer 1 : {}'.format(input_layer1.shape))
logging.info('input_layer 2 : {}'.format(input_layer2.shape))
logging.info('input_layer 3 : {}'.format(input_layer3.shape))
logging.info('input_layer 4 : {}'.format(input_layer4.shape))
logging.info('input_layer 5 : {}'.format(input_layer5.shape))
logging.info('input_layer 6 : {}'.format(input_layer6.shape))
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
# small_ip_layer = conv2d_batchnorm(input_layer5, filters*32, kernel_size=1, strides=1)
small_ip_layer = conv2d_batchnorm(input_layer6,
filters * 64,
kernel_size=1,
strides=1)
logging.info('small_ip_layer : {}'.format(small_ip_layer.shape))
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
output_layer6 = decoder_block(small_ip_layer, input_layer5, filters * 32)
logging.info('output_layer 6: {}'.format(output_layer6.shape))
output_layer5 = decoder_block(output_layer6, input_layer4, filters * 16)
# output_layer5 = decoder_block(small_ip_layer, input_layer4, filters*16)
logging.info('output_layer 5: {}'.format(output_layer5.shape))
output_layer4 = decoder_block(output_layer5, input_layer3, filters * 8)
logging.info('output_layer 4: {}'.format(output_layer4.shape))
output_layer3 = decoder_block(output_layer4, input_layer2, filters * 4)
logging.info('output_layer 3: {}'.format(output_layer3.shape))
output_layer2 = decoder_block(output_layer3, input_layer1, filters * 2)
logging.info('output_layer 2: {}'.format(output_layer2.shape))
output_layer1 = decoder_block(output_layer2, None, 3)
logging.info('output_layer 1: {}'.format(output_layer1.shape))
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(output_layer1)
def fcn_model(inputs, num_classes):
filters = 64
strides = 2
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
encoder_layer_1 = encoder_block(inputs, filters, strides)
encoder_layer_2 = encoder_block(encoder_layer_1, 2 * filters, strides)
encoder_layer_3 = encoder_block(encoder_layer_2, 4 * filters, strides)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
conv2D_layer = conv2d_batchnorm(encoder_layer_3,
4 * filters,
kernel_size=1,
strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
decoder_layer_1 = decoder_block(conv2D_layer, encoder_layer_2, 4 * filters)
decoder_layer_2 = decoder_block(decoder_layer_1, encoder_layer_1,
2 * filters)
decoder_layer_3 = decoder_block(decoder_layer_2, inputs, filters)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
outputs = layers.Conv2D(num_classes,
1,
activation='softmax',
padding='same')(decoder_layer_3)
# Print network shapes
print(inputs)
print(encoder_layer_1)
print(encoder_layer_2)
print(encoder_layer_3)
print(conv2D_layer)
print(decoder_layer_1)
print(decoder_layer_2)
print(decoder_layer_3)
print(outputs)
return outputs
def fcn_model(inputs, num_classes, layers_num, external_features,
internal_features, conv_layers_num, conv_features):
v = inputs
layer_list = []
for _ in range(layers_num):
layer_list.append(v)
if v == input:
v = encoder_block(v, external_features, 2)
else:
v = encoder_block(v, internal_features, 2)
for _ in range(conv_layers_num):
v = conv2d_batchnorm(v, conv_features)
for _ in range(layers_num):
v = decoder_block(v, layer_list.pop(), internal_features)
return layers.Conv2D(num_classes, 3, activation='softmax',
padding='same')(v)
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
def fcn_model(inputs, num_classes, depth_=32, keepProb=0.6):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
'''
Basic encode/decode
x0 = encoder_block(inputs, depth_, 2)
x1 = encoder_block(x0, depth_*2, 2)
#x1_2 = conv2d_batchnorm(x1, depth_*4, kernel_size=1, strides=1)
x2 = encoder_block(x1, depth_*4, 2)
#x3 = encoder_block(x2, 256, 2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
x3 = conv2d_batchnorm(x2, depth_*8, kernel_size=1, strides=1)
#x3=layers.Dropout(keepProb)(x3)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
#x3 = decoder_block(x4, x2, 256)
x2 = decoder_block(x3, x1, depth_*4)
x1 = decoder_block(x2, x0, depth_*2)
x = decoder_block(x1, inputs, depth_)
#x=layers.Dropout(keepProb)(x)
inputs=x
'''
'''
# Encode 1
x0 = encoder_block(inputs, depth_, 2)
# Encode 2
x1 = encoder_block(x0, depth_*2, 2)
# Encode 2.1
x1_2 = conv2d_batchnorm(x1, depth_*4, kernel_size=1, strides=1)
# Encode 3
x2 = encoder_block(x1_2, depth_*4, 2)
# Encode 4
x3 = encoder_block(x2, depth_*8, 2)
# Fully connected
x4 = conv2d_batchnorm(x3, depth_*16, kernel_size=1, strides=1)
# Decode 1
x3 = decoder_block(x4, x2, depth_*8)
# Decode 2
x2 = decoder_block(x3, x1, depth_*4)
# Decode 3
x1 = decoder_block(x2, x0, depth_*2)
# Decode 4
x = decoder_block(x1, inputs, depth_)
# Decode 4 - update variable
inputs=x
# Encode 1
x0 = encoder_block(inputs, depth_, 2)
# Encode 2
x1 = encoder_block(x0, depth_*2, 2)
# Encode 3
x2 = encoder_block(x1, depth_*4, 2)
# Fully connected
x3 = conv2d_batchnorm(x2, depth_*8, kernel_size=1, strides=1)
# Decode 1
x2 = decoder_block(x3, x1_2, depth_*4)
# Decode 2
x1 = decoder_block(x2, x0, depth_*2)
# Decode 3
x = decoder_block(x1, inputs, depth_)
'''
# Architecture bellow
# https://arxiv.org/abs/1708.01692
# Encode 1
x0 = encoder_block(inputs, depth_, 2)
# Full conn - 1.1
x0_2 = conv2d_batchnorm(x0, depth_ * 2, kernel_size=1, strides=1)
x0_3 = conv2d_batchnorm(x0_2, depth_ * 2, kernel_size=1, strides=1)
# Encode 2
x1 = encoder_block(x0_3, depth_ * 2, 2)
# Full conn - 2.1
x1_2 = conv2d_batchnorm(x1, depth_ * 2, kernel_size=1, strides=1)
x1_3 = conv2d_batchnorm(x1_2, depth_ * 2, kernel_size=1, strides=1)
# Encode 3
x2 = encoder_block(x1_3, depth_ * 4, 2)
# Full conn - 3.1
x2_2 = conv2d_batchnorm(x2, depth_ * 4, kernel_size=1, strides=1)
x2_3 = conv2d_batchnorm(x2_2, depth_ * 4, kernel_size=1, strides=1)
# Encode 4
x3 = encoder_block(x2_3, depth_ * 8, 2)
# Full conn - 3.1
x3_2 = conv2d_batchnorm(x3, depth_ * 8, kernel_size=1, strides=1)
x3_3 = conv2d_batchnorm(x3_2, depth_ * 8, kernel_size=1, strides=1)
# Encode 5
x4 = encoder_block(x3_3, depth_ * 16, 2)
# Full conn - 3.1
x4_2 = conv2d_batchnorm(x4, depth_ * 16, kernel_size=1, strides=1)
x4_3 = conv2d_batchnorm(x4_2, depth_ * 16, kernel_size=1, strides=1)
x4_4 = conv2d_batchnorm(x4_3, depth_ * 16, kernel_size=1, strides=1)
# Fully connected
x5 = conv2d_batchnorm(x4_4, depth_ * 16, kernel_size=1, strides=1)
# Full conn - 4.1
x5_2 = conv2d_batchnorm(x5, depth_ * 16, kernel_size=1, strides=1)
x5_3 = conv2d_batchnorm(x5_2, depth_ * 16, kernel_size=1, strides=1)
x5_4 = conv2d_batchnorm(x5_3, depth_ * 16, kernel_size=1, strides=1)
# Decode 1
x4 = decoder_block(x5_4, x3_3, depth_ * 8)
# Full conn - 1.1
x4_2 = conv2d_batchnorm(x4, depth_ * 8, kernel_size=1, strides=1)
x4_3 = conv2d_batchnorm(x4_2, depth_ * 8, kernel_size=1, strides=1)
x4_4 = conv2d_batchnorm(x4_3, depth_ * 8, kernel_size=1, strides=1)
# Decode 2
x3 = decoder_block(x4_4, x2_3, depth_ * 4)
# Full conn - 2.1
x3_2 = conv2d_batchnorm(x3, depth_ * 4, kernel_size=1, strides=1)
x3_3 = conv2d_batchnorm(x3_2, depth_ * 4, kernel_size=1, strides=1)
x3_4 = conv2d_batchnorm(x3_3, depth_ * 4, kernel_size=1, strides=1)
# Decode 3
x2 = decoder_block(x3_4, x1_3, depth_ * 4)
# Full conn - 3.1
x2_2 = conv2d_batchnorm(x2, depth_ * 2, kernel_size=1, strides=1)
x2_3 = conv2d_batchnorm(x2_2, depth_ * 2, kernel_size=1, strides=1)
x2_4 = conv2d_batchnorm(x2_3, depth_ * 2, kernel_size=1, strides=1)
# Decode 4
x2 = decoder_block(x2_4, x0_3, depth_ * 2)
# Decode 5
x = decoder_block(x2, inputs, depth_)
## How to use encode/decode
#x = encode_decode(inputs, 3, depth_=depth_, keepProb=keepProb)
#x = encode_decode(x, 3, depth_=depth_, keepProb=keepProb)
#x = encode_decode(x, 3, depth_=depth_, keepProb=keepProb)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 1, activation='softmax',
padding='same')(x)
With default values, it returns element-wise `max(x, 0)`
' Arguments:\n',
' x: A tensor or variable.\n',
' alpha: A scalar, slope of negative section (default=`0.`).\n',
' max_value: Saturation threshold.\n',
' Returns:\n',
' A tensor.\n',
"""
# create Conv2D tensor placeholder with input tensor
conv2d_tensor = layers.Conv2D(
filters=2,
kernel_size=(3, 3),
activation='relu',
padding='same',
data_format='channels_last',
# data_format='channels_first', # .keras/keras.json is determined
name='block1_conv1')(input_tensor)
"""
~/.keras/keras.json
{
"image_dim_ordering": "tf",
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "tensorflow"
}
"""