def average_dice_coef(y_true, y_pred):
y_pred = ThresholdedReLU(theta=0.5)(y_pred)
loss = 0
label_length = y_pred.get_shape().as_list()[-1]
for num_label in range(label_length):
y_true_f = K.flatten(y_true[..., num_label])
y_pred_f = K.flatten(y_pred[..., num_label])
intersection = K.sum(y_true_f * y_pred_f)
loss += (2. * intersection + smooth) / (K.sum(y_true_f) +
K.sum(y_pred_f) + smooth)
return loss / label_length # 1>= loss >0
def add_activation_layer(model, activation, activation_param):
"""Adds the specified activation layer to the given model.
Parameters
----------
model: tf.keras.model
Tensorflow.keras model to which to add an activation layer
activation: str
Activation to add to the model
activation_param: float
Parameter related to the activation (when needed)
"""
if activation == "relu":
model.add(ReLU())
elif activation == "leaky_relu":
model.add(LeakyReLU(alpha=activation_param))
elif activation == "prelu":
model.add(PReLU())
elif activation == "elu":
model.add(ELU(alpha=activation_param))
elif activation == "selu":
model.add(Activation("selu"))
elif activation == "thresholded_relu":
model.add(ThresholdedReLU(theta=activation_param))
elif activation == "softmax":
model.add(Softmax())
elif activation == "softplus":
model.add(Activation("softplus"))
# elif activation == "rrelu":
# model.add(tfa.activations.rrelu())
else:
print(f"Selected activation function ({activation}) is not available!")
def avg_dice_2(y_true, y_pred):
y_pred = ThresholdedReLU(theta=0.5)(y_pred)
loss = 0
num_label = 2
y_true_f = K.flatten(y_true[..., num_label])
y_pred_f = K.flatten(y_pred[..., num_label])
intersection = K.sum(y_true_f * y_pred_f)
loss += (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) +
smooth)
return loss # 1>= loss >0
def simple_block_2d(input,
number_of_filters,
downsample=False,
upsample=False,
convolution_kernel_size=(3, 3),
deconvolution_kernel_size=(2, 2),
weight_decay=0.0,
dropout_rate=0.0):
number_of_output_filters = number_of_filters
output = BatchNormalization()(input)
output = ThresholdedReLU(theta=0)(output)
if downsample:
output = MaxPooling2D(pool_size=(2, 2))(output)
output = Conv2D(
filters=number_of_filters,
kernel_size=convolution_kernel_size,
padding='same',
kernel_regularizer=regularizers.l2(weight_decay))(output)
if upsample:
output = Conv2DTranspose(
filters=number_of_filters,
kernel_size=deconvolution_kernel_size,
padding='same',
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
output = UpSampling2D(size=(2, 2))(output)
if dropout_rate > 0.0:
output = Dropout(rate=dropout_rate)(output)
# Modify the input so that it has the same size as the output
if downsample:
input = Conv2D(filters=number_of_output_filters,
kernel_size=(1, 1),
strides=(2, 2),
padding='same')(input)
elif upsample:
input = Conv2DTranspose(filters=number_of_output_filters,
kernel_size=(1, 1),
padding='same')(input)
input = UpSampling2D(size=(2, 2))(input)
elif number_of_filters != number_of_output_filters:
input = Conv2D(filters=number_of_output_filters,
kernel_size=(1, 1),
padding='same')(input)
output = skip_connection(input, output)
return (output)
def nyu_model(max_features, max_len, use_gap=True):
main_input = Input(shape=(75, ), dtype='int32 ', name='main_input')
embedding = Embedding(input_dim=128, output_dim=128,
input_length=75)(main_input)
conv1 = Conv1D(filters=128, kernel_size=3, padding='same',
strides=1)(embedding)
thresh1 = ThresholdedReLU(1e-6)(conv1)
max_pool1 = MaxPooling1D(pool_size=2, padding='same')(thresh1)
conv2 = Conv1D(filters=128, kernel_size=2, padding='same',
strides=1)(max_pool1)
thresh2 = ThresholdedReLU(1e-6)(conv2)
max_pool2 = MaxPooling1D(pool_size=2, padding='same')(thresh2)
flatten = Flatten()(max_pool2)
fc = Dense(64)(flatten)
thresh_fc = ThresholdedReLU(1e-6)(fc)
drop = Dropout(0.5)(thresh_fc)
output = Dense(1, activation='sigmoid')(drop)
model = Model(inputs=main_input, outputs=output)
model.compile(loss=' binary_crossentropy ',
optimizer='adam',
metrics=['accuracy'])
return model
def _build_model(self) -> None:
"""
Build and compile the Character Level CNN model
:return: None
"""
# Input layer
inputs = Input(shape=(self.input_sz,), name='sent_input', dtype='int16')
# Embedding layers
x = Embedding(self.alphabet_sz + 1, self.emb_sz, input_length=self.input_sz)(inputs)
x = Reshape((self.input_sz, self.emb_sz))(x)
# Convolutional layers
for cl in self.conv_layers:
x = Conv1D(cl[0], cl[1], kernel_initializer="lecun_normal", padding="causal", use_bias=False)(x)
x = BatchNormalization(scale=False)(x)
x = Activation('selu')(x)
x = AlphaDropout(0.5)(x)
if cl[2] != -1:
x = MaxPooling1D(cl[2], cl[3])(x)
if cl[4] != -1:
x = self._squeeze_and_excitation_block(input_data = x, ratio = cl[4])
# Flatten the features
x = Flatten()(x)
# Fully connected layers
for fl in self.fc_layers:
x = Dense(fl)(x)
x = ThresholdedReLU(self.threshold)(x)
x = Dropout(self.dropout_p)(x)
# Output layer
predictions = Dense(self.num_of_classes, activation="softmax")(x)
# Build and coompile the model
model = Model(inputs, predictions)
# Compile
model.compile(optimizer='nadam', loss=self.loss, metrics=['accuracy'])
self.model = model
self.model.summary()
def block(x):
if norm == "batch":
x = BatchNormalization(momentum=0.8, scale=False)(x)
if activation == 'leakyrelu':
x = LeakyReLU(0.2)(x)
elif activation == 'relu':
x = ReLU()(x)
elif activation == 'thresholdedrelu':
x = ThresholdedReLU()(x)
elif activation == 'elu':
x = ELU()(x)
if padding == 'reflect':
pad = tuple((s - 1) // 2 for s in conv_size)
x = TD(ReflectionPadding2D(padding=pad))(x)
x = TD(
Conv(channels,
conv_size,
padding='valid' if padding == 'reflect' else padding,
strides=(stride, stride),
kernel_regularizer=(l2(1e-4)
if norm != "spectral" else None)))(x)
return x
def load_model(input_shape,
num_labels,
axis=-1,
base_filter=32,
depth_size=4,
se_res_block=True,
se_ratio=16,
noise=0.1,
last_relu=False,
atten_gate=False):
def conv3d(layer_input,
filters,
axis=-1,
se_res_block=True,
se_ratio=16,
down_sizing=True):
if down_sizing == True:
layer_input = MaxPooling3D(pool_size=(2, 2, 2))(layer_input)
d = Conv3D(filters, (3, 3, 3), use_bias=False,
padding='same')(layer_input)
d = InstanceNormalization(axis=axis)(d)
d = LeakyReLU(alpha=0.3)(d)
d = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(d)
d = InstanceNormalization(axis=axis)(d)
if se_res_block == True:
se = GlobalAveragePooling3D()(d)
se = Dense(filters // se_ratio, activation='relu')(se)
se = Dense(filters, activation='sigmoid')(se)
se = Reshape([1, 1, 1, filters])(se)
d = Multiply()([d, se])
shortcut = Conv3D(filters, (3, 3, 3),
use_bias=False,
padding='same')(layer_input)
shortcut = InstanceNormalization(axis=axis)(shortcut)
d = add([d, shortcut])
d = LeakyReLU(alpha=0.3)(d)
return d
def deconv3d(layer_input,
skip_input,
filters,
axis=-1,
se_res_block=True,
se_ratio=16,
atten_gate=False):
if atten_gate == True:
gating = Conv3D(filters, (1, 1, 1), use_bias=False,
padding='same')(layer_input)
gating = InstanceNormalization(axis=axis)(gating)
attention = Conv3D(filters, (2, 2, 2),
strides=(2, 2, 2),
use_bias=False,
padding='valid')(skip_input)
attention = InstanceNormalization(axis=axis)(attention)
attention = add([gating, attention])
attention = Conv3D(1, (1, 1, 1),
use_bias=False,
padding='same',
activation='sigmoid')(attention)
# attention = Lambda(resize_by_axis, arguments={'dim_1':skip_input.get_shape().as_list()[1],'dim_2':skip_input.get_shape().as_list()[2],'ax':3})(attention) # error when None dimension is feeded.
# attention = Lambda(resize_by_axis, arguments={'dim_1':skip_input.get_shape().as_list()[1],'dim_2':skip_input.get_shape().as_list()[3],'ax':2})(attention)
attention = ZeroPadding3D(((0, 1), (0, 1), (0, 1)))(attention)
attention = UpSampling3D((2, 2, 2))(attention)
attention = CropToConcat3D(mode='crop')([attention, skip_input])
attention = Lambda(lambda x: K.tile(x, [1, 1, 1, 1, filters]))(
attention)
skip_input = multiply([skip_input, attention])
u1 = ZeroPadding3D(((0, 1), (0, 1), (0, 1)))(layer_input)
u1 = Conv3DTranspose(filters, (2, 2, 2),
strides=(2, 2, 2),
use_bias=False,
padding='same')(u1)
u1 = InstanceNormalization(axis=axis)(u1)
u1 = LeakyReLU(alpha=0.3)(u1)
u1 = CropToConcat3D()([u1, skip_input])
u2 = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(u1)
u2 = InstanceNormalization(axis=axis)(u2)
u2 = LeakyReLU(alpha=0.3)(u2)
u2 = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(u2)
u2 = InstanceNormalization(axis=axis)(u2)
if se_res_block == True:
se = GlobalAveragePooling3D()(u2)
se = Dense(filters // se_ratio, activation='relu')(se)
se = Dense(filters, activation='sigmoid')(se)
se = Reshape([1, 1, 1, filters])(se)
u2 = Multiply()([u2, se])
shortcut = Conv3D(filters, (3, 3, 3),
use_bias=False,
padding='same')(u1)
shortcut = InstanceNormalization(axis=axis)(shortcut)
u2 = add([u2, shortcut])
u2 = LeakyReLU(alpha=0.3)(u2)
return u2
def CropToConcat3D(mode='concat'):
def crop_to_concat_3D(concat_layers, axis=-1):
bigger_input, smaller_input = concat_layers
bigger_shape, smaller_shape = tf.shape(bigger_input), \
tf.shape(smaller_input)
sh, sw, sd = smaller_shape[1], smaller_shape[2], smaller_shape[3]
bh, bw, bd = bigger_shape[1], bigger_shape[2], bigger_shape[3]
dh, dw, dd = bh - sh, bw - sw, bd - sd
cropped_to_smaller_input = bigger_input[:, :-dh, :-dw, :-dd, :]
if mode == 'concat':
return K.concatenate([smaller_input, cropped_to_smaller_input],
axis=axis)
elif mode == 'add':
return smaller_input + cropped_to_smaller_input
elif mode == 'crop':
return cropped_to_smaller_input
return Lambda(crop_to_concat_3D)
def resize_by_axis(image, dim_1, dim_2,
ax): # it is available only for 1 channel 3D
resized_list = []
unstack_img_depth_list = tf.unstack(image, axis=ax)
for i in unstack_img_depth_list:
resized_list.append(tf.image.resize_images(
i, [dim_1, dim_2])) # defaults to ResizeMethod.BILINEAR
stack_img = tf.stack(resized_list, axis=ax + 1)
return stack_img
input_img = Input(shape=input_shape, name='Input')
d0 = GaussianNoise(noise)(input_img)
d1 = Conv3D(base_filter, (3, 3, 3), use_bias=False, padding='same')(d0)
d1 = InstanceNormalization(axis=axis)(d1)
d1 = LeakyReLU(alpha=0.3)(d1)
d2 = conv3d(d1, base_filter * 2, se_res_block=se_res_block)
d3 = conv3d(d2, base_filter * 4, se_res_block=se_res_block)
d4 = conv3d(d3, base_filter * 8, se_res_block=se_res_block)
if depth_size == 4:
d5 = conv3d(d4, base_filter * 16, se_res_block=se_res_block)
u4 = deconv3d(d5,
d4,
base_filter * 8,
se_res_block=se_res_block,
atten_gate=atten_gate)
u3 = deconv3d(u4,
d3,
base_filter * 4,
se_res_block=se_res_block,
atten_gate=atten_gate)
elif depth_size == 3:
u3 = deconv3d(d4,
d3,
base_filter * 4,
se_res_block=se_res_block,
atten_gate=atten_gate)
else:
raise Exception('depth size must be 3 or 4. you put ', depth_size)
u2 = deconv3d(u3,
d2,
base_filter * 2,
se_res_block=se_res_block,
atten_gate=atten_gate)
u1 = ZeroPadding3D(((0, 1), (0, 1), (0, 1)))(u2)
u1 = Conv3DTranspose(base_filter, (2, 2, 2),
strides=(2, 2, 2),
use_bias=False,
padding='same')(u1)
u1 = InstanceNormalization(axis=axis)(u1)
u1 = LeakyReLU(alpha=0.3)(u1)
u1 = CropToConcat3D()([u1, d1])
# output_img = Conv3D(num_labels, (3, 3, 3), use_bias=True, padding='same', activation='sigmoid', name='lastconv')(u1)
u1 = Conv3D(base_filter, (3, 3, 3), use_bias=False, padding='same')(u1)
u1 = InstanceNormalization(axis=axis)(u1)
u1 = LeakyReLU(alpha=0.3)(u1)
output_img = Conv3D(num_labels,
kernel_size=1,
strides=1,
padding='same',
activation='sigmoid',
name='lastconv')(u1)
if last_relu == True:
output_img = ThresholdedReLU(theta=0.5)(output_img)
model = Model(inputs=input_img, outputs=output_img)
return model
(Subtract(), [Input((6, 6, 5)), Input((6, 6, 5))], 32),
(Multiply(), [Input((6, 6, 5)), Input((6, 6, 5))], 32),
(Average(), [Input(
(6, 6, 5)), Input(
(6, 6, 5)), Input((6, 6, 5))], 32),
(Maximum(), [Input((6, 6, 5)), Input((6, 6, 5))], 32),
(Minimum(), [Input((6, 6, 5)), Input((6, 6, 5))], 32),
(Activation('relu'), Input((6, 6, 5)), 32),
(Reshape((36, 5)), Input((6, 6, 5)), 32),
(Reshape((20, 6, 5)), Input((6, 5, 4, 5)), 32),
(GatherLayer([1, 4, 2], axis=1), Input((6, 5)), 32),
(GatherLayer([1, 4, 2], axis=2), Input((6, 5)), 32),
(GatherLayer([1, 4, 2], axis=2), Input((6, 7, 5)), 32),
(LeakyReLU(), Input((6, 6, 5)), 32),
(ELU(), Input((6, 6, 5)), 32),
(ThresholdedReLU(), Input((6, 6, 5)), 32),
(Softmax(), Input((6, 6, 5)), 32),
(DownShiftLayer(), Input((6, 6, 5)), 32),
(DownShiftLayer(), Input((6, 5)), 32),
(RightShiftLayer(), Input((6, 6, 5)), 32),
(VectorToComplexNumber(), Input((6, 6, 2)), 32),
(LambdaWithOneToOneTopology(lambda x: tf.exp(x)), Input((6, 6, 2)), 32),
(ToComplex64(), Input((6, 6, 2)), 32),
(Conv2D(
8, kernel_size=3, data_format='channels_last',
bias_initializer='ones'), Input((6, 6, 5)), 1),
(Conv2D(
8, kernel_size=3, data_format='channels_last',
bias_initializer='ones'), Input((6, 6, 1)), 32),
(Conv2D(
8, kernel_size=3, data_format='channels_last',
def create_resunet_model_3d(input_image_size,
number_of_outputs=1,
number_of_filters_at_base_layer=32,
bottle_neck_block_depth_schedule=(3, 4),
convolution_kernel_size=(3, 3, 3),
deconvolution_kernel_size=(2, 2, 2),
dropout_rate=0.0,
weight_decay=0.0,
mode='classification'):
"""
3-D implementation of the Resnet + U-net deep learning architecture.
Creates a keras model of the U-net + ResNet deep learning architecture for
image segmentation and regression with the paper available here:
https://arxiv.org/abs/1608.04117
This particular implementation was ported from the following python
implementation:
https://github.com/veugene/fcn_maker/
Arguments
---------
input_image_size : tuple of length 4
Used for specifying the input tensor shape. The
shape (or dimension) of that tensor is the image dimensions followed by
the number of channels (e.g., red, green, and blue). The batch size
(i.e., number of training images) is not specified a priori.
number_of_outputs : integer
Meaning depends on the mode. For 'classification' this is the number of
segmentation labels. For 'regression' this is the number of outputs.
number_of_filters_at_base_layer : integer
Number of filters at the beginning and end of the 'U'. Doubles at each
descending/ascending layer.
bottle_neck_block_depth_schedule : tuple
Tuple that provides the encoding layer schedule for the number of bottleneck
blocks per long skip connection.
convolution_kernel_size : tuple of length 3
3-d vector defining the kernel size during the encoding path
deconvolution_kernel_size : tuple of length 3
3-d vector defining the kernel size during the decoding
dropout_rate : scalar
Float between 0 and 1 to use between dense layers.
weight_decay : scalar
Weighting parameter for L2 regularization of the kernel weights of the
convolution layers. Default = 0.0.
mode : string
'classification' or 'regression'. Default = 'classification'.
Returns
-------
Keras model
A 3-D Keras model defining the network.
Example
-------
>>> model = create_resunet_model_3d((128, 128, 128, 1))
>>> model.summary()
"""
def simple_block_3d(input,
number_of_filters,
downsample=False,
upsample=False,
convolution_kernel_size=(3, 3, 3),
deconvolution_kernel_size=(2, 2, 2),
weight_decay=0.0,
dropout_rate=0.0):
number_of_output_filters = number_of_filters
output = BatchNormalization()(input)
output = ThresholdedReLU(theta=0)(output)
if downsample:
output = MaxPooling3D(pool_size=(2, 2, 2))(output)
output = Conv3D(
filters=number_of_filters,
kernel_size=convolution_kernel_size,
padding='same',
kernel_regularizer=regularizers.l2(weight_decay))(output)
if upsample:
output = Conv3DTranspose(
filters=number_of_filters,
kernel_size=deconvolution_kernel_size,
padding='same',
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
output = UpSampling3D(size=(2, 2, 2))(output)
if dropout_rate > 0.0:
output = Dropout(rate=dropout_rate)(output)
# Modify the input so that it has the same size as the output
if downsample:
input = Conv3D(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
strides=(2, 2, 2),
padding='same')(input)
elif upsample:
input = Conv3DTranspose(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
padding='same')(input)
input = UpSampling3D(size=(2, 2, 2))(input)
elif number_of_filters != number_of_output_filters:
input = Conv3D(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
padding='same')(input)
output = skip_connection(input, output)
return (output)
def bottle_neck_block_3d(input,
number_of_filters,
downsample=False,
upsample=False,
deconvolution_kernel_size=(2, 2, 2),
weight_decay=0.0,
dropout_rate=0.0):
output = input
number_of_output_filters = number_of_filters
if downsample:
output = BatchNormalization()(output)
output = ThresholdedReLU(theta=0)(output)
output = Conv3D(
filters=number_of_filters,
kernel_size=(1, 1, 1),
strides=(2, 2, 2),
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
output = BatchNormalization()(output)
output = ThresholdedReLU(theta=0)(output)
output = Conv3D(
filters=number_of_filters,
kernel_size=(1, 1, 1),
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
output = BatchNormalization()(output)
output = ThresholdedReLU(theta=0)(output)
if upsample:
output = Conv3DTranspose(
filters=number_of_filters,
kernel_size=deconvolution_kernel_size,
padding='same',
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
output = UpSampling3D(size=(2, 2, 2))(output)
output = Conv3D(
filters=(number_of_filters * 4),
kernel_size=(1, 1, 1),
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(output)
number_of_output_filters = number_of_filters * 4
if dropout_rate > 0.0:
output = Dropout(rate=dropout_rate)(output)
# Modify the input so that it has the same size as the output
if downsample:
input = Conv3D(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
strides=(2, 2, 2),
padding='same')(input)
elif upsample:
input = Conv3DTranspose(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
padding='same')(input)
input = UpSampling3D(size=(2, 2, 2))(input)
elif number_of_filters != number_of_output_filters:
input = Conv3D(filters=number_of_output_filters,
kernel_size=(1, 1, 1),
padding='valid')(input)
output = skip_connection(input, output)
return (output)
def skip_connection(source, target, merge_mode='sum'):
layer_list = [source, target]
output = None
if merge_mode == 'sum':
output = Add()(layer_list)
else:
channel_axis = 0
if K.image_data_format() == 'channels_last':
channel_axis = -1
output = Concatenate(axis=channel_axis)(layer_list)
return (output)
inputs = Input(shape=input_image_size)
encoding_layers_with_long_skip_connections = []
encoding_layer_count = 1
# Preprocessing layer
model = Conv3D(filters=number_of_filters_at_base_layer,
kernel_size=convolution_kernel_size,
activation='relu',
padding='same',
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(inputs)
encoding_layers_with_long_skip_connections.append(model)
encoding_layer_count += 1
# Encoding initialization path
model = simple_block_3d(
model,
number_of_filters_at_base_layer,
downsample=True,
convolution_kernel_size=convolution_kernel_size,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
encoding_layers_with_long_skip_connections.append(model)
encoding_layer_count += 1
# Encoding main path
number_of_bottle_neck_layers = len(bottle_neck_block_depth_schedule)
for i in range(number_of_bottle_neck_layers):
number_of_filters = number_of_filters_at_base_layer * 2**i
for j in range(bottle_neck_block_depth_schedule[i]):
do_downsample = False
if j == 0:
do_downsample = True
else:
do_downsample = False
model = bottle_neck_block_3d(
model,
number_of_filters=number_of_filters,
downsample=do_downsample,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
if j == (bottle_neck_block_depth_schedule[i] - 1):
encoding_layers_with_long_skip_connections.append(model)
encoding_layer_count += 1
encoding_layer_count -= 1
# Transition path
number_of_filters = number_of_filters_at_base_layer * 2**number_of_bottle_neck_layers
model = bottle_neck_block_3d(
model,
number_of_filters=number_of_filters,
downsample=True,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
model = bottle_neck_block_3d(
model,
number_of_filters=number_of_filters,
upsample=True,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
# Decoding main path
number_of_bottle_neck_layers = len(bottle_neck_block_depth_schedule)
for i in range(number_of_bottle_neck_layers):
number_of_filters = (number_of_filters_at_base_layer *
2**(number_of_bottle_neck_layers - i - 1))
for j in range(
bottle_neck_block_depth_schedule[number_of_bottle_neck_layers -
i - 1]):
do_upsample = False
if j == bottle_neck_block_depth_schedule[
number_of_bottle_neck_layers - i - 1] - 1:
do_upsample = True
else:
do_upsample = False
model = bottle_neck_block_3d(
model,
number_of_filters=number_of_filters,
upsample=do_upsample,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
if j == 0:
model = Conv3D(filters=(number_of_filters * 4),
kernel_size=(1, 1, 1),
padding='same')(model)
model = skip_connection(
encoding_layers_with_long_skip_connections[
encoding_layer_count - 1], model)
encoding_layer_count -= 1
# Decoding initialization path
model = simple_block_3d(
model,
number_of_filters_at_base_layer,
upsample=True,
convolution_kernel_size=convolution_kernel_size,
deconvolution_kernel_size=deconvolution_kernel_size,
weight_decay=weight_decay,
dropout_rate=dropout_rate)
# Postprocessing layer
model = Conv3D(filters=number_of_filters_at_base_layer,
kernel_size=convolution_kernel_size,
activation='relu',
padding='same',
kernel_initializer=initializers.he_normal(),
kernel_regularizer=regularizers.l2(weight_decay))(model)
encoding_layer_count -= 1
model = skip_connection(
encoding_layers_with_long_skip_connections[encoding_layer_count - 1],
model)
model = BatchNormalization()(model)
model = ThresholdedReLU(theta=0)(model)
convActivation = ''
if mode == 'classification':
convActivation = 'softmax'
elif mode == 'regression':
convActivation = 'linear'
else:
raise ValueError(
'mode must be either `classification` or `regression`.')
outputs = Conv3D(filters=number_of_outputs,
kernel_size=(1, 1, 1),
activation=convActivation,
kernel_regularizer=regularizers.l2(weight_decay))(model)
resunet_model = Model(inputs=inputs, outputs=outputs)
return resunet_model
def build_character_cnn(model_hyperparameters=None, verbose=None):
"""
Create a language model based on the Crepe model in Zhang et. al.
Creates a model that uses only Convolutional Layers (max pooling in between),
and dense layers for prediction tasks. For this model, the final output layer
will predict the next character in the sequence.
Parameters
----------
model_hyperparameters : dict
A dictionary containing values necessary to build the model.
verbose : bool
A flag to print additional information.
Returns
-------
model : Sequential
A Keras Sequential that represents the model.
Notes
-----
See https://gab41.lab41.org/deep-learning-sentiment-one-character-at-a-t-i-m-e-6cd96e4f780d for more information.
See https://github.com/mhjabreel/CharCnn_Keras for the Keras code this is based on
See https://github.com/zhangxiangxiao/Crepe for the original (Torch) Crepe code
"""
if model_hyperparameters is None:
model_hyperparameters = _dutils.load_dictionary(
'model_hyperparameters.json')
'''
Load hyperparameter-specific values from JSON file.
'''
#The size of the characater vocabulary
vocabulary_size = model_hyperparameters.get("vocabulary_size")
#The max length of the text. Set as 1014 in the original.
text_length = model_hyperparameters.get("text_length")
#Number of filters for each convolutional layer
num_filters = model_hyperparameters.get("num_filters")
#The threshold for the ReLU activation layers
threshold = model_hyperparameters.get("relu_threshold")
#Dropout probability for Dropout layers
dropout_p = model_hyperparameters.get("dropout_percent")
#Embedding output dimension. Implementation sets it equal to vocabulary_size
embed_dim = model_hyperparameters.get("embedding_dimension")
'''
Values below specify the architecture.
These aren't stored in the JSON file due to
architectutre constraints with layers and
kernel sizes.
'''
#The number of units for each dense layer minus output layer
fully_connected_layers = [128, 64]
'''
conv_layers is a list of pairs.
First component refers to kernel size.
Second component refers to the size of
the MaxPooling1D layer (-1 indicates said layer is not present).
'''
conv_layers = [[7, 3], [3, -1], [3, -1], [3, -1], [3, 3]]
#Input layer
inputs = Input(shape=(text_length, ), name='sent_input', dtype='int32')
#Embedding layers
x = Embedding(vocabulary_size + 1,
embed_dim,
input_length=text_length,
mask_zero=True)(inputs)
#Convolution layers
'''
First Conv1D layer + MaxPooling is separate in case
changes are made upstream. Also it was used to test out
TimeDistributed functionality.
'''
x = (Convolution1D(num_filters, 7))(x)
x = (MaxPooling1D(3))(x)
for cl in conv_layers:
x = (Convolution1D(num_filters, cl[0]))(x)
x = ThresholdedReLU(threshold)(x)
if cl[1] != -1:
x = (MaxPooling1D(cl[1]))(x)
x = Flatten()(x)
# #Fully connected layers
for fl in fully_connected_layers:
'''
Original architecture did not use L2 regularization.
However, empirical results show that, for my dataset
it works well in handling overfitting.
'''
x = Dense(fl, kernel_regularizer=regularizers.l2(0.0001))(x)
x = ThresholdedReLU(threshold)(x)
'''
Original architecture had dropout at 50%.
This seemed to be too high for my dataset, and
it resulted in underfitting.
'''
x = Dropout(dropout_p)(x)
# #Output layer
predictions = Dense(vocabulary_size, activation='softmax')(x)
# Build and compile model
model = Model(inputs=inputs, outputs=predictions)
if verbose:
model.summary()
return model
def test_delete_channels_advanced_activations(channel_index, data_format):
layer_test_helper_flatten_2d(LeakyReLU(), channel_index, data_format)
layer_test_helper_flatten_2d(ELU(), channel_index, data_format)
layer_test_helper_flatten_2d(ThresholdedReLU(), channel_index, data_format)
#input does not has fixed shape. Changed to fixed shape only for layer illustration purpose.
#inp=Input(shape=(256,256,1,))
inpp = Input(shape=(
None,
None,
1,
))
#negInp=Input(shape=(256,256,1,))
#preprocessing layers -
#maintaining scan points by creating mask. Masking output prediction for scanned point and re-insert back the values
#clip the max value to 1
#Using threshold Relu for low lying points.
mask = Lambda(lambda x: 1 - x)(inpp)
mask1 = ThresholdedReLU(theta=11 / 256)(mask)
mask1 = Lambda(lambda x: x * 25)(mask1)
mask1 = Lambda(lambda x: backend.clip(x, 0, 1))(mask1)
mask = Lambda(lambda x: 1 - x)(mask1)
inp0 = Multiply()([mask, inpp])
inp1 = Multiply()([mask1, inpp])
inp = inpp
#Stage 1-5 : Area identifier
#Stage 1
# Stage 1 MAx Pooling2D layer
rul = MaxPooling2D(pool_size=(64, 64), strides=(64, 64),
name="max_layer1")(inp)
xa0 = rul
#preprocessing layers -
#maintaining scan points by creating mask. Masking output prediction for scanned point and re-insert back the values
def call(self, inputs):
input_sign = K.sign(inputs)
hard_thresh_unsigned = ThresholdedReLU(self.threshold)(input_sign *
inputs)
hard_thresh = hard_thresh_unsigned * input_sign
return hard_thresh
