def dense_net(input_tensor, blocks):
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(input_tensor)
x = layers.Conv2D(64, 7, strides=2, use_bias=False)(x)
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5)(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = layers.MaxPooling2D(3, strides=2)(x)
x = dense_block(x, blocks[0])
x = transition_block(x, 0.5)
x = dense_block(x, blocks[1])
o1 = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5)(x)
o1 = layers.GlobalMaxPooling2D()(o1)
x = transition_block(x, 0.5)
x = dense_block(x, blocks[2])
x = transition_block(x, 0.5)
x = dense_block(x, blocks[3])
o2 = None
if len(blocks) >= 5:
o2 = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5)(x)
o2 = layers.GlobalMaxPooling2D()(o2)
x = transition_block(x, 0.5)
x = dense_block(x, blocks[4])
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5)(x)
x = layers.GlobalMaxPooling2D()(x)
return x, o1, o2
def raw_model(lr=0.001, shape=(64, 64, 3)):
inputs = layers.Input(shape=shape)
base = applications.DenseNet121(input_tensor=inputs, weights='imagenet', include_top=False)
for i, layer in enumerate(base.layers):
print(i, layer.name)
# for layer in base.layers[:-7]:
# layer.trainable = False
# for layer in base.layers[-7:]:
# layer.trainable = True
output = layers.GlobalMaxPooling2D()(base.output)
output = layers.Dropout(0.5)(output)
output = layers.Dense(230, activation='softmax')(output)
model = Model(inputs=inputs, outputs=output)
opti = optimizers.Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(optimizer=opti, loss=losses.mean_squared_error, metrics=[metrics.categorical_accuracy])
for i, layer in enumerate(model.layers):
print(i, layer.name)
output = layers.GlobalMaxPooling2D()(base.output)
output = layers.Dense(1024, activation='sigmoid')(output)
middle_layer_model = Model(inputs=model.input, outputs=output)
return model, middle_layer_model
def cbam_block(tensor, ratio=8, activation='relu'):
from keras import layers
import keras.backend as K
channel = tensor.shape[-1]
avg_pool = layers.GlobalAveragePooling2D()(tensor)
avg_pool = layers.Reshape((1,1,channel))(avg_pool)
avg_pool = layers.Dense(channel//ratio, activation= activation)(avg_pool)
avg_pool = layers.Dense(channel, kernel_initializer='he_normal')(avg_pool)
max_pool = layers.GlobalMaxPooling2D()(tensor)
max_pool = layers.Reshape((1,1,channel))(max_pool)
max_pool = layers.Dense(channel//ratio, activation= activation)(max_pool)
max_pool = layers.Dense(channel, kernel_initializer='he_normal')(max_pool)
channel_att = layers.add([avg_pool,max_pool])
channel_att = layers.core.Activation('sigmoid')(channel_att)
channel_att= layers.multiply([tensor, channel_att])
#spatial attention
avg_pool = layers.Lambda(lambda x: K.mean(x, axis=3, keepdims=True))(channel_att)
max_pool = layers.Lambda(lambda x: K.max(x, axis=3, keepdims=True))(channel_att)
concat = layers.concatenate([avg_pool, max_pool], axis= -1)
spatial_att = layers.Conv2D(filters = 1,
kernel_size=7,
strides=1,
padding='same',
activation='sigmoid')(concat)
return layers.multiply([channel_att, spatial_att])
def Xception(input_shape=None,
include_top=True,
pooling='avg',
n_class=14,
pretrain_weights='imagenet'):
"""Instantiates the Xception architecture.
Note that the default input image size for this model is 299x299.
Args:
input_shape: list or tuple, (height, width, channel)
include_top: whether to include the fully-connected
layer at the top of the network.
pretrain_weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
n_class: int, num of class
pooling: string, option of ['max', 'avg']
Returns:
Raise:
Examples:
"""
inputs = layers.Input(shape=input_shape)
x = conv_bn_relu(inputs, 32, (3, 3), strides=(2, 2), name='block1_conv1')
x = conv_bn_relu(x, 64, (3, 3), name='block1_conv2')
x = xception_block1(x, [128, 128], (3, 3), activation=None, name='block2')
x = xception_block1(x, [256, 256], (3, 3), name='block3')
x = xception_block1(x, [728, 728], (3, 3), name='block4')
for i in range(8):
prefix = 'block' + str(i + 5)
x = xception_block2(x, 728, (3, 3), name=prefix)
# bottle neck
x = xception_block1(x, [728, 1024], (3, 3), name='block13')
x = sepconv_bn_relu(x, 1536, (3, 3), name='block14_conv1')
x = sepconv_bn_relu(x, 2048, (3, 3), name='block14_conv2')
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(n_class, activation='sigmoid', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Create model
model = Model(inputs, x, name='xception')
# Load weights
if pretrain_weights == 'imagenet':
load_imagenet_weights(model, include_top)
elif os.path.exists(pretrain_weights):
print("pretain from imagenet----", pretrain_weights)
model.load_weights(pretrain_weights)
else:
print("weight path does not exist!")
return model
def init_model(self):
conv_base = resnet50.ResNet50(weights='imagenet',
include_top=False,
input_shape=(input_size, input_size, 3))
for layer in conv_base.layers[:]:
if 'BatchNormalization' in str(layer):
layer.trainable = True
else:
layer.trainable = False
main_input = conv_base.input
embedding = conv_base.output
x = layers.GlobalMaxPooling2D()(embedding)
x = layers.Dropout(0.5)(x)
x = layers.Dense(4096,
activation='relu',
kernel_regularizer=regularizers.l2(0.01))(x)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(5004, activation='softmax')(x)
model = models.Model(inputs=[main_input], outputs=[x])
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
self.model = model
return model
def channel_attention(input_feature, ratio=8):
channel = input_feature._keras_shape[-1]
shared_layer_one = KL.Dense(int(channel / ratio),
activation='relu',
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
shared_layer_two = KL.Dense(channel,
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
avg_pool = KL.GlobalAveragePooling2D()(input_feature)
avg_pool = KL.Reshape((1, 1, channel))(avg_pool)
assert avg_pool._keras_shape[1:] == (1, 1, channel)
avg_pool = shared_layer_one(avg_pool)
assert avg_pool._keras_shape[1:] == (1, 1, channel // ratio)
avg_pool = shared_layer_two(avg_pool)
assert avg_pool._keras_shape[1:] == (1, 1, channel)
max_pool = KL.GlobalMaxPooling2D()(input_feature)
max_pool = KL.Reshape((1, 1, channel))(max_pool)
assert max_pool._keras_shape[1:] == (1, 1, channel)
max_pool = shared_layer_one(max_pool)
assert max_pool._keras_shape[1:] == (1, 1, channel // ratio)
max_pool = shared_layer_two(max_pool)
assert max_pool._keras_shape[1:] == (1, 1, channel)
cbam_feature = KL.Add()([avg_pool, max_pool])
cbam_feature = KL.Activation('sigmoid')(cbam_feature)
return KL.multiply([input_feature, cbam_feature])
def ResNet10(input_shape=None, include_top=True, pooling=None, classes=None):
"""
Resnet10 backbone, attention: there is no identity block in resnet10
:param img_input: the input tensor
:param include_top:
:param pooling: if include_tp=False, then we choose the pooling layer
:param classes:
:return: backbone model
"""
img_input = layers.Input(shape=input_shape)
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block2(x, 3, [64, 64], stage=2, block='a', strides=(1, 1))
x = conv_block2(x, 3, [128, 128], stage=3, block='a')
x = conv_block2(x, 3, [256, 256], stage=4, block='a')
x = conv_block2(x, 3, [512, 512], stage=5, block='a')
# x = conv_block2(x, 3, [64, 64], stage=3, block='a')
# x = conv_block2(x, 3, [64, 64], stage=4, block='a')
# x = conv_block2(x, 3, [64, 64], stage=5, block='a')
# x = conv_block2(x, 3, [64, 64], stage=6, block='a')
# x = conv_block2(x, 3, [64, 64], stage=7, block='a')
# x = conv_block2(x, 3, [64, 64], stage=8, block='a')
# x = conv_block2(x, 3, [64, 64], stage=9, block='a')
# x = conv_block2(x, 3, [64, 64], stage=10, block='a')
# x = conv_block2(x, 3, [64, 64], stage=11, block='a')
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
else:
print('The output shape of `ResNet10(include_top=False)` '
'has been changed ')
inputs = img_input
model = models.Model(inputs, x, name='resnet10')
return model
def _channel_attention(input_feature, ratio=8):
channel_dim = K.int_shape(input_feature)[-1]
shared_layer_one = layers.Dense(channel_dim // ratio, activation='relu')
shared_layer_two = layers.Dense(channel_dim)
avg_pool = layers.GlobalAveragePooling2D()(input_feature)
avg_pool = layers.Reshape((1, 1, channel_dim))(avg_pool)
assert K.int_shape(avg_pool)[1:] == (1, 1, channel_dim)
avg_pool = shared_layer_one(avg_pool)
assert K.int_shape(avg_pool)[1:] == (1, 1, channel_dim // ratio)
avg_pool = shared_layer_two(avg_pool)
assert K.int_shape(avg_pool)[1:] == (1, 1, channel_dim)
max_pool = layers.GlobalMaxPooling2D()(input_feature)
max_pool = layers.Reshape((1, 1, channel_dim))(max_pool)
assert K.int_shape(max_pool)[1:] == (1, 1, channel_dim)
max_pool = shared_layer_one(max_pool)
assert K.int_shape(max_pool)[1:] == (1, 1, channel_dim // ratio)
max_pool = shared_layer_two(max_pool)
assert K.int_shape(max_pool)[1:] == (1, 1, channel_dim)
cbam_feature = layers.Add()([avg_pool, max_pool])
cbam_feature = layers.Activation('sigmoid')(cbam_feature)
return layers.multiply([input_feature, cbam_feature])
def vgg_graph(input_image, architecture, include_top=True, pooling=None, classes=1000):
assert architecture in VGG_STRUCTURES
assert pooling in ["avg", "max", None]
x = input_image
stages = VGG_STRUCTURES["VGG11"]
stage_checkpoints = []
for bl, stage in enumerate(stages):
*k, f = stage["filters"]
layers = stage["layers"]
for cv, l in enumerate(range(layers)):
cv_name = "block{}_pool{}".format(bl, cv)
x = KL.Conv2D(f, k, activation='relu', padding='same', name=cv_name)(x)
mp_name = "block{}_pool".format(bl)
x = KL.MaxPooling2D((2, 2), strides=(2, 2), name=mp_name)(x)
stage_checkpoints.append(x)
if include_top:
# Classification block
x = KL.Flatten(name='flatten')(x)
x = KL.Dense(4096, activation='relu', name='fc1')(x)
x = KL.Dense(4096, activation='relu', name='fc2')(x)
x = KL.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = KL.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = KL.GlobalMaxPooling2D()(x)
stage_checkpoints.append(x)
return stage_checkpoints
def ResNet34(include_top=True,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3
endpoints = {}
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='same',
kernel_initializer='he_normal',
name='conv1')(img_input)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
endpoints['stage_0/tensor'] = x
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
endpoints['stage_1/tensor'] = x
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
endpoints['stage_2/tensor'] = x
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
endpoints['stage_3/tensor'] = x
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
inputs = img_input
# Create model.
model = Model(inputs, x, name='resnet34')
return model, endpoints
def create_model_multi_input(input_shapes,
yshape,
global_decay=5e-6) -> models.Model:
"""Create a multi input model for keras."""
segments = []
inputs = []
for xshape in input_shapes:
ix = layers.Input(shape=xshape)
inputs.append(ix)
x = layers.Conv2D(
filters=32,
kernel_size=4,
activation="relu",
strides=1,
kernel_regularizer=regularizers.l2(global_decay),
)(ix)
x = layers.Conv2D(
filters=48,
kernel_size=3,
activation="relu",
strides=1,
kernel_regularizer=regularizers.l2(global_decay),
)(x)
# x = layers.Conv2D(
# filters=48, kernel_size=2, activation="relu", strides=1,
# kernel_regularizer=regularizers.l2(global_decay),
# )(x)
x = layers.Conv2D(
filters=64,
kernel_size=2,
activation="relu",
strides=2,
kernel_regularizer=regularizers.l2(global_decay),
)(x)
# x = layers.MaxPooling2D(pool_size=2, strides=2)(x)
# x = layers.GlobalAveragePooling2D()(x)
x = layers.GlobalMaxPooling2D()(x)
segments.append(x)
if len(segments) > 1:
x = layers.concatenate(segments)
else:
x = segments[0]
x = layers.Dense(
units=64,
activation="relu",
# kernel_initializer="uniform",
kernel_regularizer=regularizers.l2(global_decay))(x)
x = layers.Dense(
units=32,
activation="relu",
# kernel_initializer="uniform",
kernel_regularizer=regularizers.l2(global_decay))(x)
x = layers.Dense(units=yshape, activation="softmax")(x)
model = models.Model(inputs=inputs, outputs=x)
return model
def YAMNet(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling='avg',
classes=521,
classifier_activation="sigmoid"):
"""Define the core YAMNet mode in Keras."""
if input_tensor is None:
input_shape = input_shape if input_shape is not None else (
params.PATCH_FRAMES, params.PATCH_BANDS)
input_tensor = layers.Input(shape=input_shape)
net = layers.Reshape(input_shape + (1, ))(input_tensor)
for (i, (layer_fun, kernel, stride,
filters)) in enumerate(_YAMNET_LAYER_DEFS):
net = layer_fun('layer{}'.format(i + 1), kernel, stride, filters)(net)
if include_top:
if weights is not None and classes != params.NUM_CLASSES:
model_temp = Model(inputs=input_tensor, outputs=net)
if weights is not None:
model_temp.load_weights(weights)
net = model_temp.output
net = layers.GlobalAveragePooling2D()(net)
logits = layers.Dense(units=classes, use_bias=True)(net)
predictions = layers.Activation(
name=params.EXAMPLE_PREDICTIONS_LAYER_NAME,
activation=classifier_activation)(logits)
else:
if weights is not None:
model_temp = Model(inputs=input_tensor, outputs=net)
if weights is not None:
model_temp.load_weights(weights)
net = model_temp.output
if pooling == 'avg':
predictions = layers.GlobalAveragePooling2D()(net)
elif pooling == 'max':
predictions = layers.GlobalMaxPooling2D()(net)
else:
predictions = net
model = Model(inputs=input_tensor, outputs=predictions)
if weights is not None and classes == params.NUM_CLASSES:
model.load_weights(weights)
return model
def create_inline_CNNs( embedding_dimension ):
cnn_input_layer = layers.Input(shape=(64,embedding_dimension,1))
tower_1_c = layers.Conv2D(256, kernel_size=(1,embedding_dimension), strides=(1,1), padding='valid', activation='relu' )(cnn_input_layer)
tower_1_p = layers.GlobalMaxPooling2D()(tower_1_c)
tower_2_c = layers.Conv2D(128, kernel_size=(2,embedding_dimension), strides=(1,1), padding='valid', activation='relu' )(cnn_input_layer)
tower_2_p = layers.GlobalMaxPooling2D()(tower_2_c)
tower_3_c = layers.Conv2D(64, kernel_size=(3,embedding_dimension), strides=(1,1), padding='valid', activation='relu' )(cnn_input_layer)
tower_3_p = layers.GlobalMaxPooling2D()(tower_3_c)
tower_4_c = layers.Conv2D(32, kernel_size=(4,embedding_dimension), strides=(1,1), padding='valid', activation='relu' )(cnn_input_layer)
tower_4_p = layers.GlobalMaxPooling2D()(tower_4_c)
merged = layers.concatenate([tower_1_p, tower_2_p, tower_3_p, tower_4_p])
cnn_model = Model(cnn_input_layer, merged)
cnn_model.summary()
return cnn_model
def main():
now = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
model_name = 'pretrain_NASNet_' + now + '.h5'
batch_size = 32
num_epochs = 30
lr = .0001
num_train_samples = len(os.listdir('./data/train/cancer')) + len(os.listdir('./data/train/healthy'))
num_valid_samples = len(os.listdir('./data/validation/cancer')) + len(os.listdir('./data/validation/healthy'))
# Build our model
input_tensor = Input(shape=(96, 96, 3))
NASNet = NASNetMobile(include_top=False, input_shape=(96, 96, 3))
x = NASNet(input_tensor)
x1 = layers.GlobalMaxPooling2D()(x)
x2 = layers.GlobalAveragePooling2D()(x)
x3 = layers.Flatten()(x)
z = layers.Concatenate(axis=-1)([x1, x2, x3])
z = layers.Dropout(.5)(z)
output_tensor = layers.Dense(1, activation='sigmoid')(z)
model = Model(input_tensor, output_tensor)
model.summary()
# Get things ready to train: tweak learning rate, etc.
model.compile(optimizer=Adam(lr), loss='binary_crossentropy', metrics=['acc'])
train_generator = train_gen(batch_size)
validation_generator = valid_gen(batch_size)
steps_per_epoch = num_train_samples / batch_size
validation_steps = num_valid_samples / batch_size
# Basic callbacks
checkpoint = callbacks.ModelCheckpoint(filepath='./models/' + model_name,
monitor='val_loss',
save_best_only=True)
early_stop = callbacks.EarlyStopping(monitor='val_acc',
patience=4)
csv_logger = callbacks.CSVLogger('./logs/' + model_name.split('.')[0] + '.csv')
callback_list = [checkpoint, early_stop, csv_logger]
# Training begins
history = model.fit_generator(train_generator,
steps_per_epoch=steps_per_epoch,
epochs=num_epochs,
verbose=1,
callbacks=callback_list,
validation_data=validation_generator,
validation_steps=validation_steps)
model.save('./models/' + model_name)
make_plots(history, model_name)
def pointnet2_cls_ssg(num_class, num_points, num_dim = 3):
'''
input: BxNx3
output: Bxnum_class
'''
input = keras.Input((num_points,num_dim)) # (batch, num_points, num_dim)
inp = input
if num_dim > 3:
l0_xyz = crop(2, 0, 3)(input)
l0_points = crop(2, 3, num_dim)(input)
use_feature = True
else :
l0_xyz = input
l0_points = input # useless
# for the first stage, there is no high level feature, only coordinate
use_feature = False
l1_xyz, l1_points, _ = pointnet_sa_module(l0_xyz, l0_points,
n_centroid=512, radius=0.2,
n_samples=32, mlp=[64,64,128],
bn=True, relu6=False, use_xyz=True,
use_feature=use_feature, random_sample=False)
l2_xyz, l2_points, _ = pointnet_sa_module(l1_xyz, l1_points,
n_centroid=128, radius=0.4,
n_samples=64, mlp=[128,128,256],
bn=True, relu6=False, use_xyz=True,
use_feature=True, random_sample=False)
'''
l3_xyz, l3_points, _ = pointnet_sa_module(l2_xyz, l2_points,
n_centroid=32, radius=0.6,
n_samples=32, mlp=[256,512,1024],
bn=True, relu6=False, use_xyz=True,
use_feature=True)
x = layers.GlobalMaxPooling1D()(l3_points)
# at this stage, no sampling or grouping, use PointNet layer directly
# as Keras don't support None as input or output
# the original implementation doesn't work here
'''
# try this instead
x = l2_points
x = layers.Reshape((-1,1,256))(x)
x = mlp_layers(x, [256, 512, 1024])
x = layers.GlobalMaxPooling2D()(x)
# fullly connected layers
# x = layers.Flatten()(x) # (Batch, :)
x = fully_connected(x, 512, bn=True, relu6=False, activation=True)
x = layers.Dropout(0.5)(x)
x = fully_connected(x, 256, bn=True, relu6 = False, activation=True)
x = layers.Dropout(0.5)(x)
x = fully_connected(x, num_class, bn=False, activation=False) # no BN nor ReLU here
x = layers.Softmax()(x)
return keras.models.Model(inputs=inp, outputs=x)
def define_cnn_architecture_cloud(fog_output,
alpha,
depth_multiplier,
classes,
include_top,
pooling,
dropout=1e-3):
cloud = _depthwise_conv_block(fog_output,
512,
alpha,
depth_multiplier,
block_id=9)
cloud = _depthwise_conv_block(cloud,
512,
alpha,
depth_multiplier,
block_id=10)
cloud = _depthwise_conv_block(cloud,
512,
alpha,
depth_multiplier,
block_id=11)
cloud = _depthwise_conv_block(cloud,
1024,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=12)
cloud = _depthwise_conv_block(cloud,
1024,
alpha,
depth_multiplier,
block_id=13)
if include_top:
if K.image_data_format() == 'channels_first':
shape = (int(1024 * alpha), 1, 1)
else:
shape = (1, 1, int(1024 * alpha))
cloud = layers.GlobalAveragePooling2D()(cloud)
cloud = layers.Reshape(shape, name='reshape_1')(cloud)
cloud = layers.Dropout(dropout, name='dropout')(cloud)
cloud = layers.Conv2D(classes, (1, 1),
padding='same',
name='conv_preds')(cloud)
cloud = layers.Reshape((classes, ), name='reshape_2')(cloud)
cloud_output = layers.Activation('softmax', name='output')(cloud)
else:
if pooling == 'avg':
cloud_output = layers.GlobalAveragePooling2D()(cloud)
elif pooling == 'max':
cloud_output = layers.GlobalMaxPooling2D()(cloud)
return cloud_output
def create_branches(a, b):
def sym(l, x, y):
a = l(x)
b = l(y)
return a, b
a, b = sym(layers.Conv2D(params["n_filter"], (params["h_filter"], 100)), a, b)
a, b = sym(layers.GlobalMaxPooling2D(), a, b)
for dim in params["d_encode"]:
a, b = sym(layers.Dense(dim), a, b)
a, b = sym(layers.Dropout(params["p_dropout"]),a , b)
return a, b
def DenseNet(img_input,blocks,
include_top=True,
input_shape=None,
pooling=None,
classes=1000
):
# img_input = layers.Input(shape=input_shape)
x = layers.Reshape((input_shape[0], input_shape[1], -1))(img_input)
x = dense_block(x, blocks[0], name='conv2')
x = transition_block(x, 0.5, name='pool2')
x = SEN_self_att(x,r=4,name='SEN2')
x = dense_block(x, blocks[1], name='conv3')
x = transition_block(x, 0.5, name='pool3')
x = SEN_self_att(x, r=4, name='SEN3')
x = dense_block(x, blocks[2], name='conv4')
x = transition_block(x, 0.5, name='pool4')
x = SEN_self_att(x, r=4, name='SEN4')
x = dense_block(x, blocks[3], name='conv5')
x = transition_block(x, 0.5, name='pool5')
x = SEN_self_att(x, r=4, name='SEN5')
if include_top:
# x = layers.Reshape([1,K.int_shape(x)[-2],-1])(x)
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
# x = layers.Flatten()(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors
#
# of `input_tensor`.
inputs = img_input
# Create model.
if blocks == [6, 12, 24, 16]:
model = models.Model(inputs, x, name='densenet121')
elif blocks == [6, 12, 32, 32]:
model = models.Model(inputs, x, name='densenet169')
elif blocks == [6, 12, 48, 32]:
model = models.Model(inputs, x, name='densenet201')
else:
model = models.Model(inputs, x, name='densenet')
return model
def DenseNet(input_shape,
blocks,
include_top=True,
regularization='dropout',
dropout_prob=0.2,
dropout_noise_shape=None,
pooling=None,
classes=10,
reduction=0.5):
assert regularization in [None, 'dropout']
assert pooling in [None, 'avg', 'max']
inp = layers.Input(shape=input_shape)
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(inp)
x = layers.Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x)
x = layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x)
x = layers.Activation('relu', name='conv1/relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = layers.MaxPooling2D(3, strides=2, name='pool1')(x)
i = 2
for block in blocks:
x = dense_block(x, block, name='conv{}'.format(i))
if regularization is 'dropout':
name = 'drop{}'.format(i)
x = layers.Dropout(rate=dropout_prob, noise_shape=dropout_noise_shape, name=name)(x)
if i <= len(blocks):
x = transition_block(x, reduction, name='pool{}'.format(i))
i = i + 1
x = layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name='bn')(x)
x = layers.Activation('relu', name='relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc{}'.format(classes))(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
model = models.Model(inp, x, name='densenet')
return model
def mk_conv_32(*, channels):
i = kr.Input((32, 32, 4), name='x0')
cc_stack = [
# kr.BatchNormalization(),
kr.GaussianNoise(0.025),
kr.Conv2D(10, 1, name='cconv_0'),
kr.LeakyReLU(alpha=0.4),
kr.Conv2D(channels, 1, name='cconv_1'),
kr.LeakyReLU(alpha=0.4),
]
h = apply_layers(i, cc_stack)
conv_stack_0 = [
kr.GaussianNoise(0.025),
kr.Conv2D(64, 3, activation='relu'),
kr.Conv2D(128, 3, activation='relu'),
kr.Conv2D(256, 3, activation='relu'),
kr.Conv2D(256, 3, strides=2, activation='relu'),
]
h = apply_layers(h, conv_stack_0)
ga0 = kr.GlobalAveragePooling2D()(h)
gm0 = kr.GlobalMaxPooling2D()(h)
conv_stack_1 = [
kr.Conv2D(196, 3, activation='relu'),
kr.Conv2D(196, 3, strides=2, activation='relu'),
kr.Conv2D(196, 3, activation='relu'),
kr.Flatten(),
]
h = apply_layers(h, conv_stack_1)
cat = kr.Concatenate()([h, gm0, ga0])
head = [
kr.Dropout(0.5),
kr.Dense(512, activation='elu'),
kr.Dropout(0.5),
kr.Dense(256, activation='elu'),
kr.Dropout(0.5),
kr.Dense(Y_TRAIN.shape[1], activation='sigmoid', name='labs'),
]
y = apply_layers(cat, head)
m = krm.Model(inputs=[i], outputs=[y], name='conv_32')
m.compile(loss=f2_crossentropy,
optimizer='adam',
metrics=['binary_accuracy'])
return m
def train_classifier(train_gt, train_img_dir, fast_train=False):
names = os.listdir(train_img_dir)
df = pd.DataFrame({'filename':names})
df['class'] = [*map(lambda name: train_gt[name], df['filename'])]
batch_size=10
train_generator = ImageDataGenerator(
rescale=1./255,
rotation_range=10,
zoom_range=0.2,
horizontal_flip=True
).flow_from_dataframe(
directory=train_img_dir,
dataframe=df,
target_size=(224, 224),
batch_size=batch_size,
class_mode='sparse',
x_col='filename',
y_col='class',
)
num_classes = 50
xception = Xception()
for layer in xception.layers: # first we optimize new layers only
layer.trainable = False
activation = xception.get_layer('block14_sepconv2_act').output
pool = L.GlobalMaxPooling2D()(activation)
dropout = L.Dropout(0.5)(pool)
dense = L.Dense(200, activation='relu')(dropout)
dense = L.Dense(num_classes, activation='softmax')(dense)
model = keras.models.Model(inputs=xception.inputs, outputs=dense)
model.compile(
optimizer=Adam(lr=0.001),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy']
)
# localy this was done till convergence
model.fit_generator(train_generator, steps_per_epoch= 10, verbose=1)
# now optimize whole model
for layer in model.layers:
layer.trainable = True
model.compile(
optimizer=Adam(lr=0.0001),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy']
)
# localy this was done till convergence
model.fit_generator(train_generator, steps_per_epoch= 10, verbose=1)
def create_discriminator():
discriminator = keras.Sequential(
[
keras.Input(shape=(28, 28, 1)),
layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.GlobalMaxPooling2D(),
layers.Dense(1),
],
name="discriminator",
)
discriminator.summary()
return discriminator
def build_model():
densenet = DenseNet121(weights='DenseNet-BC-121-32-no-top.h5',
include_top=False,
input_shape=(224, 224, 3))
model = Sequential()
model.add(densenet)
model.add(layers.GlobalMaxPooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(5, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=Adam(lr=0.0001),
metrics=['accuracy'])
return model
def get_model(shape, class_num, kernel_heights=[2, 3, 4, 5]):
row_num, col_num = shape
inputs = layers.Input(shape=(row_num, col_num))
reshape = layers.Reshape(target_shape=(row_num, col_num, 1))(inputs)
convs = []
for kernel_height in kernel_heights:
x = layers.Conv2D(filters=256, kernel_size=(kernel_height, col_num), activation='relu')(reshape)
x = layers.GlobalMaxPooling2D()(x)
convs.append(x)
my_concat = layers.Lambda(lambda x: K.concatenate(x, axis=1))
concats = my_concat(convs)
outputs = layers.Dropout(0.5)(concats)
outputs = layers.Dense(class_num, activation='softmax')(outputs)
model = models.Model(input=inputs, outputs=outputs)
adam = Adam(lr=1e-3)
model.compile(adam, 'categorical_crossentropy', metrics=['accuracy', acc_top3])
model.summary()
return model
def get_model(name: str):
if name == 'dense':
return keras.Sequential([
layers.InputLayer(input_shape=(85,)),
layers.Dense(70, name='hidden1', activation='relu'),
layers.Dense(60, name='hidden2', activation='relu'),
layers.Dense(30, name='hidden3', activation='relu'),
layers.Dense(10, name='output', activation='softmax')
], 'poker_predictor')
if name == 'conv':
return keras.Sequential([
layers.InputLayer(input_shape=(5, 17, 1)),
layers.Conv2D(10, (5, 5), name='conv'),
layers.GlobalMaxPooling2D(),
layers.Dense(20, name='hidden1', activation='relu'),
layers.Dense(20, name='hidden2', activation='relu'),
layers.Dense(10, name='output', activation='softmax')
], 'poker_predictor')
def MnasNet(input_shape=None, alpha=1.0, depth_multiplier=1, pooling=None, nb_classes=10):
img_input = layers.Input(shape=input_shape)
first_block_filters = _make_divisible(32 * alpha, 8)
x = _conv_block(img_input, strides=2, filters=first_block_filters)
x = _sep_conv_block(x, filters=16, alpha=alpha,
pointwise_conv_filters=16, depth_multiplier=depth_multiplier)
x = _inverted_res_block(x, kernel=3, expansion=3, stride=2, alpha=alpha, filters=24, block_id=1)
x = _inverted_res_block(x, kernel=3, expansion=3, stride=1, alpha=alpha, filters=24, block_id=2)
x = _inverted_res_block(x, kernel=3, expansion=3, stride=1, alpha=alpha, filters=24, block_id=3)
x = _inverted_res_block(x, kernel=5, expansion=3, stride=2, alpha=alpha, filters=40, block_id=4)
x = _inverted_res_block(x, kernel=5, expansion=3, stride=1, alpha=alpha, filters=40, block_id=5)
x = _inverted_res_block(x, kernel=5, expansion=3, stride=1, alpha=alpha, filters=40, block_id=6)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=2, alpha=alpha, filters=80, block_id=7)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=1, alpha=alpha, filters=80, block_id=8)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=1, alpha=alpha, filters=80, block_id=9)
x = _inverted_res_block(x, kernel=3, expansion=6, stride=1, alpha=alpha, filters=96, block_id=10)
x = _inverted_res_block(x, kernel=3, expansion=6, stride=1, alpha=alpha, filters=96, block_id=11)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=2, alpha=alpha, filters=192, block_id=12)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=1, alpha=alpha, filters=192, block_id=13)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=1, alpha=alpha, filters=192, block_id=14)
x = _inverted_res_block(x, kernel=5, expansion=6, stride=1, alpha=alpha, filters=192, block_id=15)
x = _inverted_res_block(x, kernel=3, expansion=6, stride=1, alpha=alpha, filters=320, block_id=16)
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
else:
x = layers.GlobalMaxPooling2D()(x)
x = layers.Dense(nb_classes, activation='softmax', use_bias=True, name='proba')(x)
inputs = img_input
model = models.Model(inputs, x, name='mnasnet')
return model
def channel_attention(input_feature, ratio=8):
print('input feature shape', input_feature._keras_shape)
channel = input_feature._keras_shape[1]
shared_layer_one = layers.Dense(channel // ratio,
activation='relu',
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
shared_layer_two = layers.Dense(channel,
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
avg_pool = layers.GlobalAveragePooling2D()(input_feature)
print('before reshpae avg pool', avg_pool._keras_shape)
avg_pool = layers.Reshape((channel, 1, 1))(avg_pool)
print('after reshpae avg pool', avg_pool._keras_shape)
avg_pool = shared_layer_one(avg_pool)
print('after shared layer 01 avg pool', avg_pool._keras_shape)
avg_pool = shared_layer_two(avg_pool)
print('after shared layer 02 avg pool', avg_pool._keras_shape)
max_pool = layers.GlobalMaxPooling2D()(input_feature)
print('before reshpae max pool', max_pool._keras_shape)
max_pool = layers.Reshape((channel, 1, 1))(max_pool)
print('after reshpae max pool', max_pool._keras_shape)
max_pool = shared_layer_one(max_pool)
print('after shared layer 01 max pool', max_pool._keras_shape)
max_pool = shared_layer_two(max_pool)
print('before shared layer 02 max pool', max_pool._keras_shape)
cbam_feature = layers.Add()([avg_pool, max_pool])
cbam_feature = layers.Activation('sigmoid')(cbam_feature)
return layers.multiply([input_feature, cbam_feature])
def __init__(self):
super(Channel_attention, self).__init__()
self.reduction_ratio = 0.125
self.channel_axis = 1 if K.image_data_format(
) == "channels_first" else 3
self.maxpool = KL.GlobalMaxPooling2D()
self.avgpool = KL.GlobalAvgPool2D()
self.sigmoid = KL.Activation('sigmoid')
self.channel = 128
self.Dense_One = KL.Dense(units=int(self.channel *
self.reduction_ratio),
activation='relu',
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
self.Dense_Two = KL.Dense(units=int(self.channel),
activation='relu',
kernel_initializer='he_normal',
use_bias=True,
bias_initializer='zeros')
def build_densenet(blocks,
include_top=True,
input_shape=None,
pooling=None,
num_classes=1000):
img_input = layers.Input(shape=input_shape)
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input)
x = layers.Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name='conv1/bn')(x)
x = layers.Activation('relu', name='conv1/relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = layers.MaxPooling2D(3, strides=2, name='pool1')(x)
for i, block in blocks:
conv_name = 'conv{}'.format(i + 1)
pool_name = 'pool{}'.format(i + 1)
x = dense_block(x, block, name=conv_name)
x = transition_block(x, 0.5, name=pool_name)
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x)
x = layers.Activation('relu', name='relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(num_classes, activation='softmax', name='fc')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
model = models.Model(img_input, x, name='densenet')
return model
def build_model_Inception_Resnet():
inception_resnet = inception_resnet_v2.InceptionResNetV2(
weights='imagenet',
include_top=False,
input_shape=(224,224,3)
)
model = Sequential()
model.add(inception_resnet)
model.add(layers.GlobalMaxPooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(2, activation='sigmoid'))
model.compile(
loss='categorical_crossentropy',
optimizer=Adam(lr=0.0005),
metrics=['accuracy']
)
return model
