def conv2d_block(input, filters, strides=1, bn=True):
d = SeparableConv2D(filters, kernel_size=3, strides=strides, padding='same')(input)
if bn:
d = BatchNormalization(momentum=0.8)(d)
d = LeakyReLU(alpha=0.2)(d)
return d
def detect_model(classcnt):
model_input = Input(shape=(INPUT_HEIGHT, INPUT_WIDTH, 3))
x = model_input
x05 = Conv2D(64, (5, 5),
strides=(3, 4),
activation=ACTFUNC,
padding='same',
name='block0_conv1')(x)
x07 = Conv2D(64, (7, 7),
strides=(3, 4),
activation=ACTFUNC,
padding='same',
name='block0_conv2')(x)
x09 = Conv2D(64, (9, 9),
strides=(3, 4),
activation=ACTFUNC,
padding='same',
name='block0_conv3')(x)
x11 = Conv2D(64, (11, 11),
strides=(3, 4),
activation=ACTFUNC,
padding='same',
name='block0_conv4')(x)
x = layers.concatenate([x05, x07, x09, x11])
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False,
name='block1_conv1')(x)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
pred = Dense(3, activation='softmax', name='pred')(x)
#x = Flatten()(x)
#x = Dense(512, activation=ACTFUNC)(x)
out = Dense(classcnt, activation='softmax', name='out')(x)
model = Model(inputs=model_input, outputs=[pred, out])
return model
def mini_XCEPTION(input_shape, num_classes, l2_regularization=0.01):
regularization = l2(l2_regularization)
# base
img_input = Input(input_shape)
x = Conv2D(8, (3, 3),
strides=(1, 1),
kernel_regularizer=regularization,
use_bias=False)(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(8, (3, 3),
strides=(1, 1),
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# module 1
residual = Conv2D(16, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(16, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(16, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 2
residual = Conv2D(32, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(32, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(32, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 3
residual = Conv2D(64, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(64, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(64, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 4
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
x = Conv2D(
num_classes,
(3, 3),
# kernel_regularizer=regularization,
padding='same')(x)
x = GlobalAveragePooling2D()(x)
output = Activation('softmax', name='predictions')(x)
model = Model(img_input, output)
return model
def creatXception(data_info=None,Div=32,upsample=False,train=True,name='header_model'):
# build the network with ImageNet weights
inputShape = (data_info.IMG_ROW, data_info.IMG_COL, 3)
if upsample is True:
base_model = xception.Xception(input_shape=inputShape,Div=Div)
if train:
base_model.load_weights(data_info.base_model_weight_file)
print 'you chose upsample mode'
res_out = base_model.get_layer('block14_sepconv1_bn').output
residual = keras.layers.Conv2D(1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(res_out)
residual = keras.layers.BatchNormalization()(residual)
x = base_model.output
x = keras.layers.SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block15_sepconv1')(x)
x = keras.layers.BatchNormalization(name='block15_sepconv1_bn')(x)
x = keras.layers.MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='block15_pool')(x)
x = keras.layers.add([x, residual], name='block15_add')
x = keras.layers.Activation('relu', name='block15_sepconv1_act')(x)
x = keras.layers.SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block15_sepconv2')(x)
x = keras.layers.BatchNormalization(name='block15_sepconv2_bn')(x)
x = keras.layers.Activation('relu', name='block15_sepconv2_act')(x)
x = UpSampling2D((2, 2))(x)
x = keras.layers.concatenate([x, base_model.output])
x = SeparableConv2D(1024, (3, 3), use_bias=False, padding='same', name='up_conv0')(x)
x = BatchNormalization(name='up_conv0_bn')(x)
x = Activation('relu', name='up_conv0_act')(x)
if data_info.pixel_level == 3 or data_info.pixel_level == 2 :
x = UpSampling2D((2, 2))(x)
x = keras.layers.concatenate([x, base_model.get_layer('block13_sepconv2_act').output])
x = SeparableConv2D(1024, (3, 3), use_bias=False, padding='same', name='up_conv1')(x)
x = BatchNormalization(name='up_conv1_bn')(x)
x = Activation('relu', name='up_conv1_act')(x)
if data_info.pixel_level == 2 :
x = UpSampling2D((2, 2))(x)
x = keras.layers.concatenate([x, base_model.get_layer('block4_sepconv2_act').output])
x = SeparableConv2D(1024, (3, 3), use_bias=False, padding='same', name='up_conv2')(x)
x = BatchNormalization(name='up_conv2_bn')(x)
x = Activation('relu', name='up_conv2_act')(x)
x = Dropout(0.5)(x)
x = Conv2D(256, (1, 1), use_bias=False, name='out_conv1')(x)
x = Dropout(0.5)(x)
x = Conv2D(256, (1, 1), use_bias=False, name='out_conv2')(x)
x = Dropout(0.5)(x)
else:
base_model = xception.Xception(weights='imagenet', input_shape=inputShape,Div=Div)
data_info.base_model=base_model
x = base_model.output
#x = Dropout(0.5)(x)
x = Conv2D(256, (1, 1), use_bias=False, name='out_conv1')(x)
#x = Dropout(0.5)(x)
header_model = Model(inputs=base_model.input, outputs=x, name=name)
if train:
x = header_model.output
x = Conv2D(data_info.class_num, (1, 1), use_bias=False, name='conv_out')(x)
seg_output = Activation('softmax', name='seg_out')(x)
x = GlobalAveragePooling2D()(x)
main_output = Activation('softmax', name='main_out')(x)
#with tf.device('/cpu:0'):
model = Model(inputs=header_model.input, outputs=[main_output,seg_output], name='train_model')
return model
else:
return header_model
dilation_rate=2,
name='res5c_branch2c')(x)
y = _shortcut(y, x)
Resnet = y
network = ASPP(Resnet)
# print(network.shape)
network = UpSampling2D(size=(2, 2), name='US1')(network)
network = Conv2D(64, (3, 3),
activation='relu',
padding='same',
strides=(1, 1),
name='up1')(network)
# print(network.shape)
Low_f8x = SeparableConv2D(48, (1, 1), padding='same')(x_down2)
def concat(listt):
return K.concatenate(listt, axis=-1)
combine_1 = [Low_f8x, network]
network = Lambda(concat)(combine_1)
network = UpSampling2D(size=(2, 2), name='US2')(network)
network = Conv2D(64, (3, 3),
activation='relu',
padding='same',
strides=(1, 1),
use_bias=False)(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(8, (3, 3),
strides=(1, 1),
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# module 1
residual = Conv2D(16, (1, 1), strides=(2, 2), padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(16, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(16, (3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 2
residual = Conv2D(32, (1, 1), strides=(2, 2), padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
def getmodel(image_shape):
#part 1
img_input = Input(shape=image_shape)
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False)(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, (3, 3), strides=(2, 2), use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
#this part gets repeated 4 times
residual = Conv2D(128, (1, 1), strides=(2, 2),\
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
#2
residual = Conv2D(128, (1, 1), strides=(2, 2),\
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
#3
residual = Conv2D(128, (1, 1), strides=(2, 2),\
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
#4
residual = Conv2D(128, (1, 1), strides=(2, 2),\
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
x = Conv2D(64, (2, 2), strides=(2, 2), use_bias=False)(x)
x = GlobalAveragePooling2D()(x)
output = Dense(1, activation='softmax', name='predictions')(x)
model = Model(inputs=img_input, outputs=output)
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])
return model
def Xception_model(include_top=False,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
attention_module=None,
**kwargs):
"""Instantiates the Xception architecture.
Optionally loads weights pre-trained on ImageNet.
Note that the data format convention used by the model is
the one specified in your Keras config at `~/.keras/keras.json`.
Note that the default input image size for this model is 299x299.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor
(i.e. output of `Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(299, 299, 3)`.
It should have exactly 3 inputs channels,
and width and height should be no smaller than 71.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True,
and if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
global backend, layers, models, keras_utils
backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError(
'If using `weights` as `"imagenet"` with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=71,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1
x = Convolution2D(32, (3, 3),
strides=(2, 2),
use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(axis=channel_axis, name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Convolution2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(axis=channel_axis, name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Convolution2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization(axis=channel_axis)(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(axis=channel_axis, name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(axis=channel_axis, name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = add([x, residual])
if attention_module is not None:
x = attach_attention_module(x, attention_module)
residual = Convolution2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization(axis=channel_axis)(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(axis=channel_axis, name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(axis=channel_axis, name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = add([x, residual])
if attention_module is not None:
x = attach_attention_module(x, attention_module)
residual = Convolution2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization(axis=channel_axis)(residual)
if attention_module is not None:
residual = attach_attention_module(residual, attention_module)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(axis=channel_axis, name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(axis=channel_axis, name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(axis=channel_axis,
name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(axis=channel_axis,
name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(axis=channel_axis,
name=prefix + '_sepconv3_bn')(x)
if attention_module is not None:
x = attach_attention_module(x, attention_module)
x = add([x, residual])
residual = Convolution2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization(axis=channel_axis)(residual)
if attention_module is not None:
residual = attach_attention_module(residual, attention_module)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(axis=channel_axis, name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(axis=channel_axis, name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = add([x, residual])
x = SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = BatchNormalization(axis=channel_axis, name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = BatchNormalization(axis=channel_axis, name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
#x = BatchNormalization(axis=channel_axis, momentum=0.1, epsilon=1e-5, gamma_initializer='uniform')(x)
#x = Activation('relu')(x)
#x = GlobalAveragePooling2D()(x)
x = GlobalAveragePooling2D()(x)
outputs = Dense(classes,
activation='relu',
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(x)
model = models.Model(inputs, outputs, name='xception')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = keras_utils.get_file(
'xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models',
file_hash='0a58e3b7378bc2990ea3b43d5981f1f6')
else:
weights_path = keras_utils.get_file(
'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='b0042744bf5b25fce3cb969f33bebb97')
model.load_weights(weights_path)
if backend.backend() == 'theano':
keras_utils.convert_all_kernels_in_model(model)
elif weights is not None:
model.load_weights(weights)
return model
def Xception(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
if K.backend() != 'tensorflow':
raise RuntimeError('The Xception model is only available with '
'the TensorFlow backend.')
if K.image_data_format() != 'channels_last':
warnings.warn(
'The Xception model is only available for the '
'input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height). '
'You should set `image_data_format="channels_last"` in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
K.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=71,
data_format=K.image_data_format(),
require_flatten=include_top)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
model = Model(inputs, x, name='xception')
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH,
cache_subdir='models')
model.load_weights(weights_path)
if old_data_format:
K.set_image_data_format(old_data_format)
return model
# Model 생성-----------------------------------------------------------
# 직접 Training과 Transfer Learning 두 가지를 진행
# FC 추가, CNN 추가 등 조건을 바꿔가며 실험
EfficientNetB0 = efn.EfficientNetB0(weights=None,
include_top=False,
input_shape=(224, 224, 3))
EfficientNetB0.load_weights(
'../input/efficientnet-keras-weights-b0b5/efficientnet-b0_imagenet_1000_notop.h5'
)
inputs = Input(shape=(224, 224, 3))
x = EfficientNetB0(inputs)
residual = Conv2D(2048, (1, 1), strides=(2, 2), padding='same')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
strides=1,
depth_multiplier=1,
depthwise_regularizer=l2(1e-15),
pointwise_regularizer=l2(1e-15))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
strides=1,
depth_multiplier=1,
depthwise_regularizer=l2(1e-15),
pointwise_regularizer=l2(1e-15))(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
x = Add()([x, residual])
residual1 = Conv2D(2304, (1, 1), strides=(2, 2), padding='same')(x)
x = SeparableConv2D(2304, (3, 3),
def custom_model(learning_rate: float,
decay: float = 0,
dropout_rate: float = 0.3):
model = Sequential()
# YUV conversion and normalization
model.add(
Lambda(yuv_conversion, input_shape=(160, 320, 3), name='rgb_to_yuv'))
model.add(Lambda(lambda x: x * 2 - 1, name='normalize'))
# Crop the image to remove the sky and car hood
model.add(
Cropping2D(cropping=((CROP_TOP_BIG, CROP_BOTTOM_BIG), (0, 0)),
name='crop'))
model.add(
SeparableConv2D(24, (5, 5),
strides=(3, 3),
padding='valid',
depth_multiplier=16,
name='conv_1'))
model.add(PReLU(name='conv_1_prelu'))
model.add(
SeparableConv2D(36, (5, 5),
strides=(3, 3),
padding='valid',
depth_multiplier=9,
name='conv_2'))
model.add(PReLU(name='conv_2_prelu'))
model.add(
SeparableConv2D(48, (3, 3),
strides=(2, 2),
padding='valid',
depth_multiplier=6,
name='conv_3'))
model.add(PReLU(name='conv_3_prelu'))
model.add(
SeparableConv2D(64, (2, 2),
strides=(2, 2),
padding='valid',
depth_multiplier=9,
name='conv_4'))
model.add(PReLU(name='conv_4_prelu'))
model.add(Flatten())
model.add(Dropout(rate=dropout_rate))
model.add(Dense(100, name='fc_1'))
model.add(PReLU(name='fc_1_prelu'))
model.add(Dense(50, name='fc_2'))
model.add(PReLU(name='fc_2_prelu'))
model.add(Dense(10, name='fc_3'))
model.add(PReLU(name='fc_3_prelu'))
model.add(Dense(1, name='angle'))
adam = Adam(lr=learning_rate, decay=decay)
model.compile(optimizer=adam, loss='mse')
return model
def unet(vis):
input_size = (256, 256, 1)
inputs = Input(input_size)
#Encoder
conv1_1 = SeparableConv2D(64, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(inputs)
conv1_2 = SeparableConv2D(64, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv1_1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1_2)
conv2_1 = SeparableConv2D(128, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(pool1)
conv2_2 = SeparableConv2D(128, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv2_1)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2_2)
conv3_1 = SeparableConv2D(256, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(pool2)
conv3_2 = SeparableConv2D(256, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv3_1)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3_2)
conv4_1 = SeparableConv2D(512, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(pool3)
conv4_2 = SeparableConv2D(512, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv4_1)
drop4_2 = SpatialDropout2D(0.5)(conv4_2)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4_2)
conv5_1 = SeparableConv2D(1024, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(pool4)
conv5_2 = SeparableConv2D(1024, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv5_1)
drop5_2 = SpatialDropout2D(0.5)(conv5_2)
#Decoder
up6_1 = Conv2DTranspose(512, (2, 2),
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer='he_normal')(drop5_2)
up6_2 = concatenate([drop4_2, up6_1], axis=3)
conv6_1 = SeparableConv2D(512, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(up6_2)
conv6_2 = SeparableConv2D(512, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv6_1)
up7_1 = Conv2DTranspose(256, (2, 2),
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv6_2)
up7_2 = concatenate([conv3_2, up7_1], axis=3)
conv7_1 = SeparableConv2D(256, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(up7_2)
conv7_2 = SeparableConv2D(256, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv7_1)
up8_1 = Conv2DTranspose(128, (2, 2),
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv7_2)
up8_2 = concatenate([conv2_2, up8_1], axis=3)
conv8_1 = SeparableConv2D(128, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(up8_2)
conv8_2 = SeparableConv2D(128, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv8_1)
up9_1 = Conv2DTranspose(64, (2, 2),
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv8_2)
up9_2 = concatenate([conv1_2, up9_1], axis=3)
conv9_1 = SeparableConv2D(64, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(up9_2)
conv9_2 = SeparableConv2D(64, (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal')(conv9_1)
conv9_3 = SeparableConv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9_2)
conv10 = SeparableConv2D(1, 1, activation='sigmoid')(conv9_3)
if (vis):
outputs = [
conv1_1, conv1_2, pool1, conv2_1, conv2_2, pool2, conv3_1, conv3_2,
pool3, conv4_1, conv4_2, drop4_2, pool4, conv5_1, conv5_2, drop5_2,
up6_1, up6_2, conv6_1, conv6_2, up7_1, up7_2, conv7_1, conv7_2,
up8_1, up8_2, conv8_1, conv8_2, up9_1, up9_2, conv9_1, conv9_2,
conv9_3, conv10
]
model = Model(inputs=[inputs], outputs=outputs)
model.summary()
else:
model = Model(inputs=[inputs], outputs=[conv10])
model.summary()
model.compile(optimizer=Adam(lr=1e-4),
loss=dice_coef_loss,
metrics=[dice_coef, 'accuracy'])
return model
def unet_1024(img_rows,
img_cols,
num_img_channels,
num_mask_channels,
train_batch_norm=True):
inputs = Input(shape=(img_rows, img_cols, num_img_channels))
# 1024
with K.name_scope('Down512'):
down0b = Conv2D(8, (3, 3), padding='same')(inputs)
down0b = BatchNormalization()(down0b, training=train_batch_norm)
down0b = Activation('relu')(down0b)
down0b = Conv2D(8, (3, 3), padding='same')(down0b)
down0b = BatchNormalization()(down0b, training=train_batch_norm)
down0b = Activation('relu')(down0b)
down0b_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0b)
# 512
with K.name_scope('Down256'):
down0a = SeparableConv2D(16, (3, 3), padding='same')(down0b_pool)
down0a = BatchNormalization()(down0a, training=train_batch_norm)
down0a = Activation('relu')(down0a)
down0a = SeparableConv2D(16, (3, 3), padding='same')(down0a)
down0a = BatchNormalization()(down0a, training=train_batch_norm)
down0a = Activation('relu')(down0a)
down0a_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0a)
# 256
with K.name_scope('Down128'):
down0 = SeparableConv2D(32, (3, 3), padding='same')(down0a_pool)
down0 = BatchNormalization()(down0, training=train_batch_norm)
down0 = Activation('relu')(down0)
down0 = SeparableConv2D(32, (3, 3), padding='same')(down0)
down0 = BatchNormalization()(down0, training=train_batch_norm)
down0 = Activation('relu')(down0)
down0_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0)
# 128
with K.name_scope('Down64'):
down1 = SeparableConv2D(64, (3, 3), padding='same')(down0_pool)
down1 = BatchNormalization()(down1, training=train_batch_norm)
down1 = Activation('relu')(down1)
down1 = SeparableConv2D(64, (3, 3), padding='same')(down1)
down1 = BatchNormalization()(down1, training=train_batch_norm)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
with K.name_scope('Down32'):
down2 = SeparableConv2D(128, (3, 3), padding='same')(down1_pool)
down2 = BatchNormalization()(down2, training=train_batch_norm)
down2 = Activation('relu')(down2)
down2 = SeparableConv2D(128, (3, 3), padding='same')(down2)
down2 = BatchNormalization()(down2, training=train_batch_norm)
down2 = Activation('relu')(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
# 32
with K.name_scope('Down16'):
down3 = SeparableConv2D(256, (3, 3), padding='same')(down2_pool)
down3 = BatchNormalization()(down3, training=train_batch_norm)
down3 = Activation('relu')(down3)
down3 = SeparableConv2D(256, (3, 3), padding='same')(down3)
down3 = BatchNormalization()(down3, training=train_batch_norm)
down3 = Activation('relu')(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
# 16
with K.name_scope('Down8'):
down4 = SeparableConv2D(512, (3, 3), padding='same')(down3_pool)
down4 = BatchNormalization()(down4, training=train_batch_norm)
down4 = Activation('relu')(down4)
down4 = SeparableConv2D(512, (3, 3), padding='same')(down4)
down4 = BatchNormalization()(down4, training=train_batch_norm)
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
# 8
with K.name_scope('Center'):
center = SeparableConv2D(1024, (3, 3), padding='same')(down4_pool)
center = BatchNormalization()(center, training=train_batch_norm)
center = Activation('relu')(center)
center = SeparableConv2D(1024, (3, 3), padding='same')(center)
center = BatchNormalization()(center, training=train_batch_norm)
center = Activation('relu')(center)
# center
with K.name_scope('Up16'):
up4 = UpSampling2D((2, 2))(center)
up4 = concatenate([down4, up4], axis=3)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4, training=train_batch_norm)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4, training=train_batch_norm)
up4 = Activation('relu')(up4)
# 16
with K.name_scope('Up32'):
up3 = UpSampling2D((2, 2))(up4)
up3 = concatenate([down3, up3], axis=3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3, training=train_batch_norm)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3, training=train_batch_norm)
up3 = Activation('relu')(up3)
# 32
with K.name_scope('Up64'):
up2 = UpSampling2D((2, 2))(up3)
up2 = concatenate([down2, up2], axis=3)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2, training=train_batch_norm)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2, training=train_batch_norm)
up2 = Activation('relu')(up2)
# 64
with K.name_scope('Up128'):
up1 = UpSampling2D((2, 2))(up2)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1, training=train_batch_norm)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1, training=train_batch_norm)
up1 = Activation('relu')(up1)
# 128
with K.name_scope('Up256'):
up0 = UpSampling2D((2, 2))(up1)
up0 = concatenate([down0, up0], axis=3)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0, training=train_batch_norm)
up0 = Activation('relu')(up0)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0, training=train_batch_norm)
up0 = Activation('relu')(up0)
# 256
with K.name_scope('Up512'):
up0a = UpSampling2D((2, 2))(up0)
up0a = concatenate([down0a, up0a], axis=3)
up0a = Conv2D(16, (3, 3), padding='same')(up0a)
up0a = BatchNormalization()(up0a, training=train_batch_norm)
up0a = Activation('relu')(up0a)
up0a = Conv2D(16, (3, 3), padding='same')(up0a)
up0a = BatchNormalization()(up0a, training=train_batch_norm)
up0a = Activation('relu')(up0a)
# 512
with K.name_scope('Up1024'):
up0b = UpSampling2D((2, 2))(up0a)
up0b = concatenate([down0b, up0b], axis=3)
up0b = Conv2D(8, (3, 3), padding='same')(up0b)
up0b = BatchNormalization()(up0b, training=train_batch_norm)
up0b = Activation('relu')(up0b)
up0b = Conv2D(8, (3, 3), padding='same')(up0b)
up0b = BatchNormalization()(up0b, training=train_batch_norm)
up0b = Activation('relu')(up0b)
# 1024
classify = Conv2D(num_mask_channels, (1, 1), activation='sigmoid')(up0b)
model = Model(inputs=inputs, outputs=classify)
return model
def nn_base(input_tensor=None, trainable=False):
# Determine proper input shape
if K.image_dim_ordering() == 'th':
input_shape = (3, None, None)
else:
input_shape = (None, None, 3)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if K.image_dim_ordering() == 'tf':
bn_axis = 3
else:
bn_axis = 1
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = add([x, residual])
residual = Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = add([x, residual])
residual = Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = add([x, residual])
return x
input_shape = (patch_size, patch_size, 3)
train, test, valid = load_data_to_labels(label_path,
precision,
train_fraction=0.7,
test_fraction=0.15)
train_len = len(train)
test_len = len(test)
valid_len = len(valid)
results.write('Input data: train_len: ' + str(train_len) + ", test_len: " +
str(test_len) + ", valid_len: " + str(valid_len) + lbreak)
model = Sequential()
model.add(
SeparableConv2D(32, 3, activation='relu', input_shape=input_shape))
model.add(SeparableConv2D(64, 3, activation='relu'))
model.add(Dropout(0.5))
#model.add(BatchNormalization())
model.add(MaxPooling2D(2))
model.add(SeparableConv2D(64, 3, activation='relu'))
model.add(SeparableConv2D(128, 3, activation='relu'))
model.add(Dropout(0.5))
#model.add(BatchNormalization())
model.add(MaxPooling2D(2))
model.add(SeparableConv2D(64, 3, activation='relu'))
model.add(SeparableConv2D(128, 3, activation='relu'))
model.add(Dropout(0.5))
#model.add(BatchNormalization())
model.add(MaxPooling2D(2))
#model.add(SeparableConv2D(64, 3, activation='relu'))
def create_model():
train_gen = ImageDataGenerator()
valid_gen = ImageDataGenerator()
train_generator = train_gen.flow_from_directory(TRAIN_DATA_PATH,
IMAGE_SIZE,
shuffle=True,
batch_size=BATCH_SIZE,
color_mode='grayscale')
valid_generator = valid_gen.flow_from_directory(VALID_DATA_PATH,
IMAGE_SIZE,
batch_size=BATCH_SIZE,
color_mode='grayscale')
inputs = Input((*IMAGE_SIZE, 1))
x_input = Lambda(my_preprocess)(inputs)
# block1
x = Conv2D(64, (3, 3),
input_shape=(*IMAGE_SIZE, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='block1_conv1')(x_input)
x = Conv2D(64, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block1_conv2')(x)
x = MaxPooling2D((2, 2),
strides=(2, 2),
padding='same',
name='block1_pool')(x)
# block2
x = Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block2_conv1')(x)
x = Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block2_conv2')(x)
x = MaxPooling2D((2, 2),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
# block3
x = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block3_conv1')(x)
x = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block3_conv2')(x)
x = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block3_conv3')(x)
x = MaxPooling2D((2, 2),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
# side1
x_side1 = SeparableConv2D(512, (3, 3),
padding='same',
use_bias=False,
name='side1_sepconv1')(x)
x_side1 = BatchNormalization(name='side1_bn1')(x_side1)
x_side1 = Activation('relu', name='side1_act1')(x_side1)
x_side1 = SeparableConv2D(512, (3, 3),
padding='same',
use_bias=False,
name='side1_sepconv2')(x_side1)
x_side1 = BatchNormalization(name='side1_bn2')(x_side1)
x_side1 = Activation('relu', name='side1_act2')(x_side1)
x_side1 = MaxPooling2D((2, 2),
strides=(2, 2),
padding='same',
name='side1_pool')(x_side1)
x_side1 = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='side1_sepconv3')(x_side1)
x_side1 = BatchNormalization(name='side1_bn3')(x_side1)
x_side1 = Activation('relu', name='side1_act3')(x_side1)
x_side1 = SeparableConv2D(728, (3, 3),
padding='same',
activation='relu',
name='side1_sepconv4')(x_side1)
x_side1 = GlobalAveragePooling2D(name='side1_gap')(x_side1)
# side2
x_side2_1_1 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side2_1_conv1')(x)
x_side2_1_2 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side2_2_conv1')(x)
x_side2_1_2 = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='side2_2_conv2')(x_side2_1_2)
x_side2_1_3 = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='side2_3_conv1')(x)
x_side2_1_3 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side2_3_conv2')(x_side2_1_3)
x_side2_1 = keras.layers.concatenate(
[x_side2_1_1, x_side2_1_2, x_side2_1_3])
x_side2_2_1 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side3_1_conv1')(x_side2_1)
x_side2_2_2 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side3_2_conv1')(x_side2_1)
x_side2_2_2 = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='side3_2_conv2')(x_side2_2_2)
x_side2_2_3 = Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='side3_3_conv1')(x_side2_1)
x_side2_2_3 = Conv2D(256, (1, 1),
strides=(1, 1),
padding='same',
activation='relu',
name='side3_3_conv2')(x_side2_2_3)
x_side2_2 = keras.layers.concatenate(
[x_side2_2_1, x_side2_2_2, x_side2_2_3])
x_side2 = GlobalAveragePooling2D(name='side2_gap')(x_side2_2)
# block4
x = Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block4_conv1')(x)
x = Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block4_conv2')(x)
x = Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
name='block4_conv3')(x)
x = GlobalAveragePooling2D(name='gap')(x)
x = keras.layers.concatenate([x, x_side1, x_side2])
x = Dropout(DROP_RATE, name='dropout1')(x)
predictions = Dense(CLASS_NUM, activation='softmax', name='dense1')(x)
model = Model(inputs=inputs, outputs=predictions)
model.summary()
plot_model(model,
to_file=os.path.join(RESULT_PATH, 'my_model.png'),
show_shapes=True)
check_point = ModelCheckpoint(monitor='val_loss',
filepath=os.path.join(
MODEL_PATH, MODEL_NAME),
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto')
# early stopping
early_stopping = EarlyStopping(monitor='val_loss',
patience=EARLY_STOPPING_PATIENCE,
verbose=0,
mode='auto')
# reduce lr
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=REDUCE_LR_PATIENCE,
verbose=0,
mode='auto',
epsilon=0.0001,
cooldown=0,
min_lr=0)
# 创建一个 LossHistory 实例
history = LossHistory()
# compile
model.compile(optimizer=adam(lr=LEARNING_RATE),
loss='binary_crossentropy',
metrics=['accuracy'])
# fit
model.fit_generator(train_generator,
steps_per_epoch=train_generator.samples // BATCH_SIZE,
epochs=EPOCHS,
validation_data=valid_generator,
validation_steps=valid_generator.samples // BATCH_SIZE,
callbacks=[check_point, early_stopping, history])
# 绘制 loss 曲线和 batch 曲线
history.loss_plot('batch', os.path.join(RESULT_PATH, 'my_loss_batch.png'))
history.acc_plot('batch', os.path.join(RESULT_PATH, 'my_batch.png'))
history.loss_plot('epoch', os.path.join(RESULT_PATH, 'my_loss_epoch.png'))
history.acc_plot('epoch', os.path.join(RESULT_PATH, 'my_acc_epoch.png'))
K.clear_session()
def Xception(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
factor=8):
"""Instantiates the Xception architecture.
Optionally loads weights pre-trained
on ImageNet. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
data format `(width, height, channels)`.
You should set `image_data_format="channels_last"` in your Keras config
located at ~/.keras/keras.json.
Note that the default input image size for this model is 299x299.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(299, 299, 3)`.
It should have exactly 3 inputs channels,
and width and height should be no smaller than 71.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
if K.backend() != 'tensorflow':
raise RuntimeError('The Xception model is only available with '
'the TensorFlow backend.')
if K.image_data_format() != 'channels_last':
warnings.warn(
'The Xception model is only available for the '
'input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height). '
'You should set `image_data_format="channels_last"` in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
K.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
# Determine proper input shape
input_shape = input_shape
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Conv2D(32 // factor, (3, 3),
strides=(2, 2),
use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64 // factor, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128 // factor, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128 // factor, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128 // factor, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = add([x, residual])
residual = Conv2D(256 // factor, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256 // factor, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256 // factor, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = add([x, residual])
residual = Conv2D(728 // factor, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728 // factor, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728 // factor, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = add([x, residual]) # for i in range(8):
# residual = x
# prefix = 'block' + str(i + 5)
#
# x = Activation('relu', name=prefix + '_sepconv1_act')(x)
# x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1')(x)
# x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
# x = Activation('relu', name=prefix + '_sepconv2_act')(x)
# x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2')(x)
# x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
# x = Activation('relu', name=prefix + '_sepconv3_act')(x)
# x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x)
# x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
#
# x = add([x, residual])
#
# residual = Conv2D(1024, (1, 1), strides=(2, 2),
# padding='same', use_bias=False)(x)
# residual = BatchNormalization()(residual)
#
# x = Activation('relu', name='block13_sepconv1_act')(x)
# x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x)
# x = BatchNormalization(name='block13_sepconv1_bn')(x)
# x = Activation('relu', name='block13_sepconv2_act')(x)
# x = SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x)
# x = BatchNormalization(name='block13_sepconv2_bn')(x)
#
# x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x)
# x = add([x, residual])
#
# x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x)
# x = BatchNormalization(name='block14_sepconv1_bn')(x)
# x = Activation('relu', name='block14_sepconv1_act')(x)
#
# x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x)
# x = BatchNormalization(name='block14_sepconv2_bn')(x)
# x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='xception')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path)
if old_data_format:
K.set_image_data_format(old_data_format)
return model
def ReductionCell(hi,
h_i1sub,
filter_i,
filter_o,
stride=2,
name="NAS",
is_tail=False):
"""
adjust feature size & channel size
"""
h_i1sub = _adjust_block(h_i1sub, hi, filter_o, 0, name)
hi = Conv2D(filter_o, (1, 1),
padding='same',
name='%s_hi_align' % name,
trainable=trainable,
kernel_regularizer=OrthLocalReg2D)(hi)
hi = Activation('relu', name='%s_hi_align_relu' % name)(hi)
hi = BatchNormalization(name='%s_hi_align_bn' % name)(hi)
"""
SubLayer 1
"""
l = SeparableConv2D(filter_o, (5, 5),
strides=(stride, stride),
padding='same',
name='%s_sep5x5_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(hi)
l = Activation('relu', name='%s_sep5x5_1_relu' % name)(l)
l = BatchNormalization(name='%s_sep5x5_1_bn' % name)(l)
if h_i1sub is not None:
l_1sub = SeparableConv2D(
filter_o, (7, 7),
strides=(stride, stride),
padding='same',
name='%s_sep7x7_sub_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub = Activation('relu',
name='%s_sep7x7_sub_1_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep7x7_sub_1_bn' %
name)(l_1sub)
add1 = Add()([l, l_1sub])
else:
add1 = l
l = SeparableConv2D(filter_o, (3, 3),
strides=(stride, stride),
padding='same',
name='%s_sep3x3_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(hi)
l = Activation('relu', name='%s_sep3x3_1_relu' % name)(l)
l = BatchNormalization(name='%s_sep3x3_1_bn' % name)(l)
if h_i1sub is not None:
l_1sub = SeparableConv2D(
filter_o, (7, 7),
strides=(stride, stride),
padding='same',
name='%s_sep7x7_sub_2' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub = Activation('relu',
name='%s_sep7x7_sub_2_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep7x7_sub_2_bn' %
name)(l_1sub)
add2 = Add()([l, l_1sub])
else:
add2 = l
l = AveragePooling2D(pool_size=(3, 3),
strides=(stride, stride),
padding='same')(hi)
if filter_i != filter_o:
l = Conv2D(filter_o, (1, 1),
strides=(1, 1),
padding='same',
name='%s_sep1x1_align' % name,
trainable=trainable)(l)
l = Activation('relu', name='%s_sep1x1_align_relu' % name)(l)
l = BatchNormalization(name='%s_sep1x1_align_bn' % name)(l)
if h_i1sub is not None:
l_1sub = SeparableConv2D(
filter_o, (5, 5),
strides=(stride, stride),
padding='same',
name='%s_sep5x5_sub_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub = Activation('relu',
name='%s_sep5x5_sub_1_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep5x5_sub_1_bn' %
name)(l_1sub)
add3 = Add()([l, l_1sub])
else:
add3 = l
"""
SubLayer 2
"""
l = MaxPooling2D(pool_size=(3, 3),
strides=(stride, stride),
padding='same')(hi)
if filter_i != filter_o:
l = Conv2D(filter_o, (1, 1),
strides=(1, 1),
padding='same',
name='%s_sep1x1_align_2' % name,
trainable=trainable)(l)
l = Activation('relu', name='%s_sep1x1_align_2_relu' % name)(l)
l = BatchNormalization(name='%s_sep1x1_align_2_bn' % name)(l)
l_1sub = SeparableConv2D(filter_o, (3, 3),
padding='same',
name='%s_sep3x3_2' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(add1)
l_1sub = Activation('relu', name='%s_sep3x3_2_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep3x3_2_bn' % name)(l_1sub)
add4 = Add()([l, l_1sub])
l = AveragePooling2D(pool_size=(3, 3), strides=(1, 1),
padding='same')(add1)
add5 = Add()([l, add2])
result = concatenate([add3, add4, add5])
if is_tail:
result = Conv2D(filter_o, (1, 1),
strides=(1, 1),
padding='same',
name='%s_result1x1_align' % name,
trainable=trainable,
kernel_regularizer=OrthLocalReg2D)(result)
result = Activation('relu',
name='%s_result1x1_align_relu' % name)(result)
result = BatchNormalization(name='%s_result1x1_align_bn' %
name)(result)
return result
def sepconv(n, f, k, s=1):
""" Depthwise separable convolution layer """
n = SeparableConv2D(f, k, padding='same', activation=acti,
strides=s)(n)
return n
def NormalCell(hi,
h_i1sub,
filter_i,
filter_o,
stride=1,
name="NAS",
use_deform=False,
is_tail=False):
"""
adjust feature size & channel size
"""
hi = Conv2D(filter_o, (1, 1),
padding='same',
name='%s_hi_align' % name,
trainable=trainable,
kernel_regularizer=OrthLocalReg2D)(hi)
hi = Activation('relu', name='%s_hi_align_relu' % name)(hi)
hi = BatchNormalization(name='%s_hi_align_bn' % name)(hi)
if use_deform:
hi = SepConvOffset2D(filter_o,
name='%s_deform_conv' % name)(hi,
use_resam=True)
h_i1sub = _adjust_block(h_i1sub, hi, filter_o, 0, name)
"""
SubLayer
"""
l = SeparableConv2D(filter_o, (3, 3),
padding='same',
name='%s_sep3x3_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(hi)
l = Activation('relu', name='%s_sep3x3_1_relu' % name)(l)
l = BatchNormalization(name='%s_sep3x3_1_bn' % name)(l)
add1 = Add()([l, hi])
l = SeparableConv2D(filter_o, (5, 5),
padding='same',
name='%s_sep5x5_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(hi)
l = Activation('relu', name='%s_sep5x5_1_relu' % name)(l)
l = BatchNormalization(name='%s_sep5x5_1_bn' % name)(l)
if h_i1sub is not None:
l_1sub = SeparableConv2D(
filter_o, (3, 3),
padding='same',
name='%s_sep3x3_sub_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub = Activation('relu',
name='%s_sep3x3_sub_1_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep3x3_sub_1_bn' %
name)(l_1sub)
add2 = Add()([l, l_1sub])
else:
add2 = l
l = SeparableConv2D(filter_o, (3, 3),
padding='same',
name='%s_sep3x3_2' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(hi)
l = Activation('relu', name='%s_sep3x3_2_relu' % name)(l)
l = BatchNormalization(name='%s_sep3x3_2_bn' % name)(l)
if h_i1sub is not None:
l_1sub = SeparableConv2D(
filter_o, (5, 5),
padding='same',
name='%s_sep5x5_sub_1' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub = Activation('relu',
name='%s_sep5x5_sub_1_relu' % name)(l_1sub)
l_1sub = BatchNormalization(name='%s_sep5x5_sub_1_bn' %
name)(l_1sub)
add3 = Add()([l, l_1sub])
else:
add3 = l
if h_i1sub is not None:
avg_p1 = AveragePooling2D(pool_size=(3, 3),
strides=(stride, stride),
padding='same')(h_i1sub)
# avg_p2 = AveragePooling2D(pool_size=(3, 3), strides=(stride, stride), padding='same')(h_i1sub)
# add4 = Add()([avg_p1, avg_p2])
add4 = avg_p1
l_1sub_1 = SeparableConv2D(
filter_o, (3, 3),
padding='same',
name='%s_sep3x3_sub_2' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub_1 = Activation('relu',
name='%s_sep3x3_sub_2_relu' % name)(l_1sub_1)
l_1sub_1 = BatchNormalization(name='%s_sep3x3_sub_2_bn' %
name)(l_1sub_1)
l_1sub_2 = SeparableConv2D(
filter_o, (5, 5),
padding='same',
name='%s_sep5x5_sub_2' % name,
trainable=trainable,
depthwise_regularizer=OrthLocalRegSep2D)(h_i1sub)
l_1sub_2 = Activation('relu',
name='%s_sep5x5_sub_2_relu' % name)(l_1sub_2)
l_1sub_2 = BatchNormalization(name='%s_sep5x5_sub_2_bn' %
name)(l_1sub_2)
add5 = Add()([l_1sub_1, l_1sub_2])
result = concatenate([add1, add2, add3, add4, add5])
if is_tail:
result = Conv2D(filter_o, (1, 1),
strides=(1, 1),
padding='same',
name='%s_result1x1_align' % name,
trainable=trainable,
kernel_regularizer=OrthLocalReg2D)(result)
result = Activation('relu',
name='%s_result1x1_align_relu' %
name)(result)
result = BatchNormalization(name='%s_result1x1_align_bn' %
name)(result)
return result
else:
result = concatenate([add1, add2, add3])
if is_tail:
result = Conv2D(filter_o, (1, 1),
strides=(1, 1),
padding='same',
name='%s_result1x1_align' % name,
trainable=trainable,
kernel_regularizer=OrthLocalReg2D)(result)
result = Activation('relu',
name='%s_result1x1_align_relu' %
name)(result)
result = BatchNormalization(name='%s_result1x1_align_bn' %
name)(result)
return result
def xception_base_network(input, padding=False):
weights_path = get_file('xception_weights.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
#x = Lambda(lambda x: x*2-1)(img_input)
blocks = []
x = Conv2D(32, (3, 3), padding='same', use_bias=False,
name='block1_conv1')(input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
blocks.insert(0, x)
x = Conv2D(64, (3, 3),
strides=(2, 2),
use_bias=False,
name='block1_conv2',
padding='same')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
blocks.insert(0, x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
blocks.insert(0, x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
blocks.insert(0, x)
x = layers.add([x, residual])
residual = Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
blocks.insert(0, x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
blocks.insert(0, x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
x = GlobalAveragePooling2D()(x)
model = Model(input, x, name='xception')
model.load_weights(weights_path)
return model, x, blocks
def define_model(input_shape, num_classes, regularization):
# base
img_input = Input(input_shape)
x = Conv2D(filters=8,
kernel_size=(3, 3),
strides=(1, 1),
kernel_regularizer=regularization,
use_bias=False)(img_input)
# 8 dimensions of input, 8*3*3 filters, (8*3*3+1)*feature maps as output
# size of output CNN layer = input_shape-(filter_size-1) = 48-2 = 46
# Convolutional network should not be less than the input, so padding is done.
# If we want to explicitly want to downsample the image during the convolutional, we can define a stride.
# To calculate padding, input_size + 2 * padding_size-(filter_size-1) = 48+(2*1)-2 = 48
# number of parameters the network learned = (n*m*k+1)*f = (filter_size[0]*filter_size[1]*feature_map_as_output+1)*no_of_filters
# Dropout : removes the nodes that are below the weights mentioned.
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(filters=8,
kernel_size=(3, 3),
strides=(1, 1),
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# module 1
residual = Conv2D(filters=16,
kernel_size=(1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(filters=16,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(filters=16,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 2
residual = Conv2D(filters=32,
kernel_size=(1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(filters=32,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(filters=32,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 3
residual = Conv2D(filters=64,
kernel_size=(1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(filters=64,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(filters=64,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
# module 4
residual = Conv2D(filters=128,
kernel_size=(1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(filters=128,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(filters=128,
kernel_size=(3, 3),
padding='same',
kernel_regularizer=regularization,
use_bias=False)(x)
x = BatchNormalization()(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.add([x, residual])
x = Conv2D(filters=num_classes, kernel_size=(3, 3), padding='same')(x)
x = GlobalAveragePooling2D()(x)
output = Activation('softmax', name='predictions')(x)
return img_input, output
def Xception(input_shape=None, classes=1000):
img_input = Input(shape=input_shape)
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
model = Model(img_input, x, name='xception')
return model
from .neural_layers import expand_dims
def create_network((input_shape, prior, L1=0, L2=0, dropout=0, KERNEL_NUM=64):
resnet = ResNet50(include_top=False, input_shape=input_shape)
stage_names = ['activation_10', 'activation_22', 'activation_40', 'activation_49']
stages = [resnet.get_layer(stage_name).output for stage_name in stage_names]
feature_model = Model(inputs=resnet.input, outputs=stages)
for l in feature_model.layers:
l.trainable = False
# Feature Pyramid Network
inp = Input(input_shape)
features_at_stages = feature_model(inp)
x = SeparableConv2D(KERNEL_NUM, 1, padding='same', kernel_regularizer=l1_l2(l1=L1, l2=L2))(features_at_stages[-1])
x = BatchNormalization()(x)
P = LeakyReLU(name='P5')(x)
pyramid_features = [P]
for i in range(2,5):
x = SeparableConv2D(KERNEL_NUM, 1, padding='same', kernel_regularizer=l1_l2(l1=L1, l2=L2))(features_at_stages[-i])
x = BatchNormalization()(x)
x = LeakyReLU()(x)
y = UpSampling2D(interpolation='bilinear')(P)
z = Add()([x,y])
z = SeparableConv2D(KERNEL_NUM, 3, padding='same', kernel_regularizer=l1_l2(l1=L1, l2=L2))(z)
z = BatchNormalization()(z)
P = LeakyReLU(name='P{}'.format(6-i))(z)
def get_test_model_full():
"""Returns a maximally complex test model,
using all supported layer types with different parameter combination.
"""
input_shapes = [
(26, 28, 3),
(4, 4, 3),
(4, 4, 3),
(4, ),
(2, 3),
(27, 29, 1),
(17, 1),
(17, 4),
]
inputs = [Input(shape=s) for s in input_shapes]
outputs = []
for inp in inputs[6:8]:
for padding in ['valid', 'same']:
for s in range(1, 6):
for out_channels in [1, 2]:
for d in range(1, 4):
outputs.append(
Conv1D(out_channels,
s,
padding=padding,
dilation_rate=d)(inp))
for padding_size in range(0, 5):
outputs.append(ZeroPadding1D(padding_size)(inp))
for crop_left in range(0, 2):
for crop_right in range(0, 2):
outputs.append(Cropping1D((crop_left, crop_right))(inp))
for upsampling_factor in range(1, 5):
outputs.append(UpSampling1D(upsampling_factor)(inp))
for padding in ['valid', 'same']:
for pool_factor in range(1, 6):
for s in range(1, 4):
outputs.append(
MaxPooling1D(pool_factor, strides=s,
padding=padding)(inp))
outputs.append(
AveragePooling1D(pool_factor,
strides=s,
padding=padding)(inp))
outputs.append(GlobalMaxPooling1D()(inp))
outputs.append(GlobalAveragePooling1D()(inp))
for inp in [inputs[0], inputs[5]]:
for padding in ['valid', 'same']:
for h in range(1, 6):
for out_channels in [1, 2]:
for d in range(1, 4):
outputs.append(
Conv2D(out_channels, (h, 1),
padding=padding,
dilation_rate=(d, 1))(inp))
outputs.append(
SeparableConv2D(out_channels, (h, 1),
padding=padding,
dilation_rate=(d, 1))(inp))
for sy in range(1, 4):
outputs.append(
Conv2D(out_channels, (h, 1),
strides=(1, sy),
padding=padding)(inp))
outputs.append(
SeparableConv2D(out_channels, (h, 1),
strides=(sy, sy),
padding=padding)(inp))
for sy in range(1, 4):
outputs.append(
MaxPooling2D((h, 1), strides=(1, sy),
padding=padding)(inp))
for w in range(1, 6):
for out_channels in [1, 2]:
for d in range(1, 4) if sy == 1 else [1]:
outputs.append(
Conv2D(out_channels, (1, w),
padding=padding,
dilation_rate=(1, d))(inp))
outputs.append(
SeparableConv2D(out_channels, (1, w),
padding=padding,
dilation_rate=(1, d))(inp))
for sx in range(1, 4):
outputs.append(
Conv2D(out_channels, (1, w),
strides=(sx, 1),
padding=padding)(inp))
outputs.append(
SeparableConv2D(out_channels, (1, w),
strides=(sx, sx),
padding=padding)(inp))
for sx in range(1, 4):
outputs.append(
MaxPooling2D((1, w), strides=(1, sx),
padding=padding)(inp))
outputs.append(ZeroPadding2D(2)(inputs[0]))
outputs.append(ZeroPadding2D((2, 3))(inputs[0]))
outputs.append(ZeroPadding2D(((1, 2), (3, 4)))(inputs[0]))
outputs.append(Cropping2D(2)(inputs[0]))
outputs.append(Cropping2D((2, 3))(inputs[0]))
outputs.append(Cropping2D(((1, 2), (3, 4)))(inputs[0]))
for y in range(1, 3):
for x in range(1, 3):
outputs.append(UpSampling2D(size=(y, x))(inputs[0]))
outputs.append(GlobalAveragePooling2D()(inputs[0]))
outputs.append(GlobalMaxPooling2D()(inputs[0]))
outputs.append(AveragePooling2D((2, 2))(inputs[0]))
outputs.append(MaxPooling2D((2, 2))(inputs[0]))
outputs.append(UpSampling2D((2, 2))(inputs[0]))
outputs.append(keras.layers.concatenate([inputs[0], inputs[0]]))
outputs.append(Dropout(0.5)(inputs[0]))
outputs.append(BatchNormalization()(inputs[0]))
outputs.append(BatchNormalization(center=False)(inputs[0]))
outputs.append(BatchNormalization(scale=False)(inputs[0]))
outputs.append(Conv2D(2, (3, 3), use_bias=True)(inputs[0]))
outputs.append(Conv2D(2, (3, 3), use_bias=False)(inputs[0]))
outputs.append(SeparableConv2D(2, (3, 3), use_bias=True)(inputs[0]))
outputs.append(SeparableConv2D(2, (3, 3), use_bias=False)(inputs[0]))
outputs.append(Dense(2, use_bias=True)(inputs[3]))
outputs.append(Dense(2, use_bias=False)(inputs[3]))
shared_conv = Conv2D(1, (1, 1),
padding='valid',
name='shared_conv',
activation='relu')
up_scale_2 = UpSampling2D((2, 2))
x1 = shared_conv(up_scale_2(inputs[1])) # (1, 8, 8)
x2 = shared_conv(up_scale_2(inputs[2])) # (1, 8, 8)
x3 = Conv2D(1, (1, 1), padding='valid')(up_scale_2(inputs[2])) # (1, 8, 8)
x = keras.layers.concatenate([x1, x2, x3]) # (3, 8, 8)
outputs.append(x)
x = Conv2D(3, (1, 1), padding='same', use_bias=False)(x) # (3, 8, 8)
outputs.append(x)
x = Dropout(0.5)(x)
outputs.append(x)
x = keras.layers.concatenate(
[MaxPooling2D((2, 2))(x),
AveragePooling2D((2, 2))(x)]) # (6, 4, 4)
outputs.append(x)
x = Flatten()(x) # (1, 1, 96)
x = Dense(4, use_bias=False)(x)
outputs.append(x)
x = Dense(3)(x) # (1, 1, 3)
outputs.append(x)
intermediate_input_shape = (3, )
intermediate_in = Input(intermediate_input_shape)
intermediate_x = intermediate_in
intermediate_x = Dense(8)(intermediate_x)
intermediate_x = Dense(5)(intermediate_x)
intermediate_model = Model(inputs=[intermediate_in],
outputs=[intermediate_x],
name='intermediate_model')
intermediate_model.compile(loss='mse', optimizer='nadam')
x = intermediate_model(x) # (1, 1, 5)
intermediate_model_2 = Sequential()
intermediate_model_2.add(Dense(7, input_shape=(5, )))
intermediate_model_2.add(Dense(5))
intermediate_model_2.compile(optimizer='rmsprop',
loss='categorical_crossentropy')
x = intermediate_model_2(x) # (1, 1, 5)
x = Dense(3)(x) # (1, 1, 3)
shared_activation = Activation('tanh')
outputs = outputs + [
Activation('tanh')(inputs[3]),
Activation('hard_sigmoid')(inputs[3]),
Activation('selu')(inputs[3]),
Activation('sigmoid')(inputs[3]),
Activation('softplus')(inputs[3]),
Activation('softmax')(inputs[3]),
Activation('relu')(inputs[3]),
LeakyReLU()(inputs[3]),
ELU()(inputs[3]),
shared_activation(inputs[3]),
inputs[4],
inputs[1],
x,
shared_activation(x),
]
print('Model has {} outputs.'.format(len(outputs)))
model = Model(inputs=inputs, outputs=outputs, name='test_model_full')
model.compile(loss='mse', optimizer='nadam')
# fit to dummy data
training_data_size = 1
batch_size = 1
epochs = 10
data_in = generate_input_data(training_data_size, input_shapes)
data_out = generate_output_data(training_data_size, outputs)
model.fit(data_in, data_out, epochs=epochs, batch_size=batch_size)
return model
def Squeezefacenet(self):
input_img = Input(shape=self.input_shape)
#y = Input(shape=(self.classes, ))
#stage 0
x = self.conv_block(input_img, 48, 1)
x = self.conv_block(x, 96, 2, strides=(2, 2))
#stage 1
x1 = self.fire_squeeze(x, 16, 1)
x1 = MaxPooling2D(pool_size=(2, 2), strides=(2, 2),
name='maxpool1')(x1)
#stage 2
x2 = self.fire_squeeze(x1, 32, 2)
#stage 3
x3 = self.fire_squeeze(x2, 32, 3)
merge2_3 = add([x2, x3], name="add2_3")
#stage 4
x4 = self.fire_squeeze(merge2_3, 32, 4)
x4 = MaxPooling2D(pool_size=(2, 2), strides=(2, 2),
name='maxpool4')(x4)
#stage 5
x5 = self.fire_squeeze(x4, 32, 5)
merge4_5 = add([x4, x5], name="add4_5")
#stage 6
x6 = self.fire_squeeze(merge4_5, 32, 6)
#stage 7
x7 = self.fire_squeeze(x6, 32, 7)
merge6_7 = add([x6, x7], name="add6_7")
#stage 8
x8 = self.fire_squeeze(merge6_7, 32, 8)
x8 = MaxPooling2D(pool_size=(2, 2), strides=(2, 2),
name='maxpool8')(x8)
#stage 9
x9 = self.fire_squeeze(x8, 32, 9)
merge8_9 = add([x8, x9], name="add8_9")
#GDC
x10 = SeparableConv2D(256, (6, 6),
strides=(1, 1),
depth_multiplier=1,
activation=None,
depthwise_initializer='glorot_uniform',
pointwise_initializer='glorot_uniform',
name='s_conv')(merge8_9)
x10 = BatchNormalization(epsilon=1e-5, momentum=0.9,
name='sconv_bn')(x10)
#x10 = PReLU('zero', name='sconv_prelu')(x10)
#x10 = Activation('relu', name='sconv_relu')(x10)
#x10 = self.conv_block(x10, 128, 3, kernel=(1, 1))
x10 = Conv2D(128, (1, 1),
strides=1,
padding='same',
activation=None,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=l2(weight_decay),
name='conv_out')(x10)
x10 = BatchNormalization(epsilon=1e-5, momentum=0.9,
name='conv10_bn')(x10)
#out
#out_drop = Dropout(0.5, name='dropout')(x10)
out_flatten = Flatten(name='flatten')(x10)
#out = ArcFace(self.classes, regularizer=l2(weight_decay))([out_flatten, y])
out = Dense(self.classes,
kernel_initializer='glorot_uniform',
name='dense')(out_flatten)
self.model = Model(inputs=input_img, outputs=out)
def _convBlock(self, x, num_filters, activation, kernel_size=(3,3)):
x = SeparableConv2D(num_filters,kernel_size,padding='same')(x)
x = BatchNormalization(axis=-1)(x)
x = Activation(activation)(x)
return x
def miniXception_loader(input_tensor=None,
input_shape=None,
weights=None,
output_size=1024,
return_model=False,
pooling=None,
normalize=False,
binary=False,
regularize=None):
"""
Instantiates either a Tensor or a Model for the Core Embedding Network
Optionally loads weights pre-trained
This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
data format `(width, height, channels)`.
Min input image size for this model is 128x128
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(299, 299, 3)`.
It should have exactly 3 inputs channels,
and width and height should be no smaller than 71.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
if K.backend() != 'tensorflow':
raise RuntimeError('The model is only available with '
'the TensorFlow backend.')
if K.image_data_format() != 'channels_last':
warnings.warn(
'The model is only available for the '
'input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height). '
'You should set `image_data_format="channels_last"` in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
K.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
# Determine proper input shape
'''
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=71,
data_format=K.image_data_format(),
include_top=include_top)
'''
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False,
name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Dropout(rate=0.1)(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Dropout(rate=0.1)(x)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Dropout(rate=0.1)(x)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(1):
residual = x
prefix = 'block' + str(i + 5)
x = Dropout(rate=0.1)(x)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
#x = Activation('relu', name=prefix + '_sepconv3_act')(x)
#x = SeparableConv2D(512, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x)
#x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
'''
residual = Conv2D(1024, (1, 1), strides=(2, 2),
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
'''
x = Activation('relu', name='block13_sepconv2_act')(x)
#x = SeparableConv2D(output_size, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x)
# SeparableConv2D doesn't allow decreasing feature size(solved in newer versions of tensorflow
x = Conv2D(output_size, (1, 1),
strides=(1, 1),
use_bias=False,
name='block13_conv')(x)
x = BatchNormalization(name='pre_embed')(x)
'''
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
'''
if pooling == 'avg':
x = GlobalAveragePooling2D(name='embeding')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='embeding')(x)
elif pooling == 'rmac':
# we have x16 reduction, so 128*128 input was reduced to 8*8
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='valid',
name='embed_pool')(x)
x = GlobalAveragePooling2D(name='embeding')(x)
elif pooling == 'msrmac':
s1 = GlobalAveragePooling2D(name='s1')(x)
s2 = MaxPooling2D((2, 2), strides=(1, 1), padding='valid')(x)
s2 = GlobalAveragePooling2D(name='s2')(s2)
s4 = MaxPooling2D((4, 4), strides=(2, 2), padding='valid')(x)
s4 = GlobalAveragePooling2D(name='s4')(s4)
s8 = GlobalMaxPooling2D(name='s8')(x)
x = layers.add([s1, s2, s4, s8], name='embeding')
elif pooling == 'conv':
x = Conv2D(output_size, (8, 8),
strides=(1, 1),
use_bias=False,
name='embed_conv')(x)
x = Flatten(name='embeding')(x)
else:
x = Flatten(name='embeding')(x)
if binary:
x = Activation('sigmoid')(x)
if normalize:
x = Lambda(lambda q: K.l2_normalize(q, axis=-1), name='n_embedding')(x)
if regularize is not None:
#x = Activation('relu', name='prereg_act')(x)
x = ActivityRegularization(l1=regularize)(x)
# load weights
if weights is not None:
x.load_weights('Weights/' + weights)
print('Loaded {}'.format(weights))
if old_data_format:
K.set_image_data_format(old_data_format)
if return_model:
return Model(img_input, x)
else:
return x
def get_model2():
try:
model = load_model('./model0.h5')
except IOError:
nb_filter = 24
growth_rate = 24
compression = 0.5
weight_decay = 1e-4
global shape_d
img_shape = shape_d
inputs = Input([img_shape, img_shape, 31])
x = inputs
x = SeparableConv2D(nb_filter,
3,
kernel_initializer='he_uniform',
padding='same',
strides=[2, 2])(x)
for i in range(1):
x = res_block(x, nb_filter)
x_256, nb_filter_256 = x, nb_filter
nb_filter *= 2
x = Conv2D(nb_filter,
3,
kernel_initializer='he_uniform',
padding='same',
strides=[2, 2])(x)
for i in range(2):
x = res_block(x, nb_filter)
x_128, nb_filter_128 = x, nb_filter
nb_filter *= 2
x = Conv2D(nb_filter,
3,
kernel_initializer='he_uniform',
padding='same',
strides=[2, 2])(x)
for i in range(2):
x = res_block(x, nb_filter)
x_64, nb_filter_64 = x, nb_filter
nb_filter *= 2
x = Conv2D(nb_filter,
3,
kernel_initializer='he_uniform',
padding='same',
strides=[2, 2])(x)
for i in range(4):
x = res_block(x, nb_filter)
x, nb_filter = res_up(x, nb_filter, x_64, nb_filter_64)
for i in range(2):
x = res_block(x, nb_filter)
x, nb_filter = res_up(x, nb_filter, x_128, nb_filter_128)
for i in range(2):
x = res_block(x, nb_filter)
x, nb_filter = res_up(x, nb_filter, x_256, nb_filter_256)
for i in range(1):
x = res_block(x, nb_filter)
x = Conv2DTranspose(nb_filter,
3,
kernel_initializer='he_uniform',
padding='same',
strides=[2, 2])(x)
# x = BatchNormalization(axis=-1, gamma_regularizer=regularizers.l2(weight_decay),beta_regularizer=regularizers.l2(weight_decay))(x)
x = Activation('relu')(x)
x = Conv2D(
int(nb_filter * 0.5),
3,
kernel_initializer='he_uniform',
padding='same',
)(x)
# x = Conv2D(int(nb_filter*0.5), (3,3), kernel_initializer='he_uniform', padding='same', use_bias=False,kernel_regularizer=regularizers.l2(weight_decay))(x)
# x = BatchNormalization(axis=-1, gamma_regularizer=regularizers.l2(weight_decay),beta_regularizer=regularizers.l2(weight_decay))(x)
x = Activation('relu')(x)
x = Conv2D(
int(nb_filter * 0.5),
3,
kernel_initializer='he_uniform',
padding='same',
)(x)
# x = Conv2D(int(nb_filter*0.5), (3,3), kernel_initializer='he_uniform', padding='same', use_bias=False,kernel_regularizer=regularizers.l2(weight_decay))(x)
# x = BatchNormalization(axis=-1, gamma_regularizer=regularizers.l2(weight_decay),beta_regularizer=regularizers.l2(weight_decay))(x)
x = Activation('relu')(x)
x1 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='1',
activation='relu')(x)
x2 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='2',
activation='relu')(x)
x3 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='3',
activation='relu')(x)
x4 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='4',
activation='relu')(x)
x5 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='5',
activation='relu')(x)
x6 = Conv2D(1,
3,
kernel_initializer='he_uniform',
padding='same',
name='6',
activation='relu')(x)
model = Model(inputs, [x1, x2, x3, x4, x5, x6])
return model
# maxim = np.max(test_values)
# minim = np.min(test_values)
# test_values = (test_values - minim)/(maxim - minim + 1.0)
# print test_data.shape
# print test_values.shape
# model = Sequential()
# model.add(Dense(128, activation="relu", kernel_initializer="uniform", input_dim=m*n*3))
# model.add(Dense(32, activation="relu", kernel_initializer="uniform"))
# model.add(Dense(1, kernel_initializer='normal'))
# model.add(Activation("softmax"))
model = Sequential()
# model.add(Convolution2D(32, 3, strides=1, activation='relu', input_shape=(n, m, 3)))
model.add(SeparableConv2D(32, 3, strides=1, padding='same', depth_multiplier=1, activation='relu', input_shape=(n, m, 3)))
model.add(SeparableConv2D(32, 3, strides=1, padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='softmax'))
# train the model using SGD
# print("[INFO] compiling model...")
sgd = SGD(lr=0.1)
# model.compile(optimizer=sgd, loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.compile(optimizer=sgd, loss="mean_squared_error")
