def get_red30_model():
"""
Define the model architecture
Return the model
"""
inputs = Input(shape=(256, 256, 2))
enc_conv0 = Conv2D(32, (3, 3),
padding="same",
activation='relu',
kernel_initializer="he_normal")(inputs)
enc_conv1 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(enc_conv0)
max_pool1 = MaxPooling2D((2, 2))(enc_conv1)
enc_conv2 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(max_pool1)
max_pool2 = MaxPooling2D((2, 2))(enc_conv2)
enc_conv3 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(max_pool2)
max_pool3 = MaxPooling2D((2, 2))(enc_conv3)
enc_conv4 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(max_pool3)
max_pool4 = MaxPooling2D((2, 2))(enc_conv4)
enc_conv5 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(max_pool4)
max_pool5 = MaxPooling2D((2, 2))(enc_conv5)
enc_conv6 = Conv2D(32, (3, 3), padding="SAME",
activation='relu')(max_pool5)
up_samp5 = UpSampling2D((2, 2))(enc_conv6)
concat_5 = concatenate([up_samp5, max_pool4])
dec_conv5a = Conv2D(64, (3, 3), padding="SAME",
activation='relu')(concat_5)
dec_conv5b = Conv2D(64, (3, 3), padding='SAME',
activation='relu')(dec_conv5a)
up_samp4 = UpSampling2D((2, 2))(dec_conv5b)
concat_4 = concatenate([up_samp4, max_pool3])
dec_conv4a = Conv2D(64, (3, 3), padding="SAME",
activation='relu')(concat_4)
dec_conv4b = Conv2D(64, (3, 3), padding='SAME',
activation='relu')(dec_conv4a)
up_samp3 = UpSampling2D((2, 2))(dec_conv4b)
concat_3 = concatenate([up_samp3, max_pool2])
dec_conv3a = Conv2D(64, (3, 3), padding="SAME",
activation='relu')(concat_3)
dec_conv3b = Conv2D(64, (3, 3), padding='SAME',
activation='relu')(dec_conv3a)
up_samp2 = UpSampling2D((2, 2))(dec_conv3b)
concat_2 = concatenate([up_samp2, max_pool1])
dec_conv2a = Conv2D(64, (3, 3), padding="SAME",
activation='relu')(concat_2)
dec_conv2b = Conv2D(64, (3, 3), padding='SAME',
activation='relu')(dec_conv2a)
up_samp1 = UpSampling2D((2, 2))(dec_conv2b)
concat_1 = concatenate([up_samp1, inputs])
dec_conv1a = Conv2D(64, (3, 3), padding="SAME",
activation='relu')(concat_1)
dec_conv1b = Conv2D(32, (3, 3), padding='SAME',
activation='relu')(dec_conv1a)
dec_conv1c = Conv2D(2, (3, 3), padding='SAME',
activation='linear')(dec_conv1b)
model = Model(inputs=inputs, outputs=dec_conv1c)
return model
# Supress warnings about wrong compilation of TensorFlow. tf.logging.set_verbosity(tf.logging.ERROR) latent_size = 100 ## G z = Input(shape=[latent_size], name='noise') # 1 x 1 x 256 G = Dense(7 * 7 * 256)(z) G = BatchNormalization(momentum=0.9)(G) G = LeakyReLU(alpha=0.2)(G) G = Reshape((7, 7, 256))(G) # 7 x 7 x 256 G = UpSampling2D()(G) G = Conv2D(128, (5, 5), padding='same')(G) G = BatchNormalization(momentum=0.9)(G) G = LeakyReLU(alpha=0.2)(G) # 14 x 14 x 128 G = UpSampling2D()(G) G = Conv2D(64, (5, 5), padding='same')(G) G = BatchNormalization(momentum=0.9)(G) G = LeakyReLU(alpha=0.2)(G) # 28 x 28 x 64 G = Conv2D(32, (5, 5), padding='same')(G) G = BatchNormalization(momentum=0.9)(G) G = LeakyReLU(alpha=0.2)(G) # 28 x 28 x 32 G = Conv2D(1, (5, 5), padding='same', activation='tanh')(G) # 28 x 28 x 1
plt.savefig('saves/cdA_gblur_noisy_vis.png')
################# Constructing the Model ######################
input_img = Input(
shape=(32, 32,
3)) # adapt this if using `channels_first` image data format
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
# at this point the representation is (7, 7, 32)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
########################## Training the model ##########################
from keras.callbacks import TensorBoard
import sys
#sys.stdout = open('cdA_gblur_output.txt', 'w')
autoencoder.fit(x_train_noisy,
x_train,
epochs=100,
def create_yolov3_model(nb_class, anchors, max_box_per_image, max_grid,
batch_size, warmup_batches, ignore_thresh, grid_scales,
obj_scale, noobj_scale, xywh_scale, class_scale):
input_image = Input(shape=(None, None, 3)) # net_h, net_w, 3
true_boxes = Input(shape=(1, 1, 1, max_box_per_image, 4))
true_yolo_1 = Input(
shape=(None, None, len(anchors) // 4,
4 + 1 + nb_class)) # grid_h, grid_w, nb_anchor, 5+nb_class
true_yolo_2 = Input(
shape=(None, None, len(anchors) // 4,
4 + 1 + nb_class)) # grid_h, grid_w, nb_anchor, 5+nb_class
# Layer 0 => 4
x = _conv_block(input_image, [{
'filter': 16,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 0
}],
do_skip=False)
x = MaxPooling2D(pool_size=(2, 2),
strides=2,
padding='same',
data_format=None)(x)
# Layer 5 => 8
x = _conv_block(x, [{
'filter': 32,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 2
}],
do_skip=False)
x = MaxPooling2D(pool_size=(2, 2),
strides=2,
padding='same',
data_format=None)(x)
# Layer 9 => 11
x = _conv_block(x, [{
'filter': 64,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 4
}],
do_skip=False)
x = MaxPooling2D(pool_size=(2, 2),
strides=2,
padding='same',
data_format=None)(x)
#Layer 12 => 15
x = _conv_block(x, [{
'filter': 128,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 6
}],
do_skip=False)
x = MaxPooling2D(pool_size=(2, 2),
strides=2,
padding='same',
data_format=None)(x)
x = _conv_block(x, [{
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 8
}],
do_skip=False)
skip_8 = x
x = MaxPooling2D(pool_size=(2, 2),
strides=2,
padding='same',
data_format=None)(x)
x = _conv_block(x, [{
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 10
}],
do_skip=False)
x = MaxPooling2D(pool_size=(2, 2),
strides=1,
padding='same',
data_format=None)(x)
x = _conv_block(x, [{
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 12
}],
do_skip=False)
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 13
}],
do_skip=False)
pred_yolo_1 = _conv_block(x, [{'filter': 512, 'kernel': 3, 'stride': 1, 'bnorm': True, 'leaky': True, 'layer_idx': 14}, \
{'filter': (3*(5+nb_class)), 'kernel': 1, 'stride': 1, 'bnorm': False, 'leaky': False, 'layer_idx': 15}], do_skip=False)
loss_yolo_1 = YoloLayer(
anchors[6:12], [1 * num
for num in max_grid], batch_size, warmup_batches,
ignore_thresh, grid_scales[0], obj_scale, noobj_scale, xywh_scale,
class_scale)([input_image, pred_yolo_1, true_yolo_1, true_boxes])
# Layer 83 => 86
x = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 18
}],
do_skip=False)
x = UpSampling2D(2)(x)
x = concatenate([x, skip_8])
# Layer 87 => 91
pred_yolo_2 = _conv_block(x, [{'filter': 256, 'kernel': 3, 'stride': 1, 'bnorm': True, 'leaky': True, 'layer_idx': 21},\
{'filter': (3*(5+nb_class)), 'kernel': 1, 'stride': 1, 'bnorm': False, 'leaky': False, 'layer_idx': 22}], do_skip=False)
# Layer 92 => 94
loss_yolo_2 = YoloLayer(
anchors[:6], [2 * num for num in max_grid], batch_size, warmup_batches,
ignore_thresh, grid_scales[1], obj_scale, noobj_scale, xywh_scale,
class_scale)([input_image, pred_yolo_2, true_yolo_2, true_boxes])
# Layer 95 => 98
train_model = Model([input_image, true_boxes, true_yolo_1, true_yolo_2],
[loss_yolo_1, loss_yolo_2])
infer_model = Model(input_image, [pred_yolo_1, pred_yolo_2])
return [train_model, infer_model]
def build_model():
input_tensor = Input((None, None, 1))
x = Conv2D(24, 5, strides=2, padding='same')(input_tensor)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, 3, strides=2, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, 3, strides=2, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, 3, strides=2, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(
256,
3,
strides=1,
padding='same',
)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D(2)(x)
x = Conv2D(128, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D(2)(x)
x = Conv2D(32, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(16, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D(2)(x)
x = Conv2D(8, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(4, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D(2)(x)
x = Conv2D(2, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(1, 3, strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
output_tensor = Conv2D(1, 3, padding='same', activation='sigmoid')(x)
return Model(input_tensor, output_tensor)
def build_retinanet(img_shape=(3, 416, 416),
n_classes=80,
n_priors=5,
load_pretrained=False,
freeze_layers_from='base_model'):
# RetinaNet model is only implemented for TF backend
assert (K.backend() == 'tensorflow')
inputs = Input(shape=img_shape)
K.set_image_dim_ordering('th')
backbone_net = keras_resnet.models.ResNet50(inputs,
include_top=False,
freeze_bn=True)
_, C3, C4, C5 = backbone_net.outputs # we ignore C2
K.set_image_dim_ordering('tf')
C3 = keras.layers.Permute((3, 2, 1))(C3)
C4 = keras.layers.Permute((3, 2, 1))(C4)
C5 = keras.layers.Permute((3, 2, 1))(C5)
# compute pyramid features as per https://arxiv.org/abs/1708.02002
features = create_pyramid_features(C3, C4, C5)
# create regression and classification submodels
bbox_subnet_model = regression_submodel(n_priors)
class_subnet_model = classification_submodel(n_classes, n_priors)
#Concatenation of pyramid levels
# class_subnet
class_subnet = [class_subnet_model(f) for f in features]
class_subnet0 = Conv2D(filters=n_priors * n_classes,
kernel_size=(1, 1),
strides=(4, 4))(class_subnet[0])
class_subnet1 = Conv2D(filters=n_priors * n_classes,
kernel_size=(1, 1),
strides=(2, 2))(class_subnet[1])
class_subnet2 = class_subnet[2]
class_subnet3 = UpSampling2D(size=(2, 2),
name='class_upsample')(class_subnet[3])
class_subnet = [class_subnet0, class_subnet1, class_subnet2, class_subnet3]
class_subnet = Concatenate(axis=3,
name='class_subnet_outputs')(class_subnet)
class_subnet = Conv2D(filters=n_priors * n_classes,
kernel_size=(1, 1),
strides=(1, 1))(class_subnet)
# bbox_subnet
bbox_subnet = [bbox_subnet_model(f) for f in features]
bbox_subnet0 = Conv2D(filters=n_priors * (4 + 1),
kernel_size=(1, 1),
strides=(4, 4))(bbox_subnet[0])
bbox_subnet1 = Conv2D(filters=n_priors * (4 + 1),
kernel_size=(1, 1),
strides=(2, 2))(bbox_subnet[1])
bbox_subnet2 = bbox_subnet[2]
bbox_subnet3 = UpSampling2D(size=(2, 2),
name='bbox_upsample')(bbox_subnet[3])
bbox_subnet = [bbox_subnet0, bbox_subnet1, bbox_subnet2, bbox_subnet3]
bbox_subnet = Concatenate(axis=3, name='bbox_subnet_outputs')(bbox_subnet)
bbox_subnet = Conv2D(filters=n_priors * (4 + 1),
kernel_size=(1, 1),
strides=(1, 1))(bbox_subnet)
# Output
# - n_priors: anchors
# - 4: offsets
# - n_classes: probability for each class
# - 1: confidence of having an object
output = Concatenate(axis=3)([class_subnet, bbox_subnet])
K.set_image_dim_ordering('th')
output = keras.layers.Permute((3, 2, 1))(output)
model = Model(inputs=inputs, outputs=output)
return model
def create_yolov3_model(nb_class, anchors, max_box_per_image, max_grid,
batch_size, warmup_batches, ignore_thresh, grid_scales,
obj_scale, noobj_scale, xywh_scale, class_scale):
input_image = Input(shape=(None, None, 3)) # net_h, net_w, 3
true_boxes = Input(shape=(1, 1, 1, max_box_per_image, 4))
true_yolo_1 = Input(
shape=(None, None, len(anchors) // 6,
4 + 1 + nb_class)) # grid_h, grid_w, nb_anchor, 5+nb_class
true_yolo_2 = Input(
shape=(None, None, len(anchors) // 6,
4 + 1 + nb_class)) # grid_h, grid_w, nb_anchor, 5+nb_class
true_yolo_3 = Input(
shape=(None, None, len(anchors) // 6,
4 + 1 + nb_class)) # grid_h, grid_w, nb_anchor, 5+nb_class
# Layer 0 => 4
x = _conv_block(input_image, [{
'filter': 32,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 0
}, {
'filter': 64,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 1
}, {
'filter': 32,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 2
}, {
'filter': 64,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 3
}])
# Layer 5 => 8
x = _conv_block(x, [{
'filter': 128,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 5
}, {
'filter': 64,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 6
}, {
'filter': 128,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 7
}])
# Layer 9 => 11
x = _conv_block(x, [{
'filter': 64,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 9
}, {
'filter': 128,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 10
}])
# Layer 12 => 15
x = _conv_block(x, [{
'filter': 256,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 12
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 13
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 14
}])
# Layer 16 => 36
for i in range(7):
x = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 16 + i * 3
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 17 + i * 3
}])
skip_36 = x
# Layer 37 => 40
x = _conv_block(x, [{
'filter': 512,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 37
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 38
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 39
}])
# Layer 41 => 61
for i in range(7):
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 41 + i * 3
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 42 + i * 3
}])
skip_61 = x
# Layer 62 => 65
x = _conv_block(x, [{
'filter': 1024,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 62
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 63
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 64
}])
# Layer 66 => 74
for i in range(3):
x = _conv_block(x, [{
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 66 + i * 3
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 67 + i * 3
}])
# Layer 75 => 79
x = _conv_block(x, [{
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 75
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 76
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 77
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 78
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 79
}],
do_skip=False)
# Layer 80 => 82
pred_yolo_1 = _conv_block(x, [{
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 80
}, {
'filter': (3 * (5 + nb_class)),
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 81
}],
do_skip=False)
loss_yolo_1 = YoloLayer(
anchors[12:], [1 * num
for num in max_grid], batch_size, warmup_batches,
ignore_thresh, grid_scales[0], obj_scale, noobj_scale, xywh_scale,
class_scale)([input_image, pred_yolo_1, true_yolo_1, true_boxes])
# Layer 83 => 86
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 84
}],
do_skip=False)
x = UpSampling2D(2)(x)
x = concatenate([x, skip_61])
# Layer 87 => 91
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 87
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 88
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 89
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 90
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 91
}],
do_skip=False)
# Layer 92 => 94
pred_yolo_2 = _conv_block(x, [{
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 92
}, {
'filter': (3 * (5 + nb_class)),
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 93
}],
do_skip=False)
loss_yolo_2 = YoloLayer(
anchors[6:12], [2 * num
for num in max_grid], batch_size, warmup_batches,
ignore_thresh, grid_scales[1], obj_scale, noobj_scale, xywh_scale,
class_scale)([input_image, pred_yolo_2, true_yolo_2, true_boxes])
# Layer 95 => 98
x = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 96
}],
do_skip=False)
x = UpSampling2D(2)(x)
x = concatenate([x, skip_36])
# Layer 99 => 106
pred_yolo_3 = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 99
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 100
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 101
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 102
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 103
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 104
}, {
'filter': (3 * (5 + nb_class)),
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 105
}],
do_skip=False)
loss_yolo_3 = YoloLayer(
anchors[:6], [4 * num for num in max_grid], batch_size, warmup_batches,
ignore_thresh, grid_scales[2], obj_scale, noobj_scale, xywh_scale,
class_scale)([input_image, pred_yolo_3, true_yolo_3, true_boxes])
train_model = Model(
[input_image, true_boxes, true_yolo_1, true_yolo_2, true_yolo_3],
[loss_yolo_1, loss_yolo_2, loss_yolo_3])
infer_model = Model(input_image, [pred_yolo_1, pred_yolo_2, pred_yolo_3])
return [train_model, infer_model]
def init_models(autoencoder_weights, classifier_weights):
input_shape = Input(shape=(90, 80, 1))
# Encoder Layers
conv_1 = Conv2D(16, (2, 2), activation='relu', padding='same')
max_pool_1 = MaxPooling2D((3, 2), padding='same')
conv_2 = Conv2D(32, (2, 2), activation='relu', padding='same')
max_pool_2 = MaxPooling2D((3, 2), padding='same')
conv_3 = Conv2D(64, (2, 2), activation='relu', padding='same')
max_pool_3 = MaxPooling2D((2, 2), padding='same')
conv_4 = Conv2D(128, (2, 2), activation='relu', padding='same')
encoded = Flatten(name='encoder')
# Bottleneck
dense_1 = Dense(256, name='bottleneck')
dense_2 = Dense(6400)
reshape = Reshape((5, 10, 128))
# Decoder Layers
conv_5 = Conv2D(128, (2, 2), activation='relu', padding='same')
up_samp_1 = UpSampling2D((2, 2))
conv_6 = Conv2D(64, (2, 2), activation='relu', padding='same')
up_samp_2 = UpSampling2D((3, 2))
conv_7 = Conv2D(32, (2, 2), activation='relu', padding='same')
up_samp_3 = UpSampling2D((3, 2))
decoded = Conv2D(1, (3, 3),
activation='sigmoid',
padding='same',
name='decoder')
####################################################################################################
#-----------------------------------------Full Autoencoder-----------------------------------------#
####################################################################################################
autoencoder = conv_1(input_shape)
autoencoder = max_pool_1(autoencoder)
autoencoder = conv_2(autoencoder)
autoencoder = max_pool_2(autoencoder)
autoencoder = conv_3(autoencoder)
autoencoder = max_pool_3(autoencoder)
autoencoder = conv_4(autoencoder)
autoencoder = encoded(autoencoder)
autoencoder = dense_1(autoencoder)
autoencoder = dense_2(autoencoder)
autoencoder = reshape(autoencoder)
autoencoder = conv_5(autoencoder)
autoencoder = up_samp_1(autoencoder)
autoencoder = conv_6(autoencoder)
autoencoder = up_samp_2(autoencoder)
autoencoder = conv_7(autoencoder)
autoencoder = up_samp_3(autoencoder)
autoencoder = decoded(autoencoder)
autoencoder = Model(inputs=input_shape, outputs=autoencoder)
####################################################################################################
#------------------------------------------Encoder-------------------------------------------------#
####################################################################################################
encoder = conv_1(input_shape)
encoder = max_pool_1(encoder)
encoder = conv_2(encoder)
encoder = max_pool_2(encoder)
encoder = conv_3(encoder)
encoder = max_pool_3(encoder)
encoder = conv_4(encoder)
encoder = encoded(encoder)
encoder = dense_1(encoder)
encoder_model = Model(inputs=input_shape, outputs=encoder)
####################################################################################################
#------------------------------------------Decoder------------------------------------------------#
####################################################################################################
bottleneck_input_shape = Input(shape=(256, ))
decoder_model = dense_2(bottleneck_input_shape)
decoder_model = reshape(decoder_model)
decoder_model = conv_5(decoder_model)
decoder_model = up_samp_1(decoder_model)
decoder_model = conv_6(decoder_model)
decoder_model = up_samp_2(decoder_model)
decoder_model = conv_7(decoder_model)
decoder_model = up_samp_3(decoder_model)
decoder_model = decoded(decoder_model)
decoder_model = Model(inputs=bottleneck_input_shape, outputs=decoder_model)
# Initializes the layers with weights
autoencoder.load_weights(autoencoder_weights)
####################################################################################################
#------------------------------------------Classifier----------------------------------------------#
####################################################################################################
# Layers
c_conv_1 = Conv2D(8, kernel_size=(2, 2), activation='relu')
c_max_pool_1 = MaxPooling2D(pool_size=(2, 2))
c_drop_1 = Dropout(0.2)
c_conv_2 = Conv2D(16, kernel_size=(2, 2), activation='relu')
c_max_pool_2 = MaxPooling2D(pool_size=(2, 2))
c_drop_2 = Dropout(0.2)
c_conv_3 = Conv2D(32, kernel_size=(2, 2), activation='relu')
c_max_pool_3 = MaxPooling2D(pool_size=(2, 2))
c_drop_3 = Dropout(0.2)
c_flatten = Flatten()
c_dense_1 = Dense(512, activation='relu')
c_drop_4 = Dropout(0.2)
c_dense_2 = Dense(256, activation='relu')
c_drop_5 = Dropout(0.2)
c_dense_3 = Dense(128, activation='relu')
c_drop_6 = Dropout(0.2)
c_dense_output = Dense(35, activation='softmax')
# Model
classifier = c_conv_1(input_shape)
classifier = c_max_pool_1(classifier)
classifier = c_drop_1(classifier)
classifier = c_conv_2(classifier)
classifier = c_max_pool_2(classifier)
classifier = c_drop_2(classifier)
classifier = c_conv_3(classifier)
classifier = c_max_pool_3(classifier)
classifier = c_drop_3(classifier)
classifier = c_flatten(classifier)
classifier = c_dense_1(classifier)
classifier = c_drop_4(classifier)
classifier = c_dense_2(classifier)
classifier = c_drop_5(classifier)
classifier = c_dense_3(classifier)
classifier = c_drop_6(classifier)
classifier = c_dense_output(classifier)
classifier = Model(inputs=input_shape, outputs=classifier)
# Initializes the classifier's layers with weights
classifier.load_weights(classifier_weights)
combined_model = dense_2(bottleneck_input_shape)
combined_model = reshape(combined_model)
combined_model = conv_5(combined_model)
combined_model = up_samp_1(combined_model)
combined_model = conv_6(combined_model)
combined_model = up_samp_2(combined_model)
combined_model = conv_7(combined_model)
combined_model = up_samp_3(combined_model)
combined_model = decoded(combined_model)
combined_model = c_conv_1(combined_model)
combined_model = c_max_pool_1(combined_model)
combined_model = c_drop_1(combined_model)
combined_model = c_conv_2(combined_model)
combined_model = c_max_pool_2(combined_model)
combined_model = c_drop_2(combined_model)
combined_model = c_conv_3(combined_model)
combined_model = c_max_pool_3(combined_model)
combined_model = c_drop_3(combined_model)
combined_model = c_flatten(combined_model)
combined_model = c_dense_1(combined_model)
combined_model = c_drop_4(combined_model)
combined_model = c_dense_2(combined_model)
combined_model = c_drop_5(combined_model)
combined_model = c_dense_3(combined_model)
combined_model = c_drop_6(combined_model)
combined_model = c_dense_output(combined_model)
full_model = Model(inputs=bottleneck_input_shape, outputs=combined_model)
return full_model, decoder_model
def __init__(self, im_shape):
img = Input(shape=(im_shape[0], im_shape[1], 1))
[pr6, pr5, pr4, pr3, pr2, pr1] = DispNet(img)
depth = UpSampling2D(name='y_pred')(pr1)
self.model = Model(input=img, output=depth)
shape = K.shape(x)
return K.reshape(K.repeat(input, 4 * 4), (shape[0], 4, 4, 256))
vgg_output = Lambda(repeat_output)(vgg_output)
# freeze vgg16
for layer in vgg16.layers:
layer.trainable = False
# concatenated net
merged = concatenate([vgg_output, main_output], axis=3)
last = Conv2D(128, (3, 3), padding="same")(merged)
last = UpSampling2D(size=(2, 2))(last)
last = Conv2D(64, (3, 3),
padding="same",
activation="relu",
kernel_regularizer=regularizers.l2(0.01))(last)
last = Conv2D(64, (3, 3),
padding="same",
activation="relu",
kernel_regularizer=regularizers.l2(0.01))(last)
last = UpSampling2D(size=(2, 2))(last)
last = Conv2D(32, (3, 3),
padding="same",
activation="relu",
kernel_regularizer=regularizers.l2(0.01))(last)
last = Conv2D(2, (3, 3),
def build_conv_max_pool_architecture(self):
# Encoder
e1 = Convolution2D(48,
4,
4,
activation='relu',
border_mode='same',
name='e1')(self.autoencoder_input)
e2 = MaxPooling2D((2, 2), border_mode='same', name='e2')(e1)
e3 = Convolution2D(64,
2,
2,
activation='relu',
border_mode='same',
name='e3')(e2)
e4 = MaxPooling2D((3, 3), border_mode='same', name='e4')(e3)
e5 = Dense(self.latent_shape, activation='relu',
name='e5')(flatten(e4))
self.encoder_output = e5
# Decoder layers
d1 = Dense(3136, activation='relu', name='d1')
d2 = Reshape((14, 14, 16), name='d2')
d3 = Convolution2D(64,
2,
2,
activation='relu',
border_mode='same',
name='d3')
d4 = UpSampling2D((3, 3), name='d4')
d5 = Convolution2D(48,
4,
4,
activation='relu',
border_mode='same',
name='d5')
d6 = UpSampling2D((2, 2), name='d6')
d7 = Convolution2D(1,
4,
4,
activation='sigmoid',
border_mode='same',
name='d7')
# Full autoencoder
d1_full = d1(self.encoder_output)
d2_full = d2(d1_full)
d3_full = d3(d2_full)
d4_full = d4(d3_full)
d5_full = d5(d4_full)
d6_full = d6(d5_full)
d7_full = d7(d6_full)
# Only decoding
d1_decoder = d1(self.decoder_input)
d2_decoder = d2(d1_decoder)
d3_decoder = d3(d2_decoder)
d4_decoder = d4(d3_decoder)
d5_decoder = d5(d4_decoder)
d6_decoder = d6(d5_decoder)
d7_decoder = d7(d6_decoder)
self.decoder_output = d7_decoder
self.autoencoder_output = d7_full
# MSE autoencoder reconstruction loss (with attention)
reconstruction_loss = tf.pow(
tf.multiply(
tf.subtract(self.autoencoder_input, self.autoencoder_output),
self.autoencoder_movement_focus_input), 2)
mean_reconstruction_loss = tf.reduce_mean(reconstruction_loss)
self.emulator_reconstruction_loss = tf.reduce_mean(tf.reshape(
reconstruction_loss, (self.emulator_counts, 84 * 84)),
axis=-1)
self.autoencoder_loss = mean_reconstruction_loss
x_test_small = np.array(x_test_small)
print("Successfuly generated appropriate data")
# prepare array for tensorflow
x_train = np.expand_dims(x_train, x_train.shape[-1])
x_train_small = np.expand_dims(x_train_small, x_train_small.shape[-1])
x_test = np.expand_dims(x_test, x_test.shape[-1])
x_test_small = np.expand_dims(x_test_small, x_test_small.shape[-1])
# Build model
input_img = Input(
shape=(x_train_small.shape[1], x_train_small.shape[2],
1)) # adapt this if using `channels_first` image data format
x = UpSampling2D((2, 2), interpolation='bilinear')(input_img)
x = Conv2D(64, (9, 9), activation='relu', padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(1, (3, 3), activation='relu', padding='same')(x)
upsample = Model(input_img, x)
upsample.compile(optimizer='adadelta',
loss='mean_squared_error',
metrics=[PSNR])
#Train the model
upsample.fit(x_train_small,
x_train,
epochs=epochs,
batch_size=batch_size,
shuffle=True,
def get_unet(self):
# inputs = Input((self.img_rows, self.img_cols,1))
inputs = Input((self.img_rows, self.img_cols, 3))
'''
unet with crop(because padding = valid)
conv1 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(inputs)
print "conv1 shape:",conv1.shape
conv1 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv1)
print "conv1 shape:",conv1.shape
crop1 = Cropping2D(cropping=((90,90),(90,90)))(conv1)
print "crop1 shape:",crop1.shape
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
print "pool1 shape:",pool1.shape
conv2 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool1)
print "conv2 shape:",conv2.shape
conv2 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv2)
print "conv2 shape:",conv2.shape
crop2 = Cropping2D(cropping=((41,41),(41,41)))(conv2)
print "crop2 shape:",crop2.shape
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
print "pool2 shape:",pool2.shape
conv3 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool2)
print "conv3 shape:",conv3.shape
conv3 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv3)
print "conv3 shape:",conv3.shape
crop3 = Cropping2D(cropping=((16,17),(16,17)))(conv3)
print "crop3 shape:",crop3.shape
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
print "pool3 shape:",pool3.shape
conv4 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool3)
conv4 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
crop4 = Cropping2D(cropping=((4,4),(4,4)))(drop4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(pool4)
conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))
merge6 = merge([crop4,up6], mode = 'concat', concat_axis = 3)
conv6 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge6)
conv6 = Conv2D(512, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv6)
up7 = Conv2D(256, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))
merge7 = merge([crop3,up7], mode = 'concat', concat_axis = 3)
conv7 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge7)
conv7 = Conv2D(256, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv7)
up8 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))
merge8 = merge([crop2,up8], mode = 'concat', concat_axis = 3)
conv8 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge8)
conv8 = Conv2D(128, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv8)
up9 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))
merge9 = merge([crop1,up9], mode = 'concat', concat_axis = 3)
conv9 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(merge9)
conv9 = Conv2D(64, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv9)
conv9 = Conv2D(2, 3, activation = 'relu', padding = 'valid', kernel_initializer = 'he_normal')(conv9)
'''
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(inputs)
print("conv1 shape:", conv1.shape)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv1)
print("conv1 shape:", conv1.shape)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
print("pool1 shape:", pool1.shape)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool1)
print("conv2 shape:", conv2.shape)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv2)
print("conv2 shape:", conv2.shape)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
print("pool2 shape:", pool2.shape)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool2)
print("conv3 shape:", conv3.shape)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv3)
print("conv3 shape:", conv3.shape)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
print("pool3 shape:", pool3.shape)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(drop5))
merge6 = merge([drop4, up6], mode='concat', concat_axis=3)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge6)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv6)
up7 = Conv2D(256,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv6))
merge7 = merge([conv3, up7], mode='concat', concat_axis=3)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge7)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv7)
up8 = Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv7))
merge8 = merge([conv2, up8], mode='concat', concat_axis=3)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge8)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv8)
up9 = Conv2D(64,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv8))
merge9 = merge([conv1, up9], mode='concat', concat_axis=3)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge9)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv9 = Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
model = Model(input=inputs, output=conv10)
model.compile(optimizer=Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
return model
def Network(self):
inputs = Input(shape=(self.img_size[0], self.img_size[1], 1),
batch_shape=None)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(inputs)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(drop5))
merge6 = merge([drop4, up6], mode='concat', concat_axis=3)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge6)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv6)
up7 = Conv2D(256,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv6))
merge7 = merge([conv3, up7], mode='concat', concat_axis=3)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge7)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv7)
up8 = Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv7))
merge8 = merge([conv2, up8], mode='concat', concat_axis=3)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge8)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv8)
up9 = Conv2D(64,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(conv8))
merge9 = merge([conv1, up9], mode='concat', concat_axis=3)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge9)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv9 = Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
model = Model(input=inputs, output=conv10)
return model
def gan_2(input_img,
input_channel=3,
z_num=64,
no_of_pairs=5,
hidden_num=128,
activation_fn=tf.nn.elu,
noise_dim=64):
# Encoder
encoder_layer_list = []
x = Conv2D(hidden_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(input_img)
prev_channel_num = hidden_num
for idx in range(no_of_pairs):
# to increase number of filter by (filters)*(index+1) ex: 16, 32, 48 ...
channel_num = hidden_num * (idx + 1)
res = x
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
if idx > 0:
encoder_layer_list.append(x)
if idx < no_of_pairs - 1:
x = Conv2D(channel_num,
kernel_size=3,
strides=2,
activation=activation_fn,
padding='same')(x)
if noise_dim > 0:
x = Lambda(get_noise)(x)
for idx in range(no_of_pairs):
if idx < no_of_pairs - 1:
x = Concatenate(axis=-1)(
[x, encoder_layer_list[no_of_pairs - 2 - idx]])
channel_num = x.get_shape().as_list()[-1]
x = Conv2D(hidden_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(hidden_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
if idx < no_of_pairs - 1:
x = UpSampling2D(2)(x)
out = Conv2D(input_channel,
kernel_size=3,
strides=1,
activation=None,
padding='same')(x)
return out
def _main(args):
config_path = os.path.expanduser(args.config_path)
weights_path = os.path.expanduser(args.weights_path)
assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format(
config_path)
assert weights_path.endswith(
'.weights'), '{} is not a .weights file'.format(weights_path)
output_path = os.path.expanduser(args.output_path)
assert output_path.endswith(
'.h5'), 'output path {} is not a .h5 file'.format(output_path)
output_root = os.path.splitext(output_path)[0]
# Load weights and config.
print('Loading weights.')
weights_file = open(weights_path, 'rb')
major, minor, revision = np.ndarray(shape=(3, ),
dtype='int32',
buffer=weights_file.read(12))
if (major * 10 + minor) >= 2 and major < 1000 and minor < 1000:
seen = np.ndarray(shape=(1, ),
dtype='int64',
buffer=weights_file.read(8))
else:
seen = np.ndarray(shape=(1, ),
dtype='int32',
buffer=weights_file.read(4))
print('Weights Header: ', major, minor, revision, seen)
print('Parsing Darknet config.')
unique_config_file = unique_config_sections(config_path)
cfg_parser = configparser.ConfigParser()
cfg_parser.read_file(unique_config_file)
print('Creating Keras model.')
input_layer = Input(shape=(None, None, 3))
prev_layer = input_layer
all_layers = []
weight_decay = float(cfg_parser['net_0']['decay']
) if 'net_0' in cfg_parser.sections() else 5e-4
count = 0
out_index = []
for section in cfg_parser.sections():
print('Parsing section {}'.format(section))
if section.startswith('convolutional'):
filters = int(cfg_parser[section]['filters'])
size = int(cfg_parser[section]['size'])
stride = int(cfg_parser[section]['stride'])
pad = int(cfg_parser[section]['pad'])
activation = cfg_parser[section]['activation']
batch_normalize = 'batch_normalize' in cfg_parser[section]
padding = 'same' if pad == 1 and stride == 1 else 'valid'
# Setting weights.
# Darknet serializes convolutional weights as:
# [bias/beta, [gamma, mean, variance], conv_weights]
prev_layer_shape = K.int_shape(prev_layer)
weights_shape = (size, size, prev_layer_shape[-1], filters)
darknet_w_shape = (filters, weights_shape[2], size, size)
weights_size = np.product(weights_shape)
print('conv2d', 'bn' if batch_normalize else ' ', activation,
weights_shape)
conv_bias = np.ndarray(shape=(filters, ),
dtype='float32',
buffer=weights_file.read(filters * 4))
count += filters
if batch_normalize:
bn_weights = np.ndarray(shape=(3, filters),
dtype='float32',
buffer=weights_file.read(filters * 12))
count += 3 * filters
bn_weight_list = [
bn_weights[0], # scale gamma
conv_bias, # shift beta
bn_weights[1], # running mean
bn_weights[2] # running var
]
conv_weights = np.ndarray(shape=darknet_w_shape,
dtype='float32',
buffer=weights_file.read(weights_size *
4))
count += weights_size
# DarkNet conv_weights are serialized Caffe-style:
# (out_dim, in_dim, height, width)
# We would like to set these to Tensorflow order:
# (height, width, in_dim, out_dim)
conv_weights = np.transpose(conv_weights, [2, 3, 1, 0])
conv_weights = [conv_weights] if batch_normalize else [
conv_weights, conv_bias
]
# Handle activation.
act_fn = None
if activation == 'leaky':
pass # Add advanced activation later.
elif activation != 'linear':
raise ValueError(
'Unknown activation function `{}` in section {}'.format(
activation, section))
# Create Conv2D layer
if stride > 1:
# Darknet uses left and top padding instead of 'same' mode
prev_layer = ZeroPadding2D(((1, 0), (1, 0)))(prev_layer)
conv_layer = (Conv2D(filters, (size, size),
strides=(stride, stride),
kernel_regularizer=l2(weight_decay),
use_bias=not batch_normalize,
weights=conv_weights,
activation=act_fn,
padding=padding))(prev_layer)
if batch_normalize:
conv_layer = (BatchNormalization(
weights=bn_weight_list))(conv_layer)
prev_layer = conv_layer
if activation == 'linear':
all_layers.append(prev_layer)
elif activation == 'leaky':
act_layer = LeakyReLU(alpha=0.1)(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif section.startswith('route'):
ids = [int(i) for i in cfg_parser[section]['layers'].split(',')]
layers = [all_layers[i] for i in ids]
if len(layers) > 1:
print('Concatenating route layers:', layers)
concatenate_layer = Concatenate()(layers)
all_layers.append(concatenate_layer)
prev_layer = concatenate_layer
else:
skip_layer = layers[0] # only one layer to route
all_layers.append(skip_layer)
prev_layer = skip_layer
elif section.startswith('maxpool'):
size = int(cfg_parser[section]['size'])
stride = int(cfg_parser[section]['stride'])
all_layers.append(
MaxPooling2D(pool_size=(size, size),
strides=(stride, stride),
padding='same')(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('shortcut'):
index = int(cfg_parser[section]['from'])
activation = cfg_parser[section]['activation']
assert activation == 'linear', 'Only linear activation supported.'
all_layers.append(Add()([all_layers[index], prev_layer]))
prev_layer = all_layers[-1]
elif section.startswith('upsample'):
stride = int(cfg_parser[section]['stride'])
assert stride == 2, 'Only stride=2 supported.'
all_layers.append(UpSampling2D(stride)(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('yolo'):
out_index.append(len(all_layers) - 1)
all_layers.append(None)
prev_layer = all_layers[-1]
elif section.startswith('net'):
pass
else:
raise ValueError(
'Unsupported section header type: {}'.format(section))
# Create and save model.
if len(out_index) == 0: out_index.append(len(all_layers) - 1)
model = Model(inputs=input_layer,
outputs=[all_layers[i] for i in out_index])
print(model.summary())
if args.weights_only:
model.save_weights('{}'.format(output_path))
print('Saved Keras weights to {}'.format(output_path))
else:
model.save('{}'.format(output_path))
print('Saved Keras model to {}'.format(output_path))
# Check to see if all weights have been read.
remaining_weights = len(weights_file.read()) / 4
weights_file.close()
print('Read {} of {} from Darknet weights.'.format(
count, count + remaining_weights))
if remaining_weights > 0:
print('Warning: {} unused weights'.format(remaining_weights))
if args.plot_model:
plot(model, to_file='{}.png'.format(output_root), show_shapes=True)
print('Saved model plot to {}.png'.format(output_root))
def build_ae(vgg16_encoder, x_train_shape, class_or_regr):
"""Build your autoencoder in here."""
encoder_input = Input(shape=x_train_shape, name='encoder_input')
# ---------- block1
x = vgg16_encoder.get_layer('block1_conv1')(encoder_input)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block1_conv2')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block1_pool')(x)
# ---------- block2
x = vgg16_encoder.get_layer('block2_conv1')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block2_conv2')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block2_pool')(x)
# ---------- block3
x = vgg16_encoder.get_layer('block3_conv1')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block3_conv2')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block3_conv3')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block3_pool')(x)
# ---------- block4
x = vgg16_encoder.get_layer('block4_conv1')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block4_conv2')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block4_conv3')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block4_pool')(x)
# ---------- block5
x = vgg16_encoder.get_layer('block5_conv1')(x)
x = BatchNormalization()(x)
x = vgg16_encoder.get_layer('block5_conv2')(x)
x = BatchNormalization()(x)
encoded = vgg16_encoder.get_layer('block5_conv3')(x)
# ---------- block5
x = Conv2DTranspose(512, (3, 3), activation='relu',
padding='same')(encoded)
x = BatchNormalization()(x)
x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
# ---------- block4
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
# ---------- block3
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(256, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(256, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(256, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
# ---------- block2
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
# ---------- block1
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
if class_or_regr == 0:
final_filters = 3
elif class_or_regr == 1:
final_filters = 29
decoder_output = Conv2DTranspose(final_filters, (3, 3),
activation='softmax',
padding='same')(x)
autoencoder = Model(encoder_input, decoder_output)
return autoencoder
padding='same')(encoder_output)
encoder_output = Conv2D(256, (3, 3), activation='relu',
padding='same')(encoder_output)
#Fusion
embed_input = Input(shape=(1000, ))
fusion_output = RepeatVector(32 * 32)(embed_input)
fusion_output = Reshape(([32, 32, 1000]))(fusion_output)
fusion_output = concatenate([encoder_output, fusion_output], axis=3)
fusion_output = Conv2D(256, (1, 1), activation='relu',
padding='same')(fusion_output)
#Decoder
decoder_output = Conv2D(128, (3, 3), activation='relu',
padding='same')(fusion_output)
decoder_output = UpSampling2D((2, 2))(decoder_output)
decoder_output = Conv2D(64, (3, 3), activation='relu',
padding='same')(decoder_output)
decoder_output = UpSampling2D((2, 2))(decoder_output)
decoder_output = Conv2D(32, (3, 3), activation='relu',
padding='same')(decoder_output)
decoder_output = Conv2D(16, (3, 3), activation='relu',
padding='same')(decoder_output)
decoder_output = Conv2D(2, (3, 3), activation='tanh',
padding='same')(decoder_output)
decoder_output = UpSampling2D((2, 2))(decoder_output)
model = Model(inputs=[encoder_input, embed_input], outputs=decoder_output)
def create_inception_embedding(grayscaled_rgb):
Conv2D(10, (8, 8),
activation='relu',
padding='same',
input_shape=input_shape))
auto_encoder.add(
Conv2D(10, (8, 8),
activation='relu',
padding='same',
input_shape=input_shape))
auto_encoder.add(MaxPooling2D((2, 2), padding='same'))
auto_encoder.add(
Conv2D(10, (8, 8),
activation='relu',
padding='same',
input_shape=input_shape))
auto_encoder.add(UpSampling2D((2, 2)))
auto_encoder.add(
Conv2D(10, (8, 8),
activation='relu',
padding='same',
input_shape=input_shape))
auto_encoder.add(Conv2D(10, (8, 8), activation='relu', padding='same'))
auto_encoder.add(Conv2D(1, (3, 3), activation='sigmoid', padding='same'))
#**********************************model compile*********************************************
auto_encoder.compile(optimizer='sgd', loss='mean_squared_error')
auto_encoder.summary()
#****************************************training*******************************************
for q in range(5):
def get_resnet(f=16, bn_axis=3, classes=1):
input = Input((img_rows, img_cols, 1))
x = ZeroPadding2D((4, 4))(input)
x = Conv2D(f, (7, 7), strides=(2, 2), name='conv1')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [f, f, f * 2], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [f, f, f * 2], stage=2, block='b')
x2 = identity_block(x, 3, [f, f, f * 2], stage=2, block='c')
x = conv_block(x2, 3, [f * 2, f * 2, f * 4], stage=3, block='a')
x = identity_block(x, 3, [f * 2, f * 2, f * 4], stage=3, block='b')
x3 = identity_block(x, 3, [f * 2, f * 2, f * 4], stage=3, block='d')
x = conv_block(x3, 3, [f * 4, f * 4, f * 8], stage=4, block='a')
x = identity_block(x, 3, [f * 4, f * 4, f * 8], stage=4, block='b')
x4 = identity_block(x, 3, [f * 4, f * 4, f * 8], stage=4, block='f')
x = conv_block(x4, 3, [f * 8, f * 8, f * 16], stage=5, block='a')
x = identity_block(x, 3, [f * 8, f * 8, f * 16], stage=5, block='b')
x = identity_block(x, 3, [f * 8, f * 8, f * 16], stage=5, block='c')
x = up_conv_block(x, 3, [f * 16, f * 8, f * 8], stage=6, block='a')
x = identity_block(x, 3, [f * 16, f * 8, f * 8], stage=6, block='b')
x = identity_block(x, 3, [f * 16, f * 8, f * 8], stage=6, block='c')
x = concatenate([x, x4], axis=bn_axis)
x = up_conv_block(x, 3, [f * 16, f * 4, f * 4], stage=7, block='a')
x = identity_block(x, 3, [f * 16, f * 4, f * 4], stage=7, block='b')
x = identity_block(x, 3, [f * 16, f * 4, f * 4], stage=7, block='f')
x = concatenate([x, x3], axis=bn_axis)
x = up_conv_block(x, 3, [f * 8, f * 2, f * 2], stage=8, block='a')
x = identity_block(x, 3, [f * 8, f * 2, f * 2], stage=8, block='b')
x = identity_block(x, 3, [f * 8, f * 2, f * 2], stage=8, block='d')
x = concatenate([x, x2], axis=bn_axis)
x = up_conv_block(x, 3, [f * 4, f, f], stage=10, block='a', strides=(1, 1))
x = identity_block(x, 3, [f * 4, f, f], stage=10, block='b')
x = identity_block(x, 3, [f * 4, f, f], stage=10, block='c')
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(classes, (3, 3),
padding='same',
activation='sigmoid',
name='convLast')(x)
model = Model(input, x, name='resnetUnet')
model.compile(
optimizer=Adam(lr=3e-4),
loss=dice_coef_loss,
metrics=[dice_coef, defect_accuracy, precision, recall, f1score])
model.summary()
return model
def model(input_shape, kernel_size, optimizer='adam'):
model = Sequential()
model.add(
Conv2D(kernel_size, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same',
strides=2))
model.add(
Conv2D(kernel_size * 2, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(
Conv2D(kernel_size * 4, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same',
strides=2))
model.add(
Conv2D(kernel_size * 4, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(
Conv2D(kernel_size * 8, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same',
strides=2))
model.add(
Conv2D(kernel_size * 8, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(
Conv2D(kernel_size * 16, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(
Conv2D(kernel_size * 16, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(
Conv2D(kernel_size * 8, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(
Conv2D(kernel_size * 4, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(
Conv2D(kernel_size * 2, (3, 3),
input_shape=input_shape,
activation='relu',
padding='same'))
model.add(Conv2D(2, (3, 3), activation='tanh', padding='same'))
model.add(UpSampling2D((2, 2)))
model.compile(optimizer=optimizer, loss='mse')
print(model.summary())
return model
k_size = 3
model = models.Sequential()
model.add(Conv2D(64, kernel_size=(k_size, k_size), strides=(1, 1),
activation='relu',
input_shape=input_shape, padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, (k_size, k_size), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
# model.add(Conv2D(8, (k_size, k_size), activation='relu', padding='same'))
# model.add(MaxPooling2D(pool_size=(2, 2)))
# ### Encoded
# model.add(Conv2D(8, (k_size, k_size), activation='relu', padding='same'))
# model.add(UpSampling2D((2, 2)))
model.add(Conv2D(16, (k_size, k_size), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(32, (k_size, k_size), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(1, (k_size, k_size), activation='sigmoid', padding='same'))
model.summary()
model.compile(optimizer='adam', loss='binary_crossentropy')
# model.compile(optimizer='adam', loss='mean_squared_error')
# N_total = N_copies * N_samples
# N_train = N_total * 80 // 100
# train_noisy, train_clean = PSF_img_photon[:N_train], PSF_img_copy[:N_train]
# test_noisy, test_clean = PSF_img_photon[N_train:], PSF_img_copy[N_train:]
N_copies = 15
N_loops = 15
def build_model(self):
inputs = Input((self.patch_height, self.patch_width, 1))
conv1 = Conv2D(32, (3, 3), padding='same')(inputs) # 'valid'
conv1 = LeakyReLU(alpha=0.3)(conv1)
conv1 = Dropout(0.2)(conv1)
conv1 = normalization.BatchNormalization(
epsilon=2e-05,
axis=3,
momentum=0.9,
weights=None,
beta_initializer='RandomNormal',
gamma_initializer='one')(conv1)
conv1 = Conv2D(32, (3, 3), dilation_rate=2, padding='same')(conv1)
conv1 = LeakyReLU(alpha=0.3)(conv1)
conv1 = Conv2D(32, (3, 3), dilation_rate=4, padding='same')(conv1)
conv1 = LeakyReLU(alpha=0.3)(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
# pool1 = normalization.BatchNormalization(epsilon=1e-06, mode=1, axis=-1, momentum=0.9, weights=None, beta_init='zero', gamma_init='one')(pool1)
conv2 = Conv2D(64, (3, 3), padding='same')(
pool1) # ,activation='relu', padding='same')(pool1)
conv2 = normalization.BatchNormalization(
epsilon=2e-05,
axis=3,
momentum=0.9,
weights=None,
beta_initializer='RandomNormal',
gamma_initializer='one')(conv2)
conv2 = LeakyReLU(alpha=0.3)(conv2)
conv2 = Dropout(0.2)(conv2)
conv2 = Conv2D(64, (3, 3), dilation_rate=2, padding='same')(conv2)
conv2 = LeakyReLU(alpha=0.3)(conv2)
conv2 = Conv2D(64, (3, 3), dilation_rate=4, padding='same')(
conv2) # ,W_regularizer=l2(0.01), b_regularizer=l2(0.01))(conv2)
conv2 = LeakyReLU(alpha=0.3)(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
# crop = Cropping2D(cropping=((int(3 * patch_height / 8), int(3 * patch_height / 8)), (int(3 * patch_width / 8), int(3 * patch_width / 8))))(conv1)
# conv3 = concatenate([crop,pool2], axis=1)
conv3 = Conv2D(128, (3, 3), padding='same')(
pool2) # , activation='relu', padding='same')(conv3)
conv3 = normalization.BatchNormalization(
epsilon=2e-05,
axis=3,
momentum=0.9,
weights=None,
beta_initializer='RandomNormal',
gamma_initializer='one')(conv3)
conv3 = LeakyReLU(alpha=0.3)(conv3)
conv3 = Dropout(0.2)(conv3)
conv3 = Conv2D(128, (3, 3), dilation_rate=2, padding='same')(
conv3) # ,W_regularizer=l2(0.01), b_regularizer=l2(0.01))(conv3)
conv3 = normalization.BatchNormalization(
epsilon=2e-05,
axis=3,
momentum=0.9,
weights=None,
beta_initializer='RandomNormal',
gamma_initializer='one')(conv3)
conv3 = LeakyReLU(alpha=0.3)(conv3)
conv3 = Conv2D(128, (3, 3), dilation_rate=4, padding='same')(conv3)
conv3 = normalization.BatchNormalization(
epsilon=2e-05,
axis=3,
momentum=0.9,
weights=None,
beta_initializer='RandomNormal',
gamma_initializer='one')(conv3)
conv3 = LeakyReLU(alpha=0.3)(conv3)
# up1 = UpSampling2D(size=(2, 2))(conv3)
up1 = concatenate([UpSampling2D(size=(2, 2))(conv3), conv2], axis=3)
conv4 = Conv2D(64, (3, 3), padding='same')(up1)
conv4 = LeakyReLU(alpha=0.3)(conv4)
conv4 = Dropout(0.2)(conv4)
conv4 = Conv2D(64, (3, 3), padding='same')(conv4)
conv4 = LeakyReLU(alpha=0.3)(conv4)
# conv4 = normalization.BatchNormalization(epsilon=1e-06, mode=1, axis=-1, momentum=0.9, weights=None, beta_init='zero', gamma_init='one')(conv4)
#
# up2 = UpSampling2D(size=(2, 2))(conv4)
up2 = concatenate([UpSampling2D(size=(2, 2))(conv4), conv1], axis=3)
conv5 = Conv2D(32, (3, 3), padding='same')(up2)
conv5 = LeakyReLU(alpha=0.3)(conv5)
conv5 = Dropout(0.2)(conv5)
conv5 = Conv2D(32, (3, 3), padding='same')(conv5)
conv5 = LeakyReLU(alpha=0.3)(conv5)
conv6 = Conv2D(self.num_seg_class + 1, (1, 1), padding='same')(conv5)
conv6 = LeakyReLU(alpha=0.3)(conv6)
# conv6 = normalization.BatchNormalization(epsilon=1e-06, mode=1, axis=-1, momentum=0.9, weights=None, beta_init='zero', gamma_init='one')(conv6)
# for tensorflow
# conv6 = core.Reshape((patch_height*patch_width,num_lesion_class+1))(conv6)
# for theano
conv6 = core.Reshape((self.patch_height * self.patch_width,
self.num_seg_class + 1))(conv6)
# conv6 = core.Permute((2, 1))(conv6)
############
act = Activation('softmax')(conv6)
model = Model(inputs=inputs, outputs=act)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
plot_model(model,
to_file=os.path.join(self.config.checkpoint, "model.png"),
show_shapes=True)
self.model = model
def make_yolov3_model():
input_image = Input(shape=(None, None, 3))
# Layer 0 => 4
x = _conv_block(input_image, [{
'filter': 32,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 0
}, {
'filter': 64,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 1
}, {
'filter': 32,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 2
}, {
'filter': 64,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 3
}])
# Layer 5 => 8
x = _conv_block(x, [{
'filter': 128,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 5
}, {
'filter': 64,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 6
}, {
'filter': 128,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 7
}])
# Layer 9 => 11
x = _conv_block(x, [{
'filter': 64,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 9
}, {
'filter': 128,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 10
}])
# Layer 12 => 15
x = _conv_block(x, [{
'filter': 256,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 12
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 13
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 14
}])
# Layer 16 => 36
for i in range(7):
x = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 16 + i * 3
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 17 + i * 3
}])
skip_36 = x
# Layer 37 => 40
x = _conv_block(x, [{
'filter': 512,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 37
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 38
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 39
}])
# Layer 41 => 61
for i in range(7):
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 41 + i * 3
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 42 + i * 3
}])
skip_61 = x
# Layer 62 => 65
x = _conv_block(x, [{
'filter': 1024,
'kernel': 3,
'stride': 2,
'bnorm': True,
'leaky': True,
'layer_idx': 62
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 63
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 64
}])
# Layer 66 => 74
for i in range(3):
x = _conv_block(x, [{
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 66 + i * 3
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 67 + i * 3
}])
# Layer 75 => 79
x = _conv_block(x, [{
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 75
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 76
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 77
}, {
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 78
}, {
'filter': 512,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 79
}],
skip=False)
# Layer 80 => 82
yolo_82 = _conv_block(x, [{
'filter': 1024,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 80
}, {
'filter': 255,
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 81
}],
skip=False)
# Layer 83 => 86
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 84
}],
skip=False)
x = UpSampling2D(2)(x)
x = concatenate([x, skip_61])
# Layer 87 => 91
x = _conv_block(x, [{
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 87
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 88
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 89
}, {
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 90
}, {
'filter': 256,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 91
}],
skip=False)
# Layer 92 => 94
yolo_94 = _conv_block(x, [{
'filter': 512,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 92
}, {
'filter': 255,
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 93
}],
skip=False)
# Layer 95 => 98
x = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 96
}],
skip=False)
x = UpSampling2D(2)(x)
x = concatenate([x, skip_36])
# Layer 99 => 106
yolo_106 = _conv_block(x, [{
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 99
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 100
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 101
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 102
}, {
'filter': 128,
'kernel': 1,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 103
}, {
'filter': 256,
'kernel': 3,
'stride': 1,
'bnorm': True,
'leaky': True,
'layer_idx': 104
}, {
'filter': 255,
'kernel': 1,
'stride': 1,
'bnorm': False,
'leaky': False,
'layer_idx': 105
}],
skip=False)
model = Model(input_image, [yolo_82, yolo_94, yolo_106])
return model
def UnetResidual_model(input_shape=(image_rows, image_cols, image_channels),
num_classes=1,
k=64,
kc=512):
# Conv filter parameters
k1 = k
k2 = 2 * k1
k3 = 2 * k2
k4 = 2 * k3
kc = 2 * k4
#print('k1 ={}'.format(k1))
#print('k2 ={}'.format(k2))
#print('k3 ={}'.format(k3))
#print('k4 ={}'.format(k4))
#print('kc ={}'.format(kc))
#### Build U-Net model
#### Input
inputs = Input((image_rows, image_cols, image_channels))
#### DownSampling Block (4)
down1 = Conv2D(k1, (3, 3), padding='same')(inputs)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1 = Conv2D(k1, (3, 3), padding='same')(down1)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
down2 = Conv2D(k2, (3, 3), padding='same')(down1_pool)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2 = Conv2D(k2, (3, 3), padding='same')(down2)
down2 = BatchNormalization()(down2)
shortcut = Conv2D(k2, (1, 1))(down1_pool)
shortcut = BatchNormalization()(shortcut)
down2 = add([down2, shortcut]) # skip connection
down2 = Activation('relu')(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
down3 = Conv2D(k3, (3, 3), padding='same')(down2_pool)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3 = Conv2D(k3, (3, 3), padding='same')(down3)
down3 = BatchNormalization()(down3)
shortcut = Conv2D(k3, (1, 1))(down2_pool)
shortcut = BatchNormalization()(shortcut)
down3 = add([down3, shortcut]) # skip connection
down3 = Activation('relu')(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
down4 = Conv2D(k4, (3, 3), padding='same')(down3_pool)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4 = Conv2D(k4, (3, 3), padding='same')(down4)
down4 = BatchNormalization()(down4)
shortcut = Conv2D(k4, (1, 1))(down3_pool)
shortcut = BatchNormalization()(shortcut)
down4 = add([down4, shortcut]) # skip connection
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
down4_pool = Dropout(0.5)(down4_pool)
#### Center Block
center = Conv2D(kc, (3, 3), padding='same')(down4_pool)
center = BatchNormalization()(center)
center = Activation('relu')(center)
center = Conv2D(kc, (3, 3), padding='same')(center)
center = BatchNormalization()(center)
shortcut = Conv2D(kc, (1, 1))(down4_pool)
shortcut = BatchNormalization()(shortcut)
center = add([center, shortcut]) # skip connection
center = Activation('relu')(center)
center = Dropout(0.5)(center)
#### UpSampling Blocks (4)
up4 = UpSampling2D((2, 2))(center)
up4_con = concatenate([down4, up4], axis=3)
up4 = Conv2D(k4, (3, 3), padding='same')(up4_con)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(k4, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(k4, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
shortcut = Conv2D(k4, (1, 1))(up4_con)
shortcut = BatchNormalization()(shortcut)
up4 = add([up4, shortcut]) # skip connection
up4 = Activation('relu')(up4)
up3 = UpSampling2D((2, 2))(up4)
up3_con = concatenate([down3, up3], axis=3)
up3 = Conv2D(k3, (3, 3), padding='same')(up3_con)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(k3, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(k3, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
shortcut = Conv2D(k3, (1, 1))(up3_con)
shortcut = BatchNormalization()(shortcut)
up3 = add([up3, shortcut]) # skip connection
up3 = Activation('relu')(up3)
up2 = UpSampling2D((2, 2))(up3)
up2_con = concatenate([down2, up2], axis=3)
up2 = Conv2D(k2, (3, 3), padding='same')(up2_con)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(k2, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(k2, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
shortcut = Conv2D(k2, (1, 1))(up2_con)
shortcut = BatchNormalization()(shortcut)
up2 = add([up2, shortcut]) # skip connection
up2 = Activation('relu')(up2)
up1 = UpSampling2D((2, 2))(up2)
up1_con = concatenate([down1, up1], axis=3)
up1 = Conv2D(k1, (3, 3), padding='same')(up1_con)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(k1, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(k1, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
shortcut = Conv2D(k1, (1, 1))(up1_con)
shortcut = BatchNormalization()(shortcut)
up1 = add([up1, shortcut]) # skip connection
up1 = Activation('relu')(up1)
# Pixel Classification
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up1)
# Model
model = Model(inputs=[inputs], outputs=[classify]) # optimizer=sgd
### Optimizer, Loss and Metrics
model.compile(optimizer=Adam(lr=1e-3),
loss=binary_crossentropy,
metrics=[dice_coeff])
# Display the model
model.summary()
return model
def upscale2x(self,
input_tensor,
filters,
kernel_size=3,
padding="same",
interpolation="bilinear",
res_block_follows=False,
sr_ratio=0.5,
scale_factor=2,
fast=False,
**kwargs):
""" Custom hybrid upscale layer for sub-pixel up-scaling.
Most of up-scaling is approximating lighting gradients which can be accurately achieved
using linear fitting. This layer attempts to improve memory consumption by splitting
with bilinear and convolutional layers so that the sub-pixel update will get details
whilst the bilinear filter will get lighting.
Adds reflection padding if it has been selected by the user, and other post-processing
if requested by the plugin.
Parameters
----------
input_tensor: tensor
The input tensor to the layer
filters: int
The dimensionality of the output space (i.e. the number of output filters in the
convolution)
kernel_size: int, optional
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. Default: 3
padding: ["valid", "same"], optional
The padding to use. Default: `"same"`
interpolation: ["nearest", "bilinear"], optional
Interpolation to use for up-sampling. Default: `"bilinear"`
res_block_follows: bool, optional
If a residual block will follow this layer, then this should be set to `True` to add
a leaky ReLu after the convolutional layer. Default: ``False``
scale_factor: int, optional
The amount to upscale the image. Default: `2`
sr_ratio: float, optional
The proportion of super resolution (pixel shuffler) filters to use. Non-fast mode only.
Default: `0.5`
kwargs: dict
Any additional Keras standard layer keyword arguments
fast: bool, optional
Use a faster up-scaling method that may appear more rugged. Default: ``False``
Returns
-------
tensor
The output tensor from the Upscale layer
"""
name = self._get_name("upscale2x_{}".format("fast" if fast else "hyb"))
var_x = input_tensor
if not fast:
sr_filters = int(filters * sr_ratio)
filters = filters - sr_filters
var_x_sr = self.upscale(var_x,
filters,
kernel_size=kernel_size,
padding=padding,
scale_factor=scale_factor,
res_block_follows=res_block_follows,
**kwargs)
if fast or (not fast and filters > 0):
var_x2 = self.conv2d(var_x,
filters,
kernel_size=3,
padding=padding,
name="{}_conv2d".format(name),
**kwargs)
var_x2 = UpSampling2D(size=(scale_factor, scale_factor),
interpolation=interpolation,
name="{}_upsampling2D".format(name))(var_x2)
if fast:
var_x1 = self.upscale(var_x,
filters,
kernel_size=kernel_size,
padding=padding,
scale_factor=scale_factor,
res_block_follows=res_block_follows,
**kwargs)
var_x = Add()([var_x2, var_x1])
else:
var_x = Concatenate(name="{}_concatenate".format(name))(
[var_x_sr, var_x2])
else:
var_x = var_x_sr
return var_x
def get_unet_128(input_shape=(128, 128, 3), num_classes=1):
inputs = Input(shape=input_shape)
# 128
down1 = Conv2D(64, (3, 3), padding='same')(inputs)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1 = Conv2D(64, (3, 3), padding='same')(down1)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
down2 = Conv2D(128, (3, 3), padding='same')(down1_pool)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2 = Conv2D(128, (3, 3), padding='same')(down2)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
# 32
down3 = Conv2D(256, (3, 3), padding='same')(down2_pool)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3 = Conv2D(256, (3, 3), padding='same')(down3)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
# 16
down4 = Conv2D(512, (3, 3), padding='same')(down3_pool)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4 = Conv2D(512, (3, 3), padding='same')(down4)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
# 8
center = Conv2D(1024, (3, 3), padding='same')(down4_pool)
center = BatchNormalization()(center)
center = Activation('relu')(center)
center = Conv2D(1024, (3, 3), padding='same')(center)
center = BatchNormalization()(center)
center = Activation('relu')(center)
up4 = UpSampling2D((2, 2))(center)
up4 = concatenate([down4, up4], axis=3)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
# 16
up3 = UpSampling2D((2, 2))(up4)
up3 = concatenate([down3, up3], axis=3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
# 32
up2 = UpSampling2D((2, 2))(up3)
up2 = concatenate([down2, up2], axis=3)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
# 64
up1 = UpSampling2D((2, 2))(up2)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
# 128
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up1)
model = Model(inputs=inputs, outputs=classify)
model.compile(optimizer=RMSprop(lr=0.0001),
loss=bce_dice_loss,
metrics=[dice_coeff])
return model
def gan_1(
input_img,
hidden_num=128,
no_of_pairs=5,
min_fea_map_H=8,
activation_fn=tf.nn.elu,
noise_dim=0,
z_num=64,
input_channel=3
): #x, hidden_num=3, no_of_pairs=4, min_fea_map_H=8, activation_fn=tf.nn.elu, noise_dim=0):
# Encoder
encoder_layer_list = []
x = Conv2D(hidden_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(input_img)
for idx in range(no_of_pairs):
# to increase number of filter by (filters)*(index+1) ex: 16, 32, 48 ...
channel_num = hidden_num * (idx + 1)
res = x
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = add([x, res])
encoder_layer_list.append(x)
if idx < no_of_pairs - 1:
x = Conv2D(hidden_num * (idx + 2),
kernel_size=3,
strides=2,
activation=activation_fn,
padding='same')(x)
# for flattening the layer
x = Flatten()(x)
# 20480
reshape_dim = int(np.prod([min_fea_map_H, min_fea_map_H / 2, channel_num]))
x = Reshape((1, reshape_dim))(x)
x = Dense(z_num, activation=None)(x)
# Decoder
reshape_dim = int(np.prod([min_fea_map_H, min_fea_map_H / 2, hidden_num]))
x = Dense(reshape_dim, activation=None)(x)
x = Reshape((min_fea_map_H, min_fea_map_H // 2, hidden_num))(x)
for idx in range(no_of_pairs):
x = Concatenate(axis=-1)(
[x, encoder_layer_list[no_of_pairs - 1 - idx]])
res = x
channel_num = x.get_shape().as_list()[-1]
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = add([x, res])
if idx < no_of_pairs - 1:
x = UpSampling2D(2)(x)
x = Conv2D(hidden_num * (no_of_pairs - idx - 1),
kernel_size=1,
strides=1,
activation=activation_fn,
padding='same')(x)
out = Conv2D(input_channel,
name='output_g1',
kernel_size=3,
strides=1,
activation=None,
padding='same')(x)
return out
from keras import Model
input = Input(shape=(28, 28, 1))
# encoder
conv1 = Conv2D(32, (3, 3), padding='same',
activation='relu')(input) # 1*28*28 --> 32*28*28
pool1 = MaxPooling2D(pool_size=(2, 2),
padding='same')(conv1) # 32*28*28 -->32*14*14
conv2 = Conv2D(32, (3, 3), padding='same',
activation='relu')(pool1) # 32*14*14 --> 32*14*14
pool2 = MaxPooling2D(pool_size=(2, 2),
padding='same')(conv2) # 32*14*14 --> 32*7*7
# decoder
conv3 = Conv2D(32, (3, 3), padding='same',
activation='relu')(pool2) # 32*7*7 --> 32*7*7
up1 = UpSampling2D((2, 2))(conv3) # 32*7*7-->32*14*14
conv4 = Conv2D(32, (3, 3), padding='same',
activation='relu')(up1) # 32*14*14 --> 32*14*14
up2 = UpSampling2D((2, 2))(conv4) # 32*14*14 --> 32*28*28
output = Conv2D(1, (3, 3), padding='same',
activation='sigmoid')(up2) # 32*28*28--> 1*28*28
model = Model(inputs=input, outputs=output)
model.compile(optimizer='adadelta', loss='binary_crossentropy')
history = model.fit(x_train_noise,
x_train_noise,
batch_size=128,
epochs=3,
verbose=2,
def SegNet():
model = Sequential()
#encoder
# model.add(Conv2D(64,(3,3),strides=(1,1),input_shape=(3,img_w,img_h),padding='same',activation='relu'))
model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w, img_h, 3), padding='same', activation='relu')) # for channels_last
model.add(BatchNormalization())
model.add(Conv2D(64,(3,3),strides=(1,1),padding='same',activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2,2)))
#(128,128)
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(64,64)
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(32,32)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(16,16)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(8,8)
#decoder
model.add(UpSampling2D(size=(2,2)))
#(16,16)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(32,32)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(64,64)
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(128,128)
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(256,256)
# model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=(3,img_w, img_h), padding='same', activation='relu'))
model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w, img_h, 3), padding='same', activation='relu')) # for channels_last
model.add(BatchNormalization())
model.add(Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(n_label, (1, 1), strides=(1, 1), padding='same'))
# model.add(Reshape((n_label,img_w*img_h)))
model.add(Reshape((img_w * img_h, n_label)))
#axis=1和axis=2互换位置，等同于np.swapaxes(layer,1,2)
# model.add(Permute((2,1)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
model.summary()
return model
