def Encoder(input_shape, embedding_dimension, drop_out=0.05):
#Input placeholders
inp_placeholder = tf.keras.Input(shape=input_shape)
#Convolution layer 1
layer1 = layers.Conv2D(40, 25, activation='relu', name="L11")(inp_placeholder)
norm1 = layers.BatchNormalization()(layer1)
drops1 = layers.SpatialDropout2D(drop_out)(norm1)
out1 = layers.MaxPooling2D(5)(drops1)
#Convolution layer 2
layer2 = layers.Conv2D(20, 15, activation='relu', name="L21")(out1)
norm2 = layers.BatchNormalization()(layer2)
drops2 = layers.SpatialDropout2D(drop_out)(norm2)
out2 = layers.MaxPooling2D(2)(drops2)
#Convolution layer 3
layer3 = layers.Conv2D(10, 5, activation='relu', name="L31")(out2)
norm3 = layers.BatchNormalization()(layer3)
out3 = layers.SpatialDropout2D(drop_out)(norm3)
#Flattened layer
flatten = layers.Flatten()(out3)
#Dense Layer
embeds = layers.Dense(embedding_dimension, activation = "sigmoid", name="D11")(flatten)
#Definining our model
encoder = tf.keras.Model(inputs=inp_placeholder, outputs = embeds)
return encoder
def __init__(self,
num_channels,
num_conv_layers=2,
kernel_size=(3, 3),
pool_size=(2, 2),
nonlinearity='relu',
use_batchnorm=True,
use_bias=True,
use_dropout=False,
dropout_rate=0.25,
use_spatial_dropout=True,
data_format='channels_last',
**kwargs):
super(SegNet_Conv2D_Block, self).__init__(**kwargs)
for _ in range(num_conv_layers):
self.add(tfkl.Conv2D(num_channels,
kernel_size,
padding='same',
use_bias=use_bias,
data_format=data_format))
if use_batchnorm:
self.add(tfkl.BatchNormalization(axis=-1,
momentum=0.95,
epsilon=0.001))
self.add(tfkl.Activation(nonlinearity))
if use_dropout:
if use_spatial_dropout:
self.add(tfkl.SpatialDropout2D(rate=dropout_rate))
else:
self.add(tfkl.Dropout(rate=dropout_rate))
self.add(tfkl.MaxPool2D(pool_size))
def wrapper(input_tensor):
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='cls/zeropad1')(input_tensor)
x = layers.Conv2D(
filters=filters,
kernel_size=(3, 3),
padding='valid',
kernel_initializer='glorot_uniform',
name='cls/conv1',
)(x)
if(use_batchnorm):
x = layers.BatchNormalization(axis=bn_axis, name='cls/bn1')(x)
x = layers.Activation('relu', name='cls/relu1')(x)
# model regularization
if dropout is not None:
x = layers.SpatialDropout2D(dropout, name='cls/drp1')(x)
# model head
x = layers.Conv2D(
filters=n_classes,
kernel_size=(1, 1),
padding='valid',
kernel_initializer='glorot_uniform',
name='final_conv',
)(x)
return x
def neural_network_spatial():
input_ = layers.Input(shape=(32, 32, 3))
cnn = layers.Conv2D(16, (3, 3), activation="relu")(input_)
cnn = layers.SpatialDropout2D(______)(cnn)
cnn = layers.MaxPooling2D()(cnn)
cnn = layers.Conv2D(32, (3, 3), activation="relu")(cnn)
cnn = layers.____________(cnn)
cnn = layers.MaxPooling2D()(cnn)
flatten = layers.GlobalMaxPooling2D()(cnn)
dense = layers.Dense(32, activation="relu")(flatten)
dense = layers.Dropout(_______)(dense)
dense = layers.Dense(16, activation="relu")(dense)
output = layers.Dense(10, activation="softmax")(dense)
opt = optimizers.Adam()
m = models.Model(input_, output)
m.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
return m
def get_model(in_shape, out_classes, dropout_rate=0.2, noise=1, activation='relu', combo='add', regression=False):
in_tensor = layers.Input(shape=in_shape, name='input')
in_tensor = add_features(in_tensor)
vgg19 = keras.applications.VGG19(include_top=False, weights=None, input_tensor=in_tensor)
base_in = vgg19.input
base_out = vgg19.output
concat_layers = ['block5_conv4', 'block4_conv4', 'block3_conv4', 'block2_conv2', 'block1_conv2']
concat_tensors = [vgg19.get_layer(layer).output for layer in concat_layers]
decoder0 = decoder_block(
base_out, n_filters=1028, n_convs=3, i=0,
rate=dropout_rate, noise=noise, activation=activation
) # 64
decoder1 = decoder_block(
decoder0, concat_tensor=concat_tensors[0], n_filters=512, n_convs=3, i=2,
rate=dropout_rate, noise=noise, activation=activation
)
decoder2 = decoder_block(
decoder1, concat_tensor=concat_tensors[1], n_filters=512, n_convs=3, i=3,
rate=dropout_rate, noise=noise, activation=activation
)
decoder3 = decoder_block(
decoder2, concat_tensor=concat_tensors[2], n_filters=256, n_convs=2, i=4,
rate=dropout_rate, noise=noise, activation=activation
)
decoder4 = decoder_block(
decoder3, concat_tensor=concat_tensors[3], n_filters=128, n_convs=2, i=5,
rate=dropout_rate, noise=noise, activation=activation
)
out_branch = conv_layer(64, (3, 3), name=f'out_block_conv1')(decoder4)
out_branch = layers.BatchNormalization(name=f'out_block_batchnorm1')(out_branch)
out_branch = layers.Activation(activation, name='out_block_activation1')(out_branch)
if combo == 'add':
out_branch = layers.add([out_branch, concat_tensors[4]], name='out_block_residual')
elif combo == 'concat':
out_branch = layers.concatenate([out_branch, concat_tensors[4]], name='out_block_concat')
out_branch = layers.SpatialDropout2D(rate=dropout_rate, seed=0, name='out_block_spatialdrop')(out_branch)
out_branch = conv_layer(64, (5, 5), name='out_block_conv2')(out_branch)
out_branch = layers.BatchNormalization(name='out_block_batchnorm2')(out_branch)
out_branch = layers.Activation(activation, name='out_block_activation2')(out_branch)
output = layers.Conv2D(out_classes, (1, 1), name='final_conv')(out_branch)
if regression:
out_activation = "linear"
else:
if out_classes == 1:
out_activation = "sigmoid"
else:
out_activation = "softmax"
output = layers.Activation(out_activation, name='final_out')(output)
model = models.Model(inputs=[base_in], outputs=[output], name='vgg19-unet')
return model
def conv_block(filters, kernal, padding='same', stride=1, activation=None, add_bn=True, drop_rate=0):
block = [layers.Conv2D(filters, kernal, activation=None, padding='same', strides=stride)]
if add_bn:
block.append(layers.BatchNormalization())
if activation is not None:
block.append(activation)
if drop_rate > 0:
block.append(layers.SpatialDropout2D(rate=drop_rate))
return models.Sequential(block)
def _conv_block(filters, kernel_size, x):
x = ly.Conv2D(
filters,
kernel_size,
kernel_constraint=tf.keras.constraints.max_norm(max_value=3.36))(x)
x = ly.SpatialDropout2D(0.25)(x)
x = ly.BatchNormalization(axis=-1)(x)
x = ly.Activation("relu")(x)
x = ly.MaxPooling2D()(x)
return x
def __init__(self,
num_channels,
use_2d=True,
num_conv_layers=2,
kernel_size=3,
activation='relu',
use_batchnorm=False,
use_bias=True,
use_dropout=False,
dropout_rate=0.25,
use_spatial_dropout=True,
data_format='channels_last',
name="convolution_block",
**kwargs):
super(Conv_Block, self).__init__(name=name)
for _ in range(num_conv_layers):
if use_2d:
self.add(
tfkl.Conv2D(num_channels,
kernel_size,
padding='same',
use_bias=use_bias,
data_format=data_format))
else:
self.add(
tfkl.Conv3D(num_channels,
kernel_size,
padding='same',
use_bias=use_bias,
data_format=data_format))
if use_batchnorm:
self.add(
tfkl.BatchNormalization(
axis=-1 if data_format == 'channels_last' else 1,
momentum=0.95,
epsilon=0.001))
if activation == 'prelu':
self.add(tfkl.PReLU())
else:
self.add(tfkl.Activation(activation))
if use_dropout:
if use_spatial_dropout:
if use_2d:
self.add(tfkl.SpatialDropout2D(rate=dropout_rate))
else:
self.add(tfkl.SpatialDropout3D(rate=dropout_rate))
else:
self.add(tfkl.Dropout(rate=dropout_rate))
def build_psp(
backbone,
psp_layer_idx,
pooling_type='avg',
conv_filters=512,
use_batchnorm=True,
final_upsampling_factor=8,
classes=21,
activation='softmax',
dropout=None,
):
input_ = backbone.input
x = (backbone.get_layer(name=psp_layer_idx).output if isinstance(
psp_layer_idx, str) else backbone.get_layer(
index=psp_layer_idx).output)
# x = (get_layer_number(backbone, psp_layer_idx) if isinstance(psp_layer_idx, str) else psp_layer_idx)
# build spatial pyramid
x1 = SpatialContextBlock(1, conv_filters, pooling_type, use_batchnorm)(x)
x2 = SpatialContextBlock(2, conv_filters, pooling_type, use_batchnorm)(x)
x3 = SpatialContextBlock(3, conv_filters, pooling_type, use_batchnorm)(x)
x6 = SpatialContextBlock(6, conv_filters, pooling_type, use_batchnorm)(x)
# aggregate spatial pyramid
concat_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.Concatenate(axis=concat_axis,
name='psp_concat')([x, x1, x2, x3, x6])
x = Conv1x1BnReLU(conv_filters, use_batchnorm, name='aggregation')(x)
# model regularization
if dropout is not None:
x = layers.SpatialDropout2D(dropout, name='spatial_dropout')(x)
# model head
x = layers.Conv2D(
filters=classes,
kernel_size=(3, 3),
padding='same',
kernel_initializer='glorot_uniform',
name='final_conv',
)(x)
x = layers.UpSampling2D(final_upsampling_factor,
name='final_upsampling',
interpolation='bilinear')(x)
if activation in {'softmax', 'sigmoid'}:
x = layers.Activation(activation, name=activation)(x)
model = models.Model(input_, x)
return model
def get_discriminator_block(out_filters, bn=True):
model = keras.Sequential()
model.add(
layers.Conv2D(filters=out_filters,
kernel_size=3,
strides=2,
padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.SpatialDropout2D(0.25))
if bn:
model.add(layers.BatchNormalization())
return model
def encoder(self, features=[8], name="encoder") -> KM.Model:
"""Creates an encoder model object
Args:
features (list, optional): list of features in successive hidden layers. Defaults to [8].
name (str, optional): name for the model object. Defaults to "encoder".
Returns:
KM.Model: Encoder model
"""
input_tensor = KL.Input(
shape=(32, 32, 3)) # shape of images for cifar10 dataset
encoded = KL.Conv2D(
features[0],
3,
strides=(2, 2),
padding="same",
use_bias=False,
name=name + f"_conv_{1}",
)(input_tensor)
encoded = KL.Activation("relu")(KL.BatchNormalization()(encoded))
encoded_list = [encoded]
# Prepare the skip tensor from input
skip_input_tensor = KL.Activation("relu")(
KL.BatchNormalization()(KL.Conv2D(features[0],
1,
strides=1,
use_bias=False)(input_tensor)))
skip_input_tensor = KL.SpatialDropout2D(rate=0.2)(skip_input_tensor)
skip_input_tensor = KL.AveragePooling2D(pool_size=(2, 2),
strides=2)(skip_input_tensor)
skip_tensors = tf.concat(
[
skip_input_tensor, # Routing info from input tensor to next levels
encoded, # Routes info from second level to next levels
],
axis=-1,
)
for i, feature_num in enumerate(features[1:], start=2):
encoded, skip_tensors = conv_block(
encoded,
skip_tensors,
features_in=features[i - 2],
features_out=feature_num,
name=name + f"_conv_{i}",
)
encoded_list.append(encoded)
return KM.Model(inputs=input_tensor, outputs=encoded_list, name=name)
def keras_dropout(layer, rate):
"""
Keras dropout layer.
"""
from keras import layers
input_dim = len(layer.input.shape)
if input_dim == 2:
return layers.SpatialDropout1D(rate)
elif input_dim == 3:
return layers.SpatialDropout2D(rate)
elif input_dim == 4:
return layers.SpatialDropout3D(rate)
else:
return layers.Dropout(rate)
def conv_block(inputs, filters, spatial_dropout=0.0, max_pool=True):
x = layers.Conv2D(filters=filters,
kernel_size=(3, 3),
padding='same',
activation='relu')(inputs)
x = layers.Conv2D(filters=filters,
kernel_size=(3, 3),
padding='same',
activation=None)(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
if (spatial_dropout > 0.0):
x = layers.SpatialDropout2D(spatial_dropout)(x)
if (max_pool == True):
x = layers.MaxPool2D(pool_size=(2, 2))(x)
return x
def conv_block(name,
filters,
kernel_size=4,
pad="same",
t=False,
act="relu",
bn=True):
block = Sequential(name=name)
if act == "relu":
block.add(L.ReLU())
elif act == "leaky_relu":
block.add(L.LeakyReLU(0.2))
if not t:
block.add(
L.Conv2D(
filters,
kernel_size=kernel_size,
strides=(2, 2),
padding=pad,
use_bias=True,
activation=None,
kernel_initializer=RandomNormal(0.0, 0.2),
))
else:
block.add(L.UpSampling2D(interpolation="bilinear"))
block.add(
L.Conv2DTranspose(
filters=filters,
kernel_size=kernel_size - 1,
padding=pad,
activation=None,
))
if dropout > 0:
block.add(L.SpatialDropout2D(dropout))
if bn:
block.add(
L.BatchNormalization(axis=-1, epsilon=1e-05, momentum=0.9))
return block
def perceptual_layer(weights: float = 1.0, drop: float = 0.5) -> KM.Model:
"""
Preceptual loss on latent features as in Johnson et al 2015 https://arxiv.org/abs/1603.08155
Args:
weights (float, optional): weighing for the loss. Defaults to 1.0.
drop (float, optional): randomly drop channels for regularization. Defaults to 0.5.
Returns:
KM.Model: perceptual error calculating model
"""
# pylint: disable = E1123, E1124, E1120
# Ground truth
input1 = KL.Input(shape=(None, None, 3))
# Model output
input2 = KL.Input(shape=(None, None, 3))
# concat the two tensors above
input_tensor = tf.concat([input1, input2], axis=0)
# VGG19 feature extractor trained on Imagenet
feature_extractor = tf.keras.applications.VGG19(include_top=False,
weights="imagenet")
# input_tensor is normalized between (-1.0, 1.0)
# extractor compatible format
inputs = 127.5 * (input_tensor + 1.0)
inputs = tf.keras.applications.vgg19.preprocess_input(inputs,
data_format=None)
feature_maps = feature_extractor(inputs)
# Extract deep features for the GT and generated image
content, generated = tf.split(feature_maps, num_or_size_splits=2, axis=0)
# Randomly zero-out some feature differences
drop_features = KL.SpatialDropout2D(rate=drop)(content - generated)
error = (weights / (1 - drop)) * K.mean(K.square(drop_features))
return KM.Model(inputs=[input1, input2], outputs=error, name="vgg")
def dilated_cnn(inputs,
num_filters,
max_dilation,
dilation_rep,
filter_size,
dropout=0.0,
bn_decay=0.999,
bn_epsilon=1.0e-8,
bn_scale=False,
is_training=True):
"""Constructs a base dilated convolutional network.
Args:
inputs: Typically [batch, h, w, [3,6]] Input RGB images. Two 3-channel
images are concatenated for stereo.
num_filters: The number of filters for all layers.
max_dilation: Size of the last dilation of a series. Must be a power of
two.fine
dilation_rep: Number of times to repeat the last dilation.
filter_size: kernel size for CNNs.
dropout: >0 if dropout is to be applied.
bn_decay: batchnorm parameter.
bn_epsilon: batchnorm parameter.
bn_scale: True to scale batchnorm.
is_training: True if this function is called during training.
Returns:
Output of this dilated CNN.
"""
# Progression of powers of 2: [1, 2, 4, 8 ... max_dliation].
maxlog = int(math.log(max_dilation, 2))
seq = [2**x for x in range(maxlog + 1)]
seq += [1] * (dilation_rep - 1)
net = inputs
for i, r in enumerate([1] + seq + seq + [1]):
# Split off head before the last dilation 1 convolutions.
if i == (len(seq) * 2 - dilation_rep + 2):
head = net
fs = filter_size
net = layers.Conv2D(num_filters,
fs,
dilation_rate=r,
padding='same',
kernel_regularizer=tf.keras.regularizers.l2(0.001),
use_bias=False,
trainable=is_training,
name='dil_conv_%d_%d' % (r, i))(net)
# From https://arxiv.org/pdf/1905.05928.pdf; batchnorm then dropout
# slim layers has decay/momentum = 0.999, not 0.99.
# slim layers has scale=False, not scale=True.
net = layers.BatchNormalization(scale=bn_scale,
epsilon=bn_epsilon,
trainable=is_training,
momentum=bn_decay)(
net, training=is_training)
net = layers.LeakyReLU(alpha=0.1)(net)
if dropout and i == len(seq):
net = layers.SpatialDropout2D(dropout)(net, training=is_training)
return net, head
def conv_block(
input_tensor: tf.Tensor,
skip_tensors: List[tf.Tensor],
features_in: int,
features_out: int,
name: str,
) -> Tuple[tf.Tensor, List[tf.Tensor]]:
"""Bottleneck style convolutional block with skip connections across blocks. Applies downsample convolution in lower features space.
Followed by single kernel convolution to higher feature space. Also, applies skip connections across blocks for routing information
across levels.
Args:
input_tensor (tf.Tensor): tensor to apply convolution to
skip_tensors (List[tf.Tensor]): list of output tensors from previous blocks
features_in (int): number of features for incoming layer
features_out (int): number of features for outgoing layer
name (str): name for the tensors
Returns:
Tuple[tf.Tensor, List[tf.Tensor]]: output tensor, list of tensors to route info to next levels
"""
out = KL.Conv2D(
features_in,
1,
strides=(1, 1),
padding="same",
use_bias=False,
name=name + f"_c{1}",
)(input_tensor)
out = KL.Activation("relu")(KL.BatchNormalization()(out))
out = KL.Conv2D(
features_in,
3,
strides=(2, 2),
padding="same",
use_bias=False,
name=name + f"_c{2}",
)(out)
out = KL.Activation("relu")(KL.BatchNormalization()(out))
out = KL.Conv2D(
features_out,
1,
strides=(1, 1),
padding="same",
use_bias=False,
name=name + f"_c{3}",
)(out)
out = KL.BatchNormalization()(out)
# Calculate skip tensor from previous levels
skip_connection = KL.AveragePooling2D(pool_size=(2, 2),
strides=2)(skip_tensors)
out = KL.Activation("relu", name=name + "_relu")(out + skip_connection)
out = KL.SpatialDropout2D(rate=0.2)(out)
# skip tensor for next level
skip_tensors = tf.concat([skip_connection, out], axis=-1)
return out, skip_tensors
def build_fpn(
backbone,
skip_connection_layers,
pyramid_filters=256,
segmentation_filters=128,
classes=1,
activation='sigmoid',
use_batchnorm=True,
aggregation='sum',
dropout=None,
):
input_ = backbone.input
x = backbone.output
# building decoder blocks with skip connections
ls = ([
get_layer_number(backbone, l) if isinstance(l, str) else l
for l in skip_connection_layers
])
skips = ([backbone.layers[c].output for c in ls])
# x = (backbone.get_layer(name=psp_layer_idx).output if isinstance(psp_layer_idx, str)
# else backbone.get_layer(index=psp_layer_idx).output)
# build FPN pyramid
p5 = FPNBlock(pyramid_filters, stage=5)(x, skips[0])
p4 = FPNBlock(pyramid_filters, stage=4)(p5, skips[1])
p3 = FPNBlock(pyramid_filters, stage=3)(p4, skips[2])
p2 = FPNBlock(pyramid_filters, stage=2)(p3, skips[3])
# add segmentation head to each
s5 = DoubleConv3x3BnReLU(segmentation_filters,
use_batchnorm,
name='segm_stage5')(p5)
s4 = DoubleConv3x3BnReLU(segmentation_filters,
use_batchnorm,
name='segm_stage4')(p4)
s3 = DoubleConv3x3BnReLU(segmentation_filters,
use_batchnorm,
name='segm_stage3')(p3)
s2 = DoubleConv3x3BnReLU(segmentation_filters,
use_batchnorm,
name='segm_stage2')(p2)
# upsampling to same resolution
s5 = layers.UpSampling2D((8, 8),
interpolation='nearest',
name='upsampling_stage5')(s5)
s4 = layers.UpSampling2D((4, 4),
interpolation='nearest',
name='upsampling_stage4')(s4)
s3 = layers.UpSampling2D((2, 2),
interpolation='nearest',
name='upsampling_stage3')(s3)
# aggregating results
if aggregation == 'sum':
x = layers.Add(name='aggregation_sum')([s2, s3, s4, s5])
elif aggregation == 'concat':
concat_axis = 3 if backend.image_data_format(
) == 'channels_last' else 1
x = layers.Concatenate(axis=concat_axis,
name='aggregation_concat')([s2, s3, s4, s5])
else:
raise ValueError(
'Aggregation parameter should be in ("sum", "concat"), '
'got {}'.format(aggregation))
if dropout:
x = layers.SpatialDropout2D(dropout, name='pyramid_dropout')(x)
# final stage
x = Conv3x3BnReLU(segmentation_filters, use_batchnorm,
name='final_stage')(x)
x = layers.UpSampling2D(size=(2, 2),
interpolation='bilinear',
name='final_upsampling')(x)
# model head (define number of output classes)
x = layers.Conv2D(
filters=classes,
kernel_size=(3, 3),
padding='same',
use_bias=True,
kernel_initializer='glorot_uniform',
name='head_conv',
)(x)
if activation in {'softmax', 'sigmoid'}:
x = layers.Activation(activation, name=activation)(x)
# x = layers.Activation(activation, name=activation)(x)
# create keras model instance
model = models.Model(input_, x)
return model
def get_base_model(leaky_relu_slope,
dropout_rate,
regularization_rate,
input_shape = (48, 48, 1),
n_classes = 8,
logits = False):
regularization = l2(regularization_rate)
model = keras.Sequential([
layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same',
input_shape = input_shape),
layers.BatchNormalization(),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.SpatialDropout2D(dropout_rate),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.SpatialDropout2D(dropout_rate),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(192,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(192,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.SpatialDropout2D(dropout_rate),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(384,
(3, 3),
kernel_regularizer = regularization,
padding = 'same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.SpatialDropout2D(dropout_rate),
layers.LeakyReLU(leaky_relu_slope),
layers.SeparableConv2D(n_classes, (1, 1), padding = 'same'),
layers.GlobalAveragePooling2D()
])
if not logits:
model.append(layers.Softmax())
return model
def keypose_model(mparams, is_training):
"""Constructs a Keras model that predicts 3D keypoints.
Model input is left and optionally right image, modelx x modely x 3, float32.
Values are from 0.0 to 1.0
Args:
mparams: ConfigParams object use_stereo - True if right image is input.
num_filters - The number of filters for all layers. num_kp - The number of
keypoints. ...
is_training: True if training the model.
Returns:
uv: [batch, num_kp, 2] 2D locations of keypoints.
d: [batch, num_kp] The inverse depth of keypoints.
prob_viz: A visualization of all predicted keypoints.
prob_vizs: A list of visualizations of each keypoint.
kp_viz: A visualization of GT keypoints.
img_out: The photometrically and geometrically altered image.
rot: rotation matrix modifying input: [batch, 3, 3].
"""
print('Mparams in keypose_model:\n', mparams)
use_stereo = mparams.use_stereo
num_filters = mparams.num_filters
max_dilation = mparams.max_dilation
dilation_rep = mparams.dilation_rep
dropout = mparams.dropout
num_kp = mparams.num_kp
modelx = mparams.modelx
modely = mparams.modely
filter_size = mparams.filter_size
bn_decay = mparams.batchnorm[0]
bn_epsilon = mparams.batchnorm[1]
bn_scale = mparams.batchnorm[2]
# Aux params input to the model.
offsets = keras.Input(shape=(3, ), name='offsets', dtype='float32')
hom = keras.Input(shape=(3, 3), name='hom', dtype='float32')
to_world = keras.Input(shape=(4, 4), name='to_world_L', dtype='float32')
# Images input to the model.
img_l = keras.Input(shape=(modely, modelx, 3),
name='img_L',
dtype='float32')
img_l_norm = layers.Lambda(norm_image)(img_l)
img_r = keras.Input(shape=(modely, modelx, 3),
name='img_R',
dtype='float32')
if use_stereo:
img_r_norm = layers.Lambda(norm_image)(img_r)
img_l_norm = layers.concatenate([img_l_norm, img_r_norm])
net, _ = dilated_cnn(img_l_norm,
num_filters,
max_dilation,
dilation_rep,
filter_size,
bn_decay=bn_decay,
bn_epsilon=bn_epsilon,
bn_scale=bn_scale,
dropout=dropout,
is_training=is_training)
print('Dilation net shape:', net.shape)
# Regression to keypoint values.
if mparams.use_regress:
if dropout:
net = layers.SpatialDropout2D(dropout)(net, training=is_training)
net = layers.Conv2D(64,
1,
kernel_regularizer=tf.keras.regularizers.l2(0.001),
use_bias=False,
padding='valid')(net)
net = layers.BatchNormalization(scale=bn_scale,
epsilon=bn_epsilon,
momentum=bn_decay)(
net, training=is_training)
net = layers.LeakyReLU(alpha=0.1)(net)
net = layers.Conv2D(64,
1,
kernel_regularizer=tf.keras.regularizers.l2(0.001),
use_bias=False,
padding='valid')(net)
net = layers.BatchNormalization(scale=bn_scale,
epsilon=bn_epsilon,
momentum=bn_decay)(
net, training=is_training)
net = layers.LeakyReLU(alpha=0.1)(net)
net = layers.Conv2D(num_kp * 3,
1,
kernel_regularizer=tf.keras.regularizers.l2(0.001),
padding='valid')(net) # [batch, h, w, num_kp * 3]
net = tf.reduce_mean(net, axis=[-3, -2]) # [batch, num_kp * 3]
print('Regress reduce mean shape:', net.shape)
uvd = tf.reshape(net, [-1, num_kp, 3]) # [batch, num_kp, 3]
print('Regress uvd shape:', uvd.shape)
prob = tf.stack([tf.zeros_like(img_l[Ellipsis, 0])] * num_kp, axis=1)
disp_map = prob
# [batch, num_kp, h, w]
else:
# The probability distribution map for keypoints. No activation.
prob = layers.Conv2D(
num_kp,
filter_size,
dilation_rate=1,
kernel_regularizer=tf.keras.regularizers.l2(0.001),
padding='same')(net)
# Disparity map.
disp_map = layers.Conv2D(
num_kp,
filter_size,
dilation_rate=1,
kernel_regularizer=tf.keras.regularizers.l2(0.001),
padding='same')(net)
# [batch_size, h, w, num_kp]
prob = layers.Permute((3, 1, 2))(prob)
disp_map = layers.Permute((3, 1, 2))(disp_map)
# [batch_size, num_kp, h, w]
prob = layers.Reshape((num_kp, modely * modelx))(prob)
prob = layers.Softmax()(prob)
prob = layers.Reshape((num_kp, modely, modelx), name='prob')(prob)
disp = layers.multiply([prob, disp_map])
disp = k_reduce_sum(disp, axis=[-1, -2], name='disp_out')
ranx, rany = meshgrid(modelx, modely)
# Use centroid to find indices.
sx = k_reduce_mult_sum(prob, ranx, axis=[-1, -2])
sy = k_reduce_mult_sum(prob, rany, axis=[-1, -2])
# uv are in normalized coords [-1, 1], uv order.
uvd = layers.concatenate([sx, sy, disp])
uvd = layers.Reshape((3, num_kp))(uvd)
uvd = layers.Permute((2, 1), name='uvd')(uvd) # [batch, num_kp, 3]
uv_pix_raw, uv_pix, uvdw, uvdw_pos = convert_uvd_raw(
uvd, offsets, hom, mparams)
xyzw = project(to_world, uvdw_pos, True) # [batch, 4, num_kp]
model = keras.Model(inputs={
'img_L': img_l,
'img_R': img_r,
'offsets': offsets,
'hom': hom,
'to_world_L': to_world
},
outputs={
'uvd': uvd,
'uvdw': uvdw,
'uvdw_pos': uvdw_pos,
'uv_pix': uv_pix,
'uv_pix_raw': uv_pix_raw,
'xyzw': xyzw,
'prob': prob,
'disp': disp_map
},
name='keypose')
model.summary()
return model
def get_smart_model(input,
leaky_relu_slope,
dropout_rate,
regularization_rate,
input_shape = (48, 48, 1),
n_classes = 8,
logits = False):
regularization = l2(regularization_rate)
x = layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same',
input_shape = input_shape)(input)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.MaxPooling2D((2, 2))(x)
x = layers.SpatialDropout2D(dropout_rate)(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(48,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.MaxPooling2D((2, 2))(x)
x = layers.SpatialDropout2D(dropout_rate)(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.MaxPooling2D((2, 2))(x)
x = layers.SpatialDropout2D(dropout_rate)(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.SeparableConv2D(96,
(3, 3),
kernel_regularizer = regularization,
padding = 'same')(x)
x = layers.BatchNormalization()(x)
x = layers.MaxPooling2D((2, 2))(x)
x = layers.SpatialDropout2D(dropout_rate)(x)
x = layers.LeakyReLU(leaky_relu_slope)(x)
x = layers.Conv2D(n_classes, (1, 1), padding = 'same')(x)
output = layers.GlobalAveragePooling2D()(x)
if not logits:
output = layers.Softmax()(output)
model = Model(input, output)
return model
def Convolutional(input_shape=(51, 51, 1),
conv_layers_dimensions=(16, 32, 64, 128),
dense_layers_dimensions=(32, 32),
steps_per_pooling=1,
dropout=(),
dense_top=True,
number_of_outputs=3,
output_activation=None,
output_kernel_size=3,
loss=nd_mean_absolute_error,
convolution_block="convolutional",
pooling_block="pooling",
dense_block="dense",
**kwargs):
"""Creates and compiles a convolutional neural network.
A convolutional network with a dense top.
Parameters
----------
input_shape : tuple of ints
Size of the images to be analyzed.
conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer.
dense_layers_dimensions : tuple of ints
Number of units in each dense layer.
dropout : tuple of float
Adds a dropout between the convolutional layers
number_of_outputs : int
Number of units in the output layer.
output_activation : str or keras activation
The activation function of the output.
loss : str or keras loss function
The loss function of the network.
layer_function : Callable[int] -> keras layer
Function that returns a convolutional layer with convolutions
determined by the input argument. Can be use to futher customize the network.
Returns
-------
keras.models.Model
Deep learning network
"""
# Update layer functions
dense_block = as_block(dense_block)
convolution_block = as_block(convolution_block)
pooling_block = as_block(pooling_block)
### INITIALIZE DEEP LEARNING NETWORK
if isinstance(input_shape, list):
inputs = [layers.Input(shape for shape in input_shape)]
inputs = layers.Concatenate(axis=-1)(inputs)
else:
network_input = layers.Input(input_shape)
inputs = network_input
layer = inputs
### CONVOLUTIONAL BASIS
for conv_layer_dimension in conv_layers_dimensions:
for _ in range(steps_per_pooling):
layer = convolution_block(conv_layer_dimension)(layer)
if dropout:
layer = layers.SpatialDropout2D(dropout[0])(layer)
dropout = dropout[1:]
# add pooling layer
layer = pooling_block(conv_layer_dimension)(layer)
# DENSE TOP
if dense_top:
layer = layers.Flatten()(layer)
for dense_layer_dimension in dense_layers_dimensions:
layer = dense_block(dense_layer_dimension)(layer)
output_layer = layers.Dense(number_of_outputs,
activation=output_activation)(layer)
else:
output_layer = layers.Conv2D(
number_of_outputs,
kernel_size=output_kernel_size,
activation=output_activation,
padding="same",
name="output",
)(layer)
model = models.Model(inputs, output_layer)
return KerasModel(model, loss=loss, **kwargs)
validation_gen = validation_image_generator.flow_from_directory(
directory=str(tmp_validation_data_dir),
batch_size=BATCH_SIZE,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes=list(validation_class_names))
epochs = 30
model = models.Sequential()
model.add(
layers.Conv2D(32,
3,
padding='same',
activation='relu',
input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)))
model.add(layers.MaxPooling2D())
model.add(layers.SpatialDropout2D(0.1))
model.add(layers.Conv2D(32, 3, padding='same', activation='relu'))
model.add(layers.MaxPooling2D())
model.add(layers.SpatialDropout2D(0.1))
model.add(layers.Conv2D(64, 3, padding='same', activation='relu'))
model.add(layers.MaxPooling2D())
model.add(layers.SpatialDropout2D(0.1))
model.add(layers.UpSampling2D())
model.add(layers.Conv2D(128, 3, padding='same', activation='relu'))
model.add(layers.MaxPooling2D())
model.add(layers.SpatialDropout2D(0.1))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(43))
# ?, activation='softmax'
model.compile(optimizer='adam',
def create_model(model_layers, config, compile=True):
model = models.Sequential()
for item in model_layers:
if (item["type"] == "EMBEDDING"):
model.add(
layers.Embedding(input_dim=item["input_dim"],
output_dim=item["output_dim"],
input_length=item["input_length"]))
elif (item["type"] == "MAX_POOLING"):
model.add(
layers.MaxPooling1D(pool_size=item["max_pooling_size"],
strides=item["max_pooling_strides"]))
elif (item["type"] == "CNN_1D"):
model.add(
layers.Conv1D(item["num_filters"],
item["kernel_size"],
activation=item["activation"]))
elif (item["type"] == "LSTM"):
if (item["recurrent_dropout"] > 0):
model.add(
layers.LSTM(units=item["unit"],
recurrent_dropout=item["recurrent_dropout"]))
else:
model.add(layers.LSTM(units=item["units"]))
elif (item["type"] == "BiLSTM"):
if (item["recurrent_dropout"] > 0
and item["recurrent_dropout"] < 1):
model.add(
layers.Bidirectional(
layers.LSTM(
units=item["units"],
recurrent_dropout=item["recurrent_dropout"])))
else:
model.add(
layers.Bidirectional(layers.LSTM(units=item["units"])))
elif (item["type"] == "GRU"):
if (item["recurrent_dropout"] > 0
and item["recurrent_dropout"] < 1):
model.add(
layers.GRU(units=item["units"],
recurrent_dropout=item["recurrent_dropout"]))
else:
model.add(layers.GRU(units=item["units"]))
elif (item["type"] == "BiGRU"):
if (item["recurrent_dropout"] > 0):
model.add(
layers.Bidirectional(
layers.GRU(
units=item["units"],
recurrent_dropout=item["recurrent_dropout"])))
else:
model.add(layers.Bidirectional(
layers.GRU(units=item["units"])))
elif (item["type"] == "GLOBAL"):
model.add(layers.GlobalMaxPooling1D())
elif (item["type"] == "FLATTEN"):
model.add(layers.Flatten())
elif (item["type"] == "DENSE"):
model.add(
layers.Dense(item["neurons"], activation=item["activation"]))
elif (item["type"] == "DROPOUT"):
if (item["dropout"] > 0 and item["dropout"] < 1):
model.add(layers.Dropout(rate=item["dropout"]))
elif (item["type"] == "SPATIAL_DROPOUT_2D"):
if (item["dropout"] > 0 and item["dropout"] < 1):
model.add(layers.SpatialDropout2D(rate=item["dropout"]))
else:
continue
# optimalizáló és veszteség függvények beállítása
if compile == True:
model.compile(optimizer=config["optimizer"],
loss=config["loss"],
metrics=config["metrics"])
# modell összegzése
if (config["verbose"] >= 1):
model.summary()
return model
def gated_resnet(x,
a=None,
h=None,
conv2d=down_shifted_conv2d,
nonlinearity=concat_elu,
kernel_size=(2, 3),
dropout_rate=0.1,
**kwargs):
"""Build a single Gated Masked Conv2D module.
Args:
- x: a 4-Tensor with shape [batch_dim, height, width, channels]
- a: a 4-Tensor with shape [batch_dim, height, width, channels]
that represents features from earlier hierarchies
- h: a 2-Tensor with shape [batch_dim, height, width, channels]
that conditions image generation
- conv2d: The type of convolution operation to use in this module,
must be Keras compatible.
- nonlinearity: The type of nonlinearity to use in this module,
must be Keras compatible.
- kernel_size: An integer or tuple/list of 2 integers, specifying
the height and width of the 2D convolution window. Can be a single
integer to specify the same value for all spatial dimensions.
- dropout_rate: Float between 0 and 1. Fraction of the input
units to drop.
Returns:
- out_x: a 4-Tensor with shape [batch_dim, height, width, channels]
"""
filters = int(x.shape[-1])
c = nonlinearity(x)
c = conv2d(c, filters, kernel_size, **kwargs)
if a is not None:
a = nonlinearity(a)
c = layers.add([
c,
layers.Conv2D(filters,
1,
padding='valid',
data_format='channels_last',
**kwargs)(a)
])
c = nonlinearity(c)
c = layers.SpatialDropout2D(dropout_rate, data_format='channels_last')(c)
c = conv2d(c, filters * 2, kernel_size, **kwargs)
if h is not None:
h = nonlinearity(h)
c = layers.add([
c,
layers.Conv2D(filters * 2,
1,
padding='valid',
data_format='channels_last',
**kwargs)(h)
])
def split_backend(z):
return tf.split(z, 2, axis=3)
c_a, c_b = layers.Lambda(split_backend)(c)
return layers.add(
[x, layers.multiply([c_a, layers.Activation(tf.math.sigmoid)(c_b)])])
def bottleneck(input_tensor,
in_filters,
out_filters,
stage,
block,
drop_rate=0.1,
dilation_rate=(1, 1),
projection_ratio=4):
"""ENet bottleneck block
:param input_tensor: input tensor
:param in_filters: integer, the input filters of conv layers at shortcut path
:param out_filters: integer, the out filters of conv layers at shortcut path
:param stage: integer, current stage label, used for generating layer names
:param block: integer, current block label, used for generating layer names
:param drop_rate: spatial dropout rate
:param dilation_rate: shortcut conv dilation rate
:param projection_ratio: integer, the projection ratio of conv layers at shortcut path
:return: bottleneck block tensor
"""
if backend.image_data_format() == 'channels_last':
channel_axis = -1
else:
channel_axis = 1
name_base = 'stage' + str(stage) + '_' + 'block' + str(block)
reduced_depth = in_filters // projection_ratio
shortcut = layers.Conv2D(
filters=reduced_depth,
kernel_size=(1, 1),
strides=(1, 1),
padding='valid',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY),
name=name_base + '_conv_reduce')(input_tensor)
shortcut = layers.BatchNormalization(axis=channel_axis,
name=name_base +
'_bn_reduce')(shortcut)
shortcut = layers.PReLU(alpha_initializer=PRELU_ALPHA)(shortcut)
shortcut = layers.Conv2D(
filters=reduced_depth,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
dilation_rate=dilation_rate,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY),
name=name_base + '_conv')(shortcut)
shortcut = layers.BatchNormalization(axis=channel_axis,
name=name_base + '_bn')(shortcut)
shortcut = layers.PReLU(alpha_initializer=PRELU_ALPHA)(shortcut)
shortcut = layers.Conv2D(
filters=out_filters,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY),
name=name_base + '_conv_expansion')(shortcut)
shortcut = layers.BatchNormalization(axis=channel_axis,
name=name_base +
'_bn_expansion')(shortcut)
shortcut = layers.SpatialDropout2D(rate=drop_rate)(shortcut)
x = layers.add([input_tensor, shortcut])
x = layers.PReLU(alpha_initializer=PRELU_ALPHA)(x)
return x
strides=(1, 1),
activation='elu',
padding='same')(x)
x = layers.Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
padding='same')(x)
x = layers.Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
padding='same')(x)
x = layers.BatchNormalization()(x)
x = layers.SpatialDropout2D(0.1)(x)
x = layers.MaxPooling2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
padding='same')(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
padding='same')(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
def advanced_CNN_model():
(x_train, y_train), (x_test,
y_test) = keras.datasets.fashion_mnist.load_data()
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1) / 255
y_train = y_train.reshape(y_train.shape[0], 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1) / 255
y_test = y_test.reshape(y_test.shape[0], 1)
# our model, input again, still in an image shape
inputs = keras.Input(shape=(
28,
28,
1,
), name='img')
# run pairs of conv layers, all 3s3 kernels
x = layers.Conv2D(filters=8,
kernel_size=(3, 3),
padding='same',
activation='relu')(inputs)
x = layers.Conv2D(filters=8,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
# batch normalisation, before the non-linearity
x = layers.BatchNormalization()(x)
# spatial dropout, this will drop whole kernels, i.e. 20% of our 3x3 filters will be dropped out rather
# than dropping out 20% of the invidual pixels
x = layers.SpatialDropout2D(0.2)(x)
# max pooling, 2x2, which will downsample the image
x = layers.MaxPool2D(pool_size=(2, 2))(x)
# rinse and repeat with 2D convs, batch norm, dropout and max pool
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = layers.BatchNormalization()(x)
x = layers.SpatialDropout2D(0.2)(x)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
# final conv2d, batch norm and spatial dropout
x = layers.Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = layers.Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = layers.BatchNormalization()(x)
x = layers.SpatialDropout2D(0.2)(x)
# flatten layer
x = layers.Flatten()(x)
# we'll use a couple of dense layers here, mainly so that we can show what another dropout layer looks like
# in the middle
x = layers.Dense(256, activation='relu')(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(64, activation='relu')(x)
# the output
outputs = layers.Dense(10, activation=None)(x)
# build the model, and print a summary
model_cnn = keras.Model(inputs=inputs,
outputs=outputs,
name='fashion_mnist_cnn_model')
model_cnn.summary()
# keras.utils.plot_model(model_cnn, show_shapes=True)
logdir = os.path.join("logs",
datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir,
histogram_freq=1)
# tb_sup = TensorboardSupervisor(logdir)
model_cnn.compile(
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=keras.optimizers.RMSprop(),
metrics=['accuracy'])
history = model_cnn.fit(x_train,
y_train,
batch_size=64,
epochs=5,
validation_split=0.2,
callbacks=[tensorboard_callback])
eval_model(model_cnn, x_test, y_test)
def UNet(input_shape=(None, None, 1),
conv_layers_dimensions=(16, 32, 64, 128),
base_conv_layers_dimensions=(128, 128),
output_conv_layers_dimensions=(16, 16),
dropout=(),
steps_per_pooling=1,
number_of_outputs=1,
output_kernel_size=3,
output_activation=None,
loss=nd_mean_absolute_error,
encoder_convolution_block="convolutional",
base_convolution_block="convolutional",
decoder_convolution_block="convolutional",
output_convolution_block="convolutional",
pooling_block="pooling",
upsampling_block="deconvolutional",
**kwargs):
"""Creates and compiles a U-Net.
Parameters
----------
input_shape : tuple of ints
Size of the images to be analyzed.
conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer during down-
and upsampling.
base_conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer at the base
of the unet, where the image is the most downsampled.
output_conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer after the
upsampling.
steps_per_pooling : int
Number of convolutional layers between each pooling and upsampling
step.
number_of_outputs : int
Number of convolutions in output layer.
output_activation : str or keras activation
The activation function of the output.
loss : str or keras loss function
The loss function of the network.
layer_function : Callable[int] -> keras layer
Function that returns a convolutional layer with convolutions
determined by the input argument. Can be use to futher customize the network.
Returns
-------
keras.models.Model
Deep learning network.
"""
# Update layer functions
encoder_convolution_block = as_block(encoder_convolution_block)
base_convolution_block = as_block(base_convolution_block)
output_convolution_block = as_block(output_convolution_block)
decoder_convolution_block = as_block(decoder_convolution_block)
pooling_block = as_block(pooling_block)
upsampling_block = as_block(upsampling_block)
unet_input = layers.Input(input_shape)
concat_layers = []
layer = unet_input
# Downsampling path
for conv_layer_dimension in conv_layers_dimensions:
for _ in range(steps_per_pooling):
layer = encoder_convolution_block(conv_layer_dimension)(layer)
concat_layers.append(layer)
if dropout:
layer = layers.SpatialDropout2D(dropout[0])(layer)
dropout = dropout[1:]
layer = pooling_block(conv_layer_dimension)(layer)
# Bottleneck path
for conv_layer_dimension in base_conv_layers_dimensions:
layer = base_convolution_block(conv_layer_dimension)(layer)
# Upsampling path
for conv_layer_dimension, concat_layer in zip(
reversed(conv_layers_dimensions), reversed(concat_layers)):
layer = upsampling_block(conv_layer_dimension)(layer)
layer = layers.Concatenate(axis=-1)([layer, concat_layer])
for _ in range(steps_per_pooling):
layer = decoder_convolution_block(conv_layer_dimension)(layer)
# Output step
for conv_layer_dimension in output_conv_layers_dimensions:
layer = output_convolution_block(conv_layer_dimension)(layer)
output_layer = layers.Conv2D(
number_of_outputs,
kernel_size=output_kernel_size,
activation=output_activation,
padding="same",
)(layer)
model = models.Model(unet_input, output_layer)
return KerasModel(model, loss=loss, **kwargs)
def create_cnn_model_2(learning_rate=0.00002,
nr_classes=1108,
input_shape=(6, 224, 224)):
"""
CNN model based on latest archidecture in prototype
"""
model = keras.Sequential([
keras.Input(shape=input_shape),
layers.Permute((3, 2, 1)),
layers.Conv2D(
64,
kernel_size=(1, 1),
activation="relu",
padding="same",
input_shape=(6, 224, 224),
data_format="channels_first",
),
layers.Conv2D(
64,
kernel_size=(4, 4),
activation="relu",
padding="same",
data_format="channels_first",
),
layers.MaxPooling2D(pool_size=(2, 2), data_format="channels_first"),
layers.Conv2D(
128,
kernel_size=(3, 3),
activation="relu",
padding="same",
data_format="channels_first",
),
layers.Conv2D(
128,
kernel_size=(3, 3),
activation="relu",
padding="same",
data_format="channels_first",
),
layers.AveragePooling2D(pool_size=(2, 2),
data_format="channels_first"),
layers.Conv2D(
256,
kernel_size=(3, 3),
activation="relu",
padding="same",
data_format="channels_first",
),
# layers.Conv2D(256, kernel_size=(3, 3), activation="relu", padding="same"),
layers.AveragePooling2D(pool_size=(3, 3),
data_format="channels_first"),
layers.SpatialDropout2D(0.5, data_format="channels_first"),
layers.Flatten(),
layers.Dense(
512,
activation="relu",
kernel_initializer="he_uniform",
kernel_regularizer="l2",
),
layers.Dropout(0.5),
layers.Dense(
256,
activation="relu",
kernel_initializer="he_uniform",
kernel_regularizer="l2",
),
layers.Dropout(0.5),
layers.Dense(128, activation="relu"),
layers.Dropout(0.5),
layers.Dense(nr_classes, activation="softmax"),
])
model.compile(
loss="sparse_categorical_crossentropy",
optimizer=Adam(learning_rate),
metrics=["accuracy"],
)
model.summary()
return model
