def identity_block(input_tensor, kernel_size, filters, stage, block):
'''The identity_block is the block that has no conv layer at shortcut
# Arguments
input_tensor: input tensor
kernel_size: defualt 3, the kernel size of middle conv layer at main path
filters: list of integers, the nb_filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
'''
eps = 1.1e-5
nb_filter1, nb_filter2, nb_filter3 = filters
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
scale_name_base = 'scale' + str(stage) + block + '_branch'
x = Conv2D(nb_filter1, (1, 1), name=conv_name_base + '2a',
use_bias=False)(input_tensor)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2a')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2a')(x)
x = Activation('relu', name=conv_name_base + '2a_relu')(x)
x = ZeroPadding2D((1, 1), name=conv_name_base + '2b_zeropadding')(x)
x = Conv2D(nb_filter2, (kernel_size, kernel_size),
name=conv_name_base + '2b',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2b')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2b')(x)
x = Activation('relu', name=conv_name_base + '2b_relu')(x)
x = Conv2D(nb_filter3, (1, 1), name=conv_name_base + '2c',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2c')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2c')(x)
x = add([x, input_tensor])
x = Activation('relu', name='res' + str(stage) + block + '_relu')(x)
return x
def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2)):
'''conv_block is the block that has a conv layer at shortcut
# Arguments
input_tensor: input tensor
kernel_size: defualt 3, the kernel size of middle conv layer at main path
filters: list of integers, the nb_filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
Note that from stage 3, the first conv layer at main path is with subsample=(2,2)
And the shortcut should have subsample=(2,2) as well
'''
eps = 1.1e-5
nb_filter1, nb_filter2, nb_filter3 = filters
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
scale_name_base = 'scale' + str(stage) + block + '_branch'
x = Conv2D(nb_filter1, (1, 1), strides=strides, use_bias=False, name=conv_name_base + '2a')(input_tensor)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2a')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2a')(x)
x = Activation('relu', name=conv_name_base + '2a_relu')(x)
x = ZeroPadding2D((1, 1), name=conv_name_base + '2b_zeropadding')(x)
x = Conv2D(nb_filter2, (kernel_size, kernel_size), use_bias=False, name=conv_name_base + '2b')(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2b')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2b')(x)
x = Activation('relu', name=conv_name_base + '2b_relu')(x)
x = Conv2D(nb_filter3, (1, 1), use_bias=False, name=conv_name_base + '2c')(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2c')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2c')(x)
shortcut = Conv2D(nb_filter3, (1, 1), strides=strides, use_bias=False, name=conv_name_base + '1')(input_tensor)
shortcut = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '1')(shortcut)
shortcut = Scale(axis=bn_axis, name=scale_name_base + '1')(shortcut)
#x = merge([x, shortcut], mode='sum', name='res' + str(stage) + block)
x = Add()([x, shortcut])
x = Activation('relu', name='res' + str(stage) + block + '_relu')(x)
return x
def resnet101_model(img_rows, img_cols, color_type=1, num_classes=None):
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), name='conv1', strides=(2, 2), use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 4):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 23):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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')
x_newfc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_newfc = Dropout(0.5)(x_newfc)
x_newfc = Flatten()(x_newfc)
x_newfc = Dense(num_classes, activation='softmax', name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
model.compile(optimizer=Adam(lr=1e-5,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-8,
decay=1e-9,
amsgrad=True),
loss='categorical_crossentropy',
metrics=[top_3_accuracy, 'accuracy'])
return model
def conv_block(x, stage, branch, nb_filter, dropout_rate=None, weight_decay=1e-4, nw=None):
'''Apply BatchNorm, Relu, bottleneck 1x1 Conv2D, 3x3 Conv2D, and option dropout
# Arguments
x: input tensor
stage: index for dense block
branch: layer index within each dense block
nb_filter: number of filters
dropout_rate: dropout rate
weight_decay: weight decay factor
'''
t=True
if nw is None:
t=False
print("Trainable is : "+str(t))
eps = 1.1e-5
conv_name_base = xstr(nw)+'conv' + str(stage) + '_' + str(branch)
relu_name_base = xstr(nw)+'relu' + str(stage) + '_' + str(branch)
# 1x1 Convolution (Bottleneck layer)
inter_channel = nb_filter * 4
x = BatchNormalization(epsilon=eps, axis=concat_axis, name=conv_name_base+'_x1_bn')(x)
x = Scale(axis=concat_axis, name=conv_name_base+'_x1_scale')(x)
x = Activation('relu', name=relu_name_base+'_x1')(x)
x = Convolution2D(inter_channel, 1, 1, name=conv_name_base+'_x1', bias=False)(x)
if dropout_rate:
x = Dropout(dropout_rate)(x)
# 3x3 Convolution
x = BatchNormalization(epsilon=eps, axis=concat_axis, name=conv_name_base+'_x2_bn')(x)
x = Scale(axis=concat_axis, name=conv_name_base+'_x2_scale')(x)
x = Activation('relu', name=relu_name_base+'_x2')(x)
x = ZeroPadding2D((1, 1), name=conv_name_base+'_x2_zeropadding')(x)
x = Convolution2D(nb_filter, 3, 3, name=conv_name_base+'_x2', bias=False)(x)
if dropout_rate:
x = Dropout(dropout_rate)(x)
return x
def testnet_model(img_rows, img_cols, color_type=3, num_classes=2):
"""
Resnet 101 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfdUV1MHJhelpnSG8/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfTmRRVmpGWDczaXM/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), use_bias=False, name='conv1')(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
#x_newfc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_newfc = GlobalAveragePooling2D(dim_ordering='default',
name='global_pool')(x)
#x_newfc = Flatten()(x_newfc)
x_newfc = Dense(num_classes, activation=None, name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
#sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
#model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
return model
def net_beta(img_input, classes, blocks):
x = ZeroPadding2D((1, 1))(img_input)
x = Conv2D(64, (3, 3), use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis)(x)
x = Scale(axis=bn_axis)(x)
x = advanced_activations.LeakyReLU(alpha=0.2)(x) #
x, shortcut = b_block(x, 3, [64, 64], strides=(1, 1), shortcut=None)
for i in xrange(blocks[0]):
x, shortcut = b_block(x,
3, [64, 64],
strides=(1, 1),
shortcut=shortcut)
x, shortcut = b_block(x, 3, [128, 128], shortcut=shortcut) ###ci
for i in xrange(blocks[0]):
x, shortcut = b_block(x,
3, [128, 128],
strides=(1, 1),
shortcut=shortcut)
x, shortcut = b_block(x, 3, [256, 256], shortcut=shortcut)
for i in xrange(blocks[0]):
x, shortcut = b_block(x,
3, [256, 256],
strides=(1, 1),
shortcut=shortcut)
x, shortcut = b_block(x, 3, [512, 512], shortcut=shortcut)
for i in xrange(blocks[0]):
x, shortcut = b_block(x,
3, [512, 512],
strides=(1, 1),
shortcut=shortcut)
# x, shortcut = block(x, 3, [512, 512], shortcut = shortcut)
x = Conv2D(512, (1, 1), use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis)(x)
x = advanced_activations.LeakyReLU(alpha=0.2)(x)
x_fc = GlobalAveragePooling2D()(x)
x_fc = Dense(classes, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
return model
def build_Resnet152_Model(im_shape, num_Classes, pretrained):
'''Instantiate the ResNet152 architecture,
# Arguments
weights_path: path to pretrained weight file
# Returns
A Keras model instance.
'''
eps = 1.1e-5
#weights_path = '/home/user/zyong/darknetnew/yong/yong/pretrained/resnet152/resnet152_weights_tf.h5'
# Handle Dimension Ordering for different backends
global bn_axis
bn_axis = 3
img_input = Input(shape=im_shape, name='input')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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')
x_fc = AveragePooling2D((int(im_shape[0] / 32), int(im_shape[1] / 32)),
name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(int(num_Classes), activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
return model
def transition_block(tensor_x,
stage,
nb_filter,
compression=1.0,
dropout_rate=None,
weight_decay=1E-4):
'''
# 说明:
Apply BatchNorm, 1x1 Convolution, averagePooling, optional compression, dropout
# Arguments
- tensor_x: input tensor
- stage: index for dense block
- nb_filter: number of filters
- compression: calculated as 1 - reduction. Reduces the number of feature maps in the transition block.
- dropout_rate: dropout rate
- weight_decay: weight decay factor
'''
eps = 1.1e-5
conv_name_base = 'conv' + str(stage) + '_blk'
relu_name_base = 'relu' + str(stage) + '_blk'
pool_name_base = 'pool' + str(stage)
tensor_x = BatchNormalization(epsilon=eps,
axis=CONCAT_AXIS,
name=conv_name_base + '_bn')(tensor_x)
tensor_x = Scale(axis=CONCAT_AXIS,
name=conv_name_base + '_scale')(tensor_x)
tensor_x = Activation('relu', name=relu_name_base)(tensor_x)
tensor_x = Conv2D(int(nb_filter * compression), (1, 1),
name=conv_name_base,
use_bias=False)(tensor_x)
if dropout_rate:
tensor_x = Dropout(dropout_rate)(tensor_x)
tensor_x = AveragePooling2D((2, 2), strides=(2, 2),
name=pool_name_base)(tensor_x)
return tensor_x
def transition_block(x,
stage,
nb_filter,
compression=1.0,
dropout_rate=None,
weight_decay=1E-4):
''' Apply BatchNorm, 1x1 Convolution, averagePooling, optional compression, dropout
# Arguments
x: input tensor
stage: index for dense block
nb_filter: number of filters
compression: calculated as 1 - reduction. Reduces the number of feature maps in the transition block.
dropout_rate: dropout rate
weight_decay: weight decay factor
'''
eps = 1.1e-5
conv_name_base = 'conv' + str(stage) + '_blk'
relu_name_base = 'relu' + str(stage) + '_blk'
pool_name_base = 'pool' + str(stage)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name=conv_name_base + '_bn')(x)
x = Scale(axis=concat_axis, name=conv_name_base + '_scale')(x)
x = Activation('relu', name=relu_name_base)(x)
x = Conv2D(int(nb_filter * compression),
1,
1,
name=conv_name_base,
bias=False,
kernel_regularizer=reg)(x)
if dropout_rate:
x = Dropout(dropout_rate)(x)
x = AveragePooling2D((2, 2), strides=(2, 2), name=pool_name_base)(x)
return x
def resnet101_model(input_shape=(None, None, None),
include_top=False,
weights_root='',
num_classes=1000):
"""
Resnet 101 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfdUV1MHJhelpnSG8/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfTmRRVmpGWDczaXM/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
img_rows, img_cols, color_type = input_shape
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(64, (7, 7),
subsample=(2, 2),
name='conv1',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 4):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 23):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(num_classes,
activation='softmax',
name='fc' + str(num_classes))(x_fc)
model = Model(img_input, x_fc)
else:
x_gap = GlobalAveragePooling2D(name='final_gap')(x)
model = Model(img_input, x_gap)
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = os.path.join(weights_root, 'resnet101_weights_th.h5')
else:
# Use pre-trained weights for Tensorflow backend
weights_path = os.path.join(weights_root, 'resnet101_weights_tf.h5')
model.load_weights(weights_path, by_name=True)
if include_top:
# Learning rate is changed to 0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def create_model(img_rows=224,
img_cols=224,
color_type=3,
nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4):
'''
DenseNet 169 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfN0d3T1F1MXg0NlU
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfSEc5UC1ROUFJdmM
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras models instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
concat_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 32, 32] # For DenseNet-169
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
return model, x, final_stage, img_input
def conv_block(input_tensor,
kernel_size,
filters,
stage,
block,
strides=(2, 2),
eps=1.0e-5):
'''
Build the convolutional block
Note that from stage 3, the first conv layer at main path is with subsample=(2,2)
And the shortcut should have subsample=(2,2) as well
Args:
input_tensor (tensor): input tensor
kernel_size (int): defualt 3, the kernel size of the middle convolutional layer
filters (list): list of three (3) integers of the three (3) nb_filters of the
convolutional layers
stage (int): current stage label, used for generating layer names
block (str): current block label, used for generating layer names
strides (tuple): default (2,2), tuple of Strides for the Conv2D layers
eps (float): default 1.0e-5, epsilon value to use in BatchNormalization layers
Returns:
convolutional block of layers for model
'''
nb_filter1, nb_filter2, nb_filter3 = filters
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
scale_name_base = 'scale' + str(stage) + block + '_branch'
x = Conv2D(nb_filter1, (1, 1),
strides=strides,
name=conv_name_base + '2a',
use_bias=False)(input_tensor)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2a')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2a')(x)
x = Activation('relu', name=conv_name_base + '2a_relu')(x)
x = ZeroPadding2D((1, 1), name=conv_name_base + '2b_zeropadding')(x)
x = Conv2D(nb_filter2, (kernel_size, kernel_size),
name=conv_name_base + '2b',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2b')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2b')(x)
x = Activation('relu', name=conv_name_base + '2b_relu')(x)
x = Conv2D(nb_filter3, (1, 1), name=conv_name_base + '2c',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis,
name=bn_name_base + '2c')(x)
x = Scale(axis=bn_axis, name=scale_name_base + '2c')(x)
shortcut = Conv2D(nb_filter3, (1, 1),
strides=strides,
name=conv_name_base + '1',
use_bias=False)(input_tensor)
shortcut = BatchNormalization(epsilon=eps,
axis=bn_axis,
name=bn_name_base + '1')(shortcut)
shortcut = Scale(axis=bn_axis, name=scale_name_base + '1')(shortcut)
x = add([x, shortcut], name='res' + str(stage) + block)
x = Activation('relu', name='res' + str(stage) + block + '_relu')(x)
return x
def resnet152_model(img_rows,
img_cols,
color_type=1,
num_classes=196,
eps=1.0e-5):
"""
Resnet 152 Model
Follows structure of original Caffe implementation. See more here:
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights:
https://drive.google.com/file/d/0Byy2AcGyEVxfeXExMzNNOHpEODg/view?usp=sharing
Args:
img_rows (int): row dimension of image inputs
img_cols (int): column dimension of image inputs
color_type (int): number of color channels (1 for greyscale, 3 for RGB)
num_classes (int): default 196, number of class labels for the classification task;
Stanford Cars Dataset is comprised of 196 car make-model-year labels.
eps (float): default 1.0e-5, epsilon value to use in BatchNormalization layers
Returns:
compiled ResNet152 model
"""
global bn_axis
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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')
x_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
weights_path = 'models/resnet152_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
x_newfc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_newfc = Flatten()(x_newfc)
x_newfc = Dense(num_classes, activation='softmax', name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def convolutional_block(X, f, filters, stage, block, s=2):
"""
Implementation of the convolutional block as defined in Figure 4
Arguments:
X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)
f -- integer, specifying the shape of the middle CONV's window for the main path
filters -- python list of integers, defining the number of filters in the CONV layers of the main path
stage -- integer, used to name the layers, depending on their position in the network
block -- string/character, used to name the layers, depending on their position in the network
s -- Integer, specifying the stride to be used
Returns:
X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)
"""
# defining name basis
eps = 1.1e-5
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
scale_name_base = 'scale' + str(stage) + block + '_branch'
# Retrieve Filters
F1, F2, F3 = filters
# Save the input value
X_shortcut = X
##### MAIN PATH #####
# First component of main path
X = Conv2D(F1, (1, 1),
strides=(s, s),
padding='valid',
name=conv_name_base + '2a',
use_bias=False,
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(epsilon=eps, axis=3, name=bn_name_base + '2a')(X)
X = Scale(axis=3, name=scale_name_base + '2a')(X)
X = Activation('relu')(X)
# Second component of main path
X = Conv2D(F2, (f, f),
strides=(1, 1),
padding='same',
name=conv_name_base + '2b',
use_bias=False,
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(epsilon=eps, axis=3, name=bn_name_base + '2b')(X)
X = Scale(axis=3, name=scale_name_base + '2b')(X)
X = Activation('relu')(X)
# Third component of main path
X = Conv2D(F3, (1, 1),
strides=(1, 1),
padding='valid',
name=conv_name_base + '2c',
use_bias=False,
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(epsilon=eps, axis=3, name=bn_name_base + '2c')(X)
X = Scale(axis=3, name=scale_name_base + '2c')(X)
##### SHORTCUT PATH ####
X_shortcut = Conv2D(F3, (1, 1),
strides=(s, s),
padding='valid',
name=conv_name_base + '1',
use_bias=False,
kernel_initializer=glorot_uniform(seed=0))(X_shortcut)
X_shortcut = BatchNormalization(epsilon=eps,
axis=3,
name=bn_name_base + '1')(X_shortcut)
X_shortcut = Scale(axis=3, name=scale_name_base + '1')(X_shortcut)
# Final step: Add shortcut value to main path, and pass it through a RELU activation
X = Add()([X, X_shortcut])
X = Activation('relu')(X)
return X
def densenet161_model(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=48,
nb_filter=96,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4,
num_classes=None):
'''
DenseNet 161 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfVnlCMlBGTDR3RGs
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfUDZwVjU2cFNidTA
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
layers = []
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 96
nb_layers = [6, 12, 36, 24] # For DenseNet-161
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(nb_filter, (7, 7), strides=(2, 2), name='conv1',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
layers.append(x)
# x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
layers.append(x)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
# x_fc = GlobalAveragePooling2D(name='pool'+str(final_stage))(x)
# x_fc = Dense(1000, name='fc6')(x_fc)
# x_fc = Activation('softmax', name='prob')(x_fc)
# model = Model(img_input, x_fc, name='densenet')
model = Model(img_input, x, name='densenet')
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = '../imagenet_models/densenet161_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = '../imagenet_models/densenet161_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
return model, layers
def densenet121_model(img_rows, img_cols, color_type=1, nb_dense_block=4, growth_rate=32, \
nb_filter=64, reduction=0.5, dropout_rate=0.0, weight_decay=1e-4, num_classes=None):
'''
# 说明:
- DenseNet 121 Model for Keras
- Model Schema is based on https://github.com/flyyufelix/DenseNet-Keras
- ImageNet Pretrained Weights
- Theano:
https://drive.google.com/open?id=0Byy2AcGyEVxfMlRYb3YzV210VzQ
- TensorFlow:
https://drive.google.com/open?id=0Byy2AcGyEVxfSTA4SHJVOHNuTXc
# Arguments
- nb_dense_block: number of dense blocks to add to end
- growth_rate: number of filters to add per dense block
- nb_filter: initial number of filters
- reduction: reduction factor of transition blocks.
- dropout_rate: dropout rate
- weight_decay: weight decay factor
- classes: optional number of classes to classify images
- weights_path: path to pre-trained weights
# Returns
- A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global CONCAT_AXIS
if K.image_dim_ordering() == 'tf':
CONCAT_AXIS = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
CONCAT_AXIS = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
tensor_x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
tensor_x = Conv2D(nb_filter, (7, 7),
strides=(2, 2),
name='conv1',
use_bias=False)(tensor_x)
tensor_x = BatchNormalization(epsilon=eps,
axis=CONCAT_AXIS,
name='conv1_bn')(tensor_x)
tensor_x = Scale(axis=CONCAT_AXIS, name='conv1_scale')(tensor_x)
tensor_x = Activation('relu', name='relu1')(tensor_x)
tensor_x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(tensor_x)
tensor_x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(tensor_x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
tensor_x, nb_filter = dense_block(tensor_x, stage, nb_layers[block_idx], nb_filter, \
growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
# Add transition_block
tensor_x = transition_block(tensor_x, stage, nb_filter, compression=compression, \
dropout_rate=dropout_rate, weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
tensor_x, nb_filter = dense_block(tensor_x, final_stage, nb_layers[-1], nb_filter, \
growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
tensor_x = BatchNormalization(epsilon=eps,
axis=CONCAT_AXIS,
name='conv' + str(final_stage) +
'_blk_bn')(tensor_x)
tensor_x = Scale(axis=CONCAT_AXIS,
name='conv' + str(final_stage) + '_blk_scale')(tensor_x)
tensor_x = Activation('relu',
name='relu' + str(final_stage) + '_blk')(tensor_x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(tensor_x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'imagenet_models/densenet121_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'imagenet_models/densenet121_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
# # 固定参数
# for layer in model.layers:
# layer.trainable = False
# # Truncate and replace softmax layer for transfer learning
# # Cannot use model.layers.pop() since model is not of Sequential() type
# # The method below works since pre-trained weights are stored in layers but not in the model
# x_newfc = GlobalAveragePooling2D(name='pool'+str(final_stage))(tensor_x)
# x_newfc = Dense(num_classes, name='fc6')(x_newfc)
# x_newfc = Activation('softmax', name='prob')(x_newfc)
# new_model = Model(img_input, x_newfc)
# # Learning rate is changed to 0.001
# sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
# new_model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
return model
def cnn_model(img_rows, img_cols, color_type=1, num_classes=None):
eps = 1.1e-5
# 处理尺寸不同的后端
global bn_axis
# ## th : if image_dim_ordering = channels_first”数据组织为（3,128,128,128），
# ## tf : ...=“channels_last”数据组织为（128,128,128,3）
if K.image_data_format() == 'channels_last':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
# x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
# 7X7 ==> 3X3 + 3X3 + 3X3
x = Conv2D(32, (3, 3), strides=(2, 2), name='conv1a', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1a')(x)
x = Scale(axis=bn_axis, name='scale_conv1a')(x)
x = Activation('relu', name='conv1a_relu')(x)
x = Conv2D(32, (3, 3), strides=(2, 2), name='conv1b', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1b')(x)
x = Scale(axis=bn_axis, name='scale_conv1b')(x)
x = Activation('relu', name='conv1b_relu')(x)
x = Conv2D(64, (3, 3), strides=(1, 1), name='conv1c', use_bias=False)(x)
#
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1c')(x)
x = Scale(axis=bn_axis, name='scale_conv1c')(x)
x = Activation('relu', name='conv1c_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block_D(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b'+str(i))
x = conv_block_D(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b'+str(i))
x = conv_block_D(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block_tanh(x, 3, [512, 512, 2048], stage=5, block='c')
x_fc = AveragePooling2D((4, 4), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dropout(0.5)(x_fc)
# Dense(units:输出维度，activation=激活函数)全连接层（对上一层的神经元进行全部连接，实现特征的非线性组合）
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
if K.image_data_format() == 'channels_first':
# 使用预先训练过的权重进行Theano后端
weights_path = 'models/resnet152_v1d-cddbc86f.params'
# weights_path = 'models/resnet152_v1d-cddbc86f.params'
else:
# 在Tensorflow后端使用预先训练的权重
weights_path = 'models/resnet152_v1d-cddbc86f.params'
# weights_path = 'models/resnet152_v1d-cddbc86f.params'
model.load_weights(weights_path, by_name=True)
# 截断并替换softmax层以进行传输学习
# 不能使用model.layers.pop（），因为model不是Sequential（）类型
# 下面的方法有效，因为预训练的权重存储在图层中但不存储在模型中
x_newfc = AveragePooling2D((4, 4), name='avg_pool')(x)
x_newfc = Flatten()(x_newfc)
x_newfc = Dropout(0.5)(x_newfc)
x_newfc = Dense(num_classes, activation='softmax', name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# 学习率改为0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
return model
def densenet169_model(img_dim, nb_dense_block=4, growth_rate=32, nb_filter=64, reduction=0.5, dropout_rate=0.2, weight_decay=1e-4, num_classes=17):
'''
DenseNet 169 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfN0d3T1F1MXg0NlU
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfSEc5UC1ROUFJdmM
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = -1
else:
concat_axis = 1
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6,12,32,32] # For DenseNet-169
# Initial convolution
img_input = Input(shape=img_dim, name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis)(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx+2
x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
# Add transition_block
x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv'+str(final_stage)+'_blk_bn')(x)
x = Scale(axis=concat_axis)(x)
x = Activation('relu', name='relu'+str(final_stage)+'_blk')(x)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = GlobalAveragePooling2D(name='pool'+str(final_stage))(x)
x_newfc = Dense(num_classes, name='fc6')(x_newfc)
x_newfc = Activation('softmax', name='prob')(x_newfc)
model = Model(img_input, x_newfc, name='densenet')
# Learning rate is changed to 0.001
# sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
# model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
return model
def densenet161_model(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=48,
nb_filter=96,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4,
num_classes=None):
'''
DenseNet 161 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfVnlCMlBGTDR3RGs
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfUDZwVjU2cFNidTA
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 96
nb_layers = [6, 12, 36, 24] # For DenseNet-161
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'imagenet_models/densenet161_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'imagenet_models/densenet161_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_newfc = Dense(num_classes, name='fc6')(x_newfc)
x_newfc = Activation('softmax', name='prob')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def ResNet152(img_rows, img_cols, color_type=1, include_top=True):
"""
Resnet 152 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfZHhUT3lWVWxRN28/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfeXExMzNNOHpEODg/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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')
x_fc_emb = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc_emb)
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'imagenet_models/resnet152_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'imagenet_models/resnet152_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
if include_top:
model = Model(img_input, x_fc_emb)
else:
model = Model(img_input, x)
return model
def ResNet(input_shape=(224, 224, 3), classes=196):
"""
Implementation of the popular ResNet50 the following architecture:
CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
-> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
Arguments:
input_shape -- shape of the images of the dataset
classes -- integer, number of classes
Returns:
model -- a Model() instance in Keras
"""
#Set epsilon value for Batch Normalization
eps = 1.1e-5
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
use_bias=False,
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(epsilon=eps, axis=3, name='bn_conv1')(X)
X = Scale(axis=3, name='scale_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X,
f=3,
filters=[64, 64, 256],
stage=2,
block='a',
s=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')
# Stage 3 (Default Identity blocks = 3)
X = convolutional_block(X,
f=3,
filters=[128, 128, 512],
stage=3,
block='a',
s=2)
for i in range(1, 8):
X = identity_block(X, 3, [128, 128, 512], stage=3, block='b' + str(i))
# Stage 4 (Default Identity blocks = 5)
X = convolutional_block(X,
f=3,
filters=[256, 256, 1024],
stage=4,
block='a',
s=2)
for i in range(1, 36):
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b' + str(i))
# Stage 5
X = convolutional_block(X,
f=3,
filters=[512, 512, 2048],
stage=5,
block='a',
s=2)
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
# First output layer
Xfc = AveragePooling2D(pool_size=(2, 2), padding='valid',
name="avg_pool")(X)
Xfc = Flatten()(Xfc)
Xfc = Dense(1000, activation='softmax', name='fc1000' + str(classes))(Xfc)
#Transfer learning from pretrained weights
model = Model(inputs=X_input,
outputs=Xfc,
name='Cifar10_transfer_learning')
# model.load_weights('models/resnet152_weights_tf.h5', by_name=True)
# Switch to the final output layer
Xfc2 = AveragePooling2D((7, 7), name='avg_pool')(X)
Xfc2 = Flatten()(Xfc2)
Xfc2 = Dense(classes, activation='softmax', name='fc' + str(classes))(Xfc2)
# Create model
model = Model(inputs=X_input, outputs=Xfc2, name='ResNet150')
return model
def MANs_model():
'''
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
nb_dense_block = 4
growth_rate = 48
reduction = 0.5
dropout_rate = 0.0
weight_decay = 1e-4
compression = 1.0 - reduction
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
nb_filter = 96
nb_layers = [6, 12, 36, 24] # For DenseNet-161
nb_lstm = 128 # For TARM
## Temporal Attention Recalibration Module(TARM) for three channel coordinate feature
img_channel1 = Lambda(lambda x: x[:, :, :, 0])(img_input)
img_reshape = Reshape((num_frame, feature_dim))(img_channel1)
img_dense = Dense(nb_lstm)(img_reshape)
#obtain the memory information
lstm_output = Bidirectional(GRU(nb_lstm,
kernel_initializer='orthogonal',
recurrent_initializer='orthogonal',
dropout=0,
recurrent_dropout=0,
kernel_regularizer=reg,
return_sequences=True),
merge_mode='sum')(img_dense)
lstm_weight = Lambda(attention,
arguments={'nb_lstm': nb_lstm},
output_shape=[num_frame, nb_lstm])(img_dense)
lstm_output = multiply([lstm_output, lstm_weight])
lstm = Dense(feature_dim)(lstm_output)
lstm1 = add(
[img_reshape, lstm]
) # a residual module, adding by the memory information and temporal attention recalibration information
## channel 2
img_channel2 = Lambda(lambda x: x[:, :, :, 1])(img_input)
img_reshape = Reshape((num_frame, feature_dim))(img_channel2)
img_dense = Dense(nb_lstm)(img_reshape)
lstm_output = Bidirectional(GRU(nb_lstm,
kernel_initializer='orthogonal',
recurrent_initializer='orthogonal',
dropout=0,
recurrent_dropout=0,
kernel_regularizer=reg,
return_sequences=True),
merge_mode='sum')(img_dense)
lstm_weight = Lambda(attention,
arguments={'nb_lstm': nb_lstm},
output_shape=[num_frame, nb_lstm])(img_dense)
lstm_output = multiply([lstm_output, lstm_weight])
lstm = Dense(feature_dim)(lstm_output)
lstm2 = add([img_reshape, lstm])
## channel 3
img_channel3 = Lambda(lambda x: x[:, :, :, 2])(img_input)
img_reshape = Reshape((num_frame, feature_dim))(img_channel3)
img_dense = Dense(nb_lstm)(img_reshape)
lstm_output = Bidirectional(GRU(nb_lstm,
kernel_initializer='orthogonal',
recurrent_initializer='orthogonal',
dropout=0,
recurrent_dropout=0,
kernel_regularizer=reg,
return_sequences=True),
merge_mode='sum')(img_dense)
lstm_weight = Lambda(attention,
arguments={'nb_lstm': nb_lstm},
output_shape=[num_frame, nb_lstm])(img_dense)
lstm_output = multiply([lstm_output, lstm_weight])
lstm = Dense(feature_dim)(lstm_output)
lstm3 = add([img_reshape, lstm])
lstm1 = Reshape((224, 224, 1))(lstm1)
lstm2 = Reshape((224, 224, 1))(lstm2)
lstm3 = Reshape((224, 224, 1))(lstm3)
x = concatenate([lstm1, lstm2, lstm3], axis=-1)
## Spatial Convolution Module(SCM)
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(x)
x = Conv2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False,
kernel_regularizer=reg)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_new = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_new = Dense(60, name='fc6_new')(x_new)
x_new = Activation('softmax', name='prob_new')(x_new)
model = Model(img_input, x_new)
model.load_weights('densenet161_weights_tf.h5', by_name='true')
return model
def network(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4,
num_classes=None,
isscratch=False):
'''
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
concat_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(nb_filter, (7, 7), name='conv1', use_bias=False,
strides=(2, 2))(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
if isscratch:
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
model.load_weights('imagenet_models/densenet121_weights_tf.h5',
by_name=True)
x_newfc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_newfc = Dense(num_classes, name='fc6')(x_newfc)
x_newfc = Activation('softmax', name='prob')(x_newfc)
model = Model(img_input, x_newfc)
return model
def densenet121_model(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.5,
dropout_rate=0.,
weight_decay=1e-4,
num_classes=None):
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
concat_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(nb_filter,
kernel_size=(7, 7),
strides=(2, 2),
name='conv1',
use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'pre_train/imagenet_models/densenet121_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'pre_train/imagenet_models/densenet121_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_newfc = Dropout(0.5)(x_newfc)
x_newfc = Dense(num_classes,
name='fc6',
kernel_regularizer=regularizers.l2(l2_lambda),
kernel_initializer='he_uniform')(x_newfc)
x_newfc = Activation('sigmoid', name='prob')(x_newfc)
model = Model(img_input, x_newfc)
nadam1 = keras.optimizers.Nadam(lr=0.0003,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
schedule_decay=0.0)
#sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=nadam1,
loss='binary_crossentropy',
metrics=['accuracy'])
return model
def build_resnet152_model(self, inputs):
"""
Resnet 152 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfZHhUT3lWVWxRN28/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfeXExMzNNOHpEODg/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
#img_rows = self.x_shape[0]
#img_cols = self.x_shape[1]
#color_type = self.x_shape[2]
# Handle Dimension Ordering for different backends
global bn_axis
bn_axis = 3
img_input = inputs
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(64, 7, 7, subsample=(2, 2), name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
x = self.conv_block(x,
3, [64, 64, 256],
stage=2,
block='a',
strides=(1, 1))
x = self.identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = self.identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x = self.conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = self.identity_block(x,
3, [128, 128, 512],
stage=3,
block='b' + str(i))
x = self.conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = self.identity_block(x,
3, [256, 256, 1024],
stage=4,
block='b' + str(i))
x = self.conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = self.identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = self.identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
x_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
return [model, x]
def DenseNet(nb_dense_block=4, growth_rate=32, nb_filter=64, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, classes=1000, weights_path=None):
'''Instantiate the DenseNet architecture,
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6,12,32,32] # For DenseNet-169
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(nb_filter, (7, 7), subsample=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx+2
x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
# Add transition_block
x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv'+str(final_stage)+'_blk_bn')(x)
x = Scale(axis=concat_axis, name='conv'+str(final_stage)+'_blk_scale')(x)
x = Activation('relu', name='relu'+str(final_stage)+'_blk')(x)
x = GlobalAveragePooling2D(name='pool'+str(final_stage))(x)
x = Dense(classes, name='fc6')(x)
x = Activation('softmax', name='prob')(x)
model = Model(img_input, x, name='densenet')
if weights_path is not None:
model.load_weights(weights_path)
return model
def densenet161_model(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=48,
nb_filter=96,
reduction=0.5,
dropout_rate=0,
weight_decay=1e-4,
weights_file=None):
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 96
nb_layers = [6, 12, 36, 24] # For DenseNet-161
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(nb_filter, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
model = Model(img_input, x, name='densenet')
# model = keras.applications.mobilenet.MobileNet()
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'imagenet_models/densenet161_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'imagenet_models/densenet161_weights_tf.h5'
if weights_file is None:
model.load_weights(weights_path, by_name=True)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
# Our Hierarchical Mult-task
# Part 1. Global regression
global_fc = Dense(512, name='global_feature')(x_newfc)
global_fc = Dense(1, name='global_fc')(global_fc)
global_fc = Activation('sigmoid', name='global_loss')(global_fc)
# Part 2. Attribute regression
attribute_fc = Dense(512, name='attribute_feature')(x_newfc)
attribute1_fc = Dense(256, name='attribute1_feature')(attribute_fc)
attribute1_fc = Dense(1, name='attribute1_fc')(attribute1_fc)
attribute1_fc = Activation('sigmoid',
name='attribute1_loss')(attribute1_fc)
attribute2_fc = Dense(256, name='attribute2_feature')(attribute_fc)
attribute2_fc = Dense(1, name='attribute2_fc')(attribute2_fc)
attribute2_fc = Activation('sigmoid',
name='attribute2_loss')(attribute2_fc)
attribute3_fc = Dense(256, name='attribute3_feature')(attribute_fc)
attribute3_fc = Dense(1, name='attribute3_fc')(attribute3_fc)
attribute3_fc = Activation('sigmoid',
name='attribute3_loss')(attribute3_fc)
attribute4_fc = Dense(256, name='attribute4_feature')(attribute_fc)
attribute4_fc = Dense(1, name='attribute4_fc')(attribute4_fc)
attribute4_fc = Activation('sigmoid',
name='attribute4_loss')(attribute4_fc)
attribute5_fc = Dense(256, name='attribute5_feature')(attribute_fc)
attribute5_fc = Dense(1, name='attribute5_fc')(attribute5_fc)
attribute5_fc = Activation('sigmoid',
name='attribute5_loss')(attribute5_fc)
attribute6_fc = Dense(256, name='attribute6_feature')(attribute_fc)
attribute6_fc = Dense(1, name='attribute6_fc')(attribute6_fc)
attribute6_fc = Activation('sigmoid',
name='attribute6_loss')(attribute6_fc)
model = Model(img_input, [
global_fc, attribute1_fc, attribute2_fc, attribute3_fc, attribute4_fc,
attribute5_fc, attribute6_fc
])
if weights_file is not None:
model.load_weights(weights_file)
# Learning rate is changed to 0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss=losses.mean_squared_error)
return model
def resnet152_model(img_rows, img_cols, color_type=1, num_classes=None):
"""
Resnet 152 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfZHhUT3lWVWxRN28/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfeXExMzNNOHpEODg/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1,8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b'+str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1,36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b'+str(i))
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')
x_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'models/resnet152_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'models/resnet152_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_newfc = Flatten()(x_newfc)
x_newfc = Dense(num_classes, activation='softmax', name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
#model.load_weights("./models/model.54-0.79.hdf5")
model.compile(optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False), loss='categorical_crossentropy', metrics=['accuracy'])
return model
def resnet101_model(img_rows, img_cols, color_type=1, trainable=True):
"""
Resnet 101 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfdUV1MHJhelpnSG8/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfTmRRVmpGWDczaXM/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding',
trainable=trainable)(img_input)
x = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
use_bias=False,
trainable=trainable)(x)
x = BatchNormalization(epsilon=eps,
axis=bn_axis,
name='bn_conv1',
trainable=trainable)(x)
x = Scale(axis=bn_axis, name='scale_conv1', trainable=trainable)(x)
x = Activation('relu', name='conv1_relu', trainable=trainable)(x)
layer1 = x
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='pool1',
trainable=trainable)(x)
x = conv_block(x,
3, [64, 64, 256],
stage=2,
block='a',
strides=(1, 1),
trainable=trainable)
x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='b',
trainable=trainable)
x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='c',
trainable=trainable)
layer2 = x
x = conv_block(x,
3, [128, 128, 512],
stage=3,
block='a',
trainable=trainable)
for i in range(1, 3):
x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='b' + str(i),
trainable=trainable)
layer3 = x
x = conv_block(x,
3, [256, 256, 1024],
stage=4,
block='a',
trainable=trainable)
for i in range(1, 23):
# if i == 22:
# x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i), trainable=True)
# else:
x = identity_block(x,
3, [256, 256, 1024],
stage=4,
block='b' + str(i),
trainable=trainable)
layer4 = x
x = conv_block(x,
3, [512, 512, 2048],
stage=5,
block='a',
trainable=trainable)
x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='b',
trainable=trainable)
x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='c',
trainable=trainable)
# x_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
# x_fc = Flatten()(x_fc)
# x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
# model = Model(img_input, x_fc)
model = Model(img_input, x)
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = '../imagenet_models/resnet101_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = '../imagenet_models/resnet101_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
return model, [layer1, layer2, layer3, layer4]
