def build(width, height, kernel, depth, classes):
input_shape = (height, width, depth)
if K.image_data_format() == "channels_first":
input_shape = (depth, height, width)
base = mobilenet_v2(weights="imagenet",
include_top=False,
input_tensor=Input(shape=input_shape))
head = base.output
head = AveragePooling2D(pool_size=(7, 7))(head)
head = Flatten(name="flatten")(head)
head = Dense(128, activation="relu")(head)
head = Dropout(0.5)(head)
head = Dense(classes, activation="softmax")(head)
model = Model(inputs=base.input, outputs=head)
for layer in base.layers:
layer.trainable = False
return model
def inception_A(input):
if K.image_dim_ordering() == "th":
channel_axis = 1
else:
channel_axis = -1
a1 = AveragePooling2D((3, 3), strides=(1, 1), border_mode='same')(input)
a1 = Convolution2D(96, 1, 1, activation='relu', border_mode='same')(a1)
a2 = Convolution2D(96, 1, 1, activation='relu', border_mode='same')(input)
a3 = Convolution2D(64, 1, 1, activation='relu', border_mode='same')(input)
a3 = Convolution2D(96, 3, 3, activation='relu', border_mode='same')(a3)
a4 = Convolution2D(64, 1, 1, activation='relu', border_mode='same')(input)
a4 = Convolution2D(96, 3, 3, activation='relu', border_mode='same')(a4)
a4 = Convolution2D(96, 3, 3, activation='relu', border_mode='same')(a4)
m = merge([a1, a2, a3, a4], mode='concat', concat_axis=channel_axis)
m = BatchNormalization(axis=channel_axis)(m)
m = Activation('relu')(m)
return m
def block_inception_a(input, idx):
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
branch_0 = conv2d_bn(input, 96, 1, 1)
branch_1 = conv2d_bn(input, 64, 1, 1)
branch_1 = conv2d_bn(branch_1, 96, 3, 3)
branch_2 = conv2d_bn(input, 64, 1, 1)
branch_2 = conv2d_bn(branch_2, 96, 3, 3)
branch_2 = conv2d_bn(branch_2, 96, 3, 3)
branch_3 = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(input)
branch_3 = conv2d_bn(branch_3, 96, 1, 1)
x = concatenate([branch_0, branch_1, branch_2, branch_3],
axis=channel_axis,
name="mixed_inception_a_{0}".format(idx))
return x
def inception_v4(num_classes, dropout_keep_prob, weights, include_top):
# Input Shape is 299 x 299 x 3 (tf) or 3 x 299 x 299 (th)
if K.image_data_format() == 'channels_first':
inputs = Input((3, 299, 299))
else:
inputs = Input((299, 299, 3))
# Make inception base
x = inception_v4_base(inputs)
if include_top:
# 1 x 1 x 1536
x = AveragePooling2D((8, 8), padding='valid')(x)
x = Dropout(dropout_keep_prob)(x)
x = Flatten()(x)
dense1 = Dense(units=num_classes, activation='softmax')(x)
model = Model(inputs, x, name='inception_v4')
model.load_weights('inception-v4_weights_tf_dim_ordering_tf_kernels.h5',
by_name=True)
return model
def conv_bn_pool(inp_tensor,
conv_filters,
conv_kernel_size,
conv_strides,
conv_pad,
pool_type="",
pool_size=(2, 2),
pool_strides=None):
x = ZeroPadding2D(padding=conv_pad)(inp_tensor)
x = Conv2D(filters=conv_filters,
kernel_size=conv_kernel_size,
strides=conv_strides,
padding='valid')(x)
x = BatchNormalization(epsilon=1e-5, momentum=1)(x)
x = Activation('relu')(x)
if pool_type == 'max':
return MaxPooling2D(pool_size=pool_size, strides=pool_strides)(x)
elif pool_type == 'avg':
return AveragePooling2D(pool_size=pool_size, strides=pool_strides)(x)
return x
def __call__(self):
logging.debug("Creating model...")
inputs = Input(shape=self._input_shape)
x = Conv2D(32, (3, 3), activation='relu')(inputs)
x = MaxPooling2D(2, 2)(x)
x = Conv2D(32, (3, 3), activation='relu')(x)
x = MaxPooling2D(2, 2)(x)
x = Conv2D(64, (3, 3), activation='relu')(x)
y = Conv2D(32, (3, 3), activation='relu')(inputs)
y = MaxPooling2D(2, 2)(y)
y = Conv2D(32, (3, 3), activation='relu')(y)
y = MaxPooling2D(2, 2)(y)
y = Conv2D(64, (3, 3), activation='tanh')(y)
z = Multiply()([x, y])
z = BatchNormalization(axis=self._channel_axis)(z)
# Classifier block
pool = AveragePooling2D(pool_size=(8, 8),
strides=(1, 1),
padding="same")(z)
flatten = Flatten()(pool)
predictions_g = Dense(units=2,
kernel_initializer=self._weight_init,
use_bias=self._use_bias,
kernel_regularizer=l2(self._weight_decay),
activation="softmax")(flatten)
predictions_a = Dense(units=21,
kernel_initializer=self._weight_init,
use_bias=self._use_bias,
kernel_regularizer=l2(self._weight_decay),
activation="softmax")(flatten)
model = Model(inputs=inputs, outputs=[predictions_g, predictions_a])
return model
def inception_B(input):
channel_axis = -1
b1 = conv_block(input, 384, 1, 1)
b2 = conv_block(input, 192, 1, 1)
b2 = conv_block(b2, 224, 1, 7)
b2 = conv_block(b2, 256, 7, 1)
b3 = conv_block(input, 192, 1, 1)
b3 = conv_block(b3, 192, 7, 1)
b3 = conv_block(b3, 224, 1, 7)
b3 = conv_block(b3, 224, 7, 1)
b3 = conv_block(b3, 256, 1, 7)
b4 = AveragePooling2D((3, 3), strides=(1, 1), border_mode='same')(input)
b4 = conv_block(b4, 128, 1, 1)
#m = merge([b1, b2, b3, b4], mode='concat', concat_axis=channel_axis)
m = concatenate([b1, b2, b3, b4], axis=channel_axis)
return m
def inception_C(input):
c1 = AveragePooling2D((3, 3), strides=(1, 1), border_mode='same')(input)
c1 = Convolution2D(256, 1, 1, activation='relu', border_mode='same')(c1)
c2 = Convolution2D(256, 1, 1, activation='relu', border_mode='same')(input)
c3 = Convolution2D(384, 1, 1, activation='relu', border_mode='same')(input)
c3_1 = Convolution2D(256, 1, 3, activation='relu', border_mode='same')(c3)
c3_2 = Convolution2D(256, 3, 1, activation='relu', border_mode='same')(c3)
c4 = Convolution2D(384, 1, 1, activation='relu', border_mode='same')(input)
c4 = Convolution2D(192, 1, 3, activation='relu', border_mode='same')(c4)
c4 = Convolution2D(224, 3, 1, activation='relu', border_mode='same')(c4)
c4_1 = Convolution2D(256, 3, 1, activation='relu', border_mode='same')(c4)
c4_2 = Convolution2D(256, 1, 3, activation='relu', border_mode='same')(c4)
m = merge([c1, c2, c3_1, c3_2, c4_1, c4_2],
mode='concat',
concat_axis=channel_axis)
m = BatchNormalization(axis=1)(m)
m = Activation('relu')(m)
return m
def MiniGoogLeNet(width, height, depth, classes):
input_shape = height, width, depth
chan_dim = -1
if K.image_data_format() == 'channels_first':
input_shape = depth, height, width
chan_dim = 1
# define the model input and first CONV module
inputs = Input(shape=input_shape)
x = conv_module(inputs, 96, 3, 3, (1, 1), chan_dim)
# two inception modules followed by a downsample module
x = inception_module(x, 32, 32, chan_dim)
x = inception_module(x, 32, 48, chan_dim)
x = downample_module(x, 80, chan_dim)
# for inception modules followed by a downsample module
x = inception_module(x, 112, 48, chan_dim)
x = inception_module(x, 96, 64, chan_dim)
x = inception_module(x, 80, 80, chan_dim)
x = inception_module(x, 48, 96, chan_dim)
x = downample_module(x, 96, chan_dim)
# two inception modules followed by global POOL and dropout
x = inception_module(x, 176, 160, chan_dim)
x = inception_module(x, 176, 160, chan_dim)
x = AveragePooling2D((7, 7))(x)
x = Dropout(.5)(x)
# softmax classifier
x = Flatten()(x)
x = Dense(classes)(x)
x = Activation('softmax')(x)
# create model
model = Model(inputs, x, name='mini googlenet')
return model
def create(self, size, include_top):
input_shape = (3, ) + size
img_input = Input(shape=input_shape)
bn_axis = 1
x = Lambda(self.vgg_preprocess)(img_input)
x = ZeroPadding2D((3, 3))(x)
x = Conv2D(64, 7, 7, strides=(2, 2), name='conv1')(x) # Keras2
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [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 n in ['b', 'c', 'd']:
x = identity_block(x, 3, [128, 128, 512], stage=3, block=n)
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for n in ['b', 'c', 'd', 'e', 'f']:
x = identity_block(x, 3, [256, 256, 1024], stage=4, block=n)
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 = AveragePooling2D((7, 7), name='avg_pool')(x)
x = Flatten()(x)
x = Dense(1000, activation='softmax', name='fc1000')(x)
fname = 'resnet50.h5'
else:
fname = 'resnet_nt.h5'
self.img_input = img_input
self.model = Model(self.img_input, x)
convert_all_kernels_in_model(self.model)
self.model.load_weights(self.FILE_PATH + fname)
def marge_resnet_googlenet():
ip = Input(shape=init)
layers = 1
conv_n = 0
#=====================================================================================================
if if_n[0]:
for i in range(0, loop):
x, l, c = resnet_block(ip, dropout_n=0)
layers += l
conv_n += c
x = LeakyReLU(alpha=config.alpha_lrelu)(x)
x = Dropout(rate=dropout[0])(x)
layers += 2
#=====================================================================================================
if if_n[1]:
for i in range(0, loop):
x, l, c = resnet_block(ip, dropout_n=0)
layers += l
conv_n += c
x = LeakyReLU(alpha=config.alpha_lrelu)(x)
x = Dropout(rate=dropout[0])(x)
layers += 2
#=====================================================================================================
if if_n[2]:
for i in range(0, loop):
x, l, c = resnet_block(ip, dropout_n=0)
layers += l
conv_n += c
x = LeakyReLU(alpha=config.alpha_lrelu)(x)
x = Dropout(rate=dropout[0])(x)
layers += 2
#=====================================================================================================
x = AveragePooling2D((pool, pool))(x)
x = Flatten()(x)
x = Dense(nb_classes, activation='softmax')(x)
layers += 3
model = Model(ip, x)
return [model, layers, conv_n]
def create_parallel_model(self):
'''
Creates A keras Model With a Parallel Branch for race detection.
:return: None
'''
if self.__model is None or len(self.__model.layers) == 32:
self.create_model()
if self.__training:
self.__model.load_weights(self.AGE_GENDER_WEIGHTS)
if self.__training:
for layer in self.__model.layers:
layer.trainable = False
batch_norm = BatchNormalization(axis=self._channel_axis, name='batch_norm_parallel_branch')(self.__conv4_copy)
relu = Activation("relu", name='activation_parallel_branch')(batch_norm)
# Classifier block
pool = AveragePooling2D(pool_size=(8, 8), strides=(1, 1), padding="same", name='pool_parallel_branch')(relu)
new_flatten = Flatten(name='flatten_parallel_branch')(pool)
predictions_r = Dense(units=5, kernel_initializer=self._weight_init, use_bias=self._use_bias,
kernel_regularizer=l2(self._weight_decay), activation="softmax", name = 'race')(new_flatten)
self.__model = Model(self.__model.layers[0].input, [self.__model.layers[-2].output, self.__model.layers[-1].output, predictions_r])
def custom_cnn(input):
x = Conv2D(12, (3, 3), padding='same', activation='relu')(input)
x = Dropout(0.20)(
x
) # very important. dropout is inserted into somewhere between consecutive Conv2D layers, rather than after max pooling layers
x = Conv2D(18, (3, 3), activation='relu', padding='same')(x)
x = AveragePooling2D(pool_size=(3, 3), dim_ordering="th")(x)
y = Conv2D(18, (3, 3), activation='relu', padding='same')(x)
y = Dropout(0.20)(y)
y = Conv2D(18, (3, 3), activation='relu', padding='same')(y)
y = MaxPooling2D(pool_size=(3, 3), dim_ordering="th")(y)
z = Flatten()(y)
z = Dropout(0.20)(z)
z = Dense(128, activation='relu')(z)
z = Dense(nb_classes, activation='softmax', name='prediction')(z)
model = Model(input=input, output=z)
model.summary()
return model
def ShallowConvNet(input_shape):
""" Keras implementation of the Shallow Convolutional Network as described
in Schirrmeister et. al. (2017), arXiv 1703.0505
Assumes the input is a 2-second EEG signal sampled at 128Hz. Note that in
the original paper, they do temporal convolutions of length 25 for EEG
data sampled at 250Hz. We instead use length 13 since the sampling rate is
roughly half of the 250Hz which the paper used. The pool_size and stride
in later layers is also approximately half of what is used in the paper.
ours original paper
pool_size 1, 35 1, 75
strides 1, 7 1, 15
conv filters 1, 13 1, 25
"""
# if K.image_data_format() == 'channels_first':
# input_shape = (1, Chans, Samples)
# else:
# input_shape = (Chans, Samples, 1)
# print(input_shape)
# start the model
input_EEG = Input(input_shape)
block1 = Conv2D(10, (1, 25),
input_shape=(1, n_ch, n_samp),
kernel_constraint=max_norm(2.))(input_EEG)
block1 = Conv2D(10, (n_ch, 1),
use_bias=False,
kernel_constraint=max_norm(2.))(block1)
block1 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block1)
block1 = Activation(square)(block1)
block1 = AveragePooling2D(pool_size=(1, 30), strides=(1, 10))(block1)
block1 = Activation(safe_log)(block1)
block1 = Dropout(dropout_rate)(block1)
flatten = Flatten()(block1)
dense = Dense(n_class, kernel_constraint=max_norm(0.5))(flatten)
softmax = Activation('softmax')(dense)
return Model(inputs=input_EEG, outputs=softmax)
def inception_B(input):
if K.image_dim_ordering() == "th":
channel_axis = 1
else:
channel_axis = -1
b1 = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), padding='same')(input)
b1 = conv_block(b1, 128, 1, 1)
b2 = conv_block(input, 384, 1, 1)
b3 = conv_block(input, 192, 1, 1)
b3 = conv_block(b3, 224, 1, 7)
b3 = conv_block(b3, 256, 7, 1)
b4 = conv_block(input, 192, 1, 1)
b4 = conv_block(b4, 192, 7, 1)
b4 = conv_block(b4, 224, 1, 7)
b4 = conv_block(b4, 224, 7, 1)
b4 = conv_block(b4, 256, 1, 7)
m = concatenate([b1, b2, b3, b4], axis=channel_axis)
return m
def __init__(self, weights_path=None):
self.inp = Input(shape=(224, 224, 1))
self.out = ZeroPadding2D((3, 3))(self.inp)
self.out = Convolution2D(64, 7, 7, subsample=(2, 2))(self.out)
self.out = BatchNormalization()(self.out)
self.out = Activation('relu')(self.out)
self.out = MaxPooling2D((3, 3), strides=(2, 2))(self.out)
self.out = conv_block(self.out, [64, 64, 256])
self.out = identity_block(self.out, [64, 64, 256])
self.out = identity_block(self.out, [64, 64, 256])
self.out = conv_block(self.out, [128, 128, 512])
self.out = identity_block(self.out, [128, 128, 512])
self.out = identity_block(self.out, [128, 128, 512])
self.out = identity_block(self.out, [128, 128, 512])
self.out = conv_block(self.out, [256, 256, 1024])
self.out = identity_block(self.out, [256, 256, 1024])
self.out = identity_block(self.out, [256, 256, 1024])
self.out = identity_block(self.out, [256, 256, 1024])
self.out = identity_block(self.out, [256, 256, 1024])
self.out = identity_block(self.out, [256, 256, 1024])
self.out = conv_block(self.out, [512, 512, 2048])
self.out = identity_block(self.out, [512, 512, 2048])
self.out = identity_block(self.out, [512, 512, 2048])
self.out = AveragePooling2D((7, 7))(self.out)
self.out = Flatten()(self.out)
self.out = Dense(1)(self.out)
self.model = Model(self.inp, self.out)
self.model.compile(optimizer=adam(), loss='mse')
if os.path.exists(weights_path):
self.model.load_weights(weights_path)
print(
"********************Load Model Success*********************")
def inception_B(x_input):
"""17*17 卷积块"""
global INCEPTION_B_COUNT
INCEPTION_B_COUNT += 1
with K.name_scope('inception_B' + str(INCEPTION_B_COUNT)):
averagepooling_conv1x1 = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), padding='same')(x_input)
averagepooling_conv1x1 = conv_block(averagepooling_conv1x1, 128, 1, 1)
conv1x1 = conv_block(x_input, 384, 1, 1)
conv1x7_1x7 = conv_block(x_input, 192, 1, 1)
conv1x7_1x7 = conv_block(conv1x7_1x7, 224, 1, 7)
conv1x7_1x7 = conv_block(conv1x7_1x7, 256, 1, 7)
conv2_1x7_7x1 = conv_block(x_input, 192, 1, 1)
conv2_1x7_7x1 = conv_block(conv2_1x7_7x1, 192, 1, 7)
conv2_1x7_7x1 = conv_block(conv2_1x7_7x1, 224, 7, 1)
conv2_1x7_7x1 = conv_block(conv2_1x7_7x1, 224, 1, 7)
conv2_1x7_7x1 = conv_block(conv2_1x7_7x1, 256, 7, 1)
merged_vector = concatenate([averagepooling_conv1x1, conv1x1, conv1x7_1x7, conv2_1x7_7x1], axis=-1)
return merged_vector
def add_inceptionC(self, input_layer, list_nb_filter, base_name):
l1_1 = self.add_bn_conv_layer(name=base_name+'_l1_1', input=input_layer, nb_filter=list_nb_filter[0][0], nb_row=1, nb_col=1)
l2_1 = self.add_bn_conv_layer(name=base_name+'_l2_1', input=input_layer, nb_filter=list_nb_filter[1][0], nb_row=1, nb_col=1)
l2_2 = self.add_bn_conv_layer(name=base_name+'_l2_2', input=l2_1, nb_filter=list_nb_filter[1][1], nb_row=1, nb_col=7, padding=(0,3))
l2_3 = self.add_bn_conv_layer(name=base_name+'_l2_3', input=l2_2, nb_filter=list_nb_filter[1][2], nb_row=7, nb_col=1, padding=(3,0))
## padding and nb_row might not match with the lasagne weights
l3_1 = self.add_bn_conv_layer(name=base_name+'_l3_1', input=input_layer, nb_filter=list_nb_filter[2][0], nb_row=1, nb_col=1)
l3_2 = self.add_bn_conv_layer(name=base_name+'_l3_2', input=l3_1, nb_filter=list_nb_filter[2][1], nb_row=7, nb_col=1, padding=(3,0))
l3_3 = self.add_bn_conv_layer(name=base_name+'_l3_3', input=l3_2, nb_filter=list_nb_filter[2][2], nb_row=1, nb_col=7, padding=(0,3))
l3_4 = self.add_bn_conv_layer(name=base_name+'_l3_4', input=l3_3, nb_filter=list_nb_filter[2][3], nb_row=7, nb_col=1, padding=(3,0))
l3_5 = self.add_bn_conv_layer(name=base_name+'_l3_5', input=l3_4, nb_filter=list_nb_filter[2][4], nb_row=1, nb_col=7, padding=(0,3))
l4_1 = self.add_to_graph(ZeroPadding2D(padding=(1,1)), name=base_name+'_14_1', input=input_layer)
l4_2 = self.add_to_graph(AveragePooling2D(pool_size=(3,3), strides=(1,1)), name=base_name+'_14_2', input=l4_1)
l4_3 = self.add_bn_conv_layer(name=base_name+'_l4_3', input=l4_2, nb_filter=list_nb_filter[3][0], nb_row=1, nb_col=1)
self.add_to_graph(Activation("linear"), name=base_name, inputs=[l1_1, l2_3, l3_5, l4_3], merge_mode="concat", concat_axis=1)
self.io.print_info('Added Inception-C {0}'.format(base_name))
def build(width, height, depth, classes):
inputShape = (height, width, depth)
chanDim = -1
if K.image_data_format() == 'channels_first':
inputShape = (depth, height, width)
chanDim = 1
# Define the model input and first CONV module
inputs = Input(shape=inputShape)
x = MiniGoogLenet.conv_module(inputs, 96, 3, 3, (1, 1), chanDim)
# Two inception modules followed by downsampling modules
x = MiniGoogLenet.inception_module(x, 32, 32, chanDim)
x = MiniGoogLenet.inception_module(x, 32, 48, chanDim)
x = MiniGoogLenet.downsample_sample(x, 80, chanDim)
# Four inception modules followed by a downsample module
x = MiniGoogLenet.inception_module(x, 112, 48, chanDim)
x = MiniGoogLenet.inception_module(x, 96, 64, chanDim)
x = MiniGoogLenet.inception_module(x, 80, 80, chanDim)
x = MiniGoogLenet.inception_module(x, 48, 96, chanDim)
x = MiniGoogLenet.downsample_sample(x, 96, chanDim)
# Two inception modules followed by global Pool and dropout
x = MiniGoogLenet.inception_module(x, 176, 160, chanDim)
x = MiniGoogLenet.inception_module(x, 176, 160, chanDim)
x = AveragePooling2D((7, 7))(x)
x = Dropout(0.5)(x)
# Softmax classifier
x = Flatten()(x)
x = Dense(classes)(x)
x = Activation("softmax")(x)
model = Model(inputs, x, name='googlenet')
return model
def _decoder_dense(self, x, num_out, name_suff='', name_out=''):
""" Decoder with one conv2d layer, avg pooling and a fully connected
layer.
Args:
x (tf.Tensor): Input, latent representation.
num_out (int): # of output values.
name_suff (str): Name suffix of layers.
name_out (str): Name of the output layer.
Returns:
tf.Tensor, shape (B, `num_out`).
"""
# Produces (N, 3, 3, 64)
x = Convolution2D(64, (1, 1),
padding='same',
name='conv_1_{}'.format(name_suff))(x)
x = AveragePooling2D((3, 3), padding='same')(x)
x = Flatten()(x)
x = Dense(num_out, name='dense_1_{}'.format(name_suff))(x)
return Activation('linear', name=name_out)(x)
def wlcc( input_shape, nb_classes = 3 ):
'''
Creates a inception v4 network
:param nb_classes: number of classes.txt
:return: Keras Model with 1 input and 1 output
'''
if K.image_dim_ordering() == ‘th’:
channel_axis = 1
else:
channel_axis = -1 # channels_last is default in Keras
init = Input(input_shape)
x = Conv2D( 32, kernel_size = ( 3, 3 ), strides = ( 1, 1 ), activation = 'relu', padding = 'same', input_shape = input_shape )( init )
# x2 = lzwl( init )
x2 = mywl2d( x )
x = Conv2D( 64, kernel_size = ( 3, 3 ), activation = 'relu', padding = 'same', input_shape = input_shape )( x )
x1 = Conv2D( 64, ( 2,2 ), strides = ( 2, 2 ), activation = 'relu', padding = 'valid' )( x )
# Input Shape is 299 x 299 x 3 (tf) or 3 x 299 x 299 (th
branches = [ x1, x2 ]
x = Concatenate( axis = channel_axis )( branches )
x3 = Conv2D( 96, ( 2, 2 ), strides = ( 2, 2 ), activation = 'relu', padding = 'valid' )( x )
# Input Shape is 299 x 299 x 3 (tf) or 3 x 299 x 299 (th)
x4 = mywl2d( x2 )
branches = [ x3, x4 ]
x = Concatenate( axis = channel_axis )( branches )
x = Conv2D( 128, ( 2, 2 ), strides = ( 2, 2 ), activation = 'relu', padding = 'valid' )( x )
# x6 = mywl2d( x4 )
# branches = [ x, x6 ]
# x = Concatenate( axis = channel_axis )( branches )
x = AveragePooling2D( ( 2, 2 ), strides = ( 1, 1 ), padding = 'same' )( x )
# Dropout
x = Dropout( 0.5 )( x )
x = Flatten()( x )
x = Dense( activation = 'relu', units = 512 )( x )
x = Dropout( 0.5 )( x )
# Output
out = Dense( activation = 'softmax', units = nb_classes )( x )
model = Model( init, out, name = 'wlcc' )
return model
def resnet14(input_tensor, n_classes):
x = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(input_tensor)
x = Conv2D(64, (7, 7), strides=(2, 2), padding='valid', name='conv1')(x)
x = BatchNormalization(axis=3, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 64, stage=2, block='a', strides=(1, 1))
x = identity_block(x, 64, stage=2, block='b')
x = conv_block(x, 128, stage=3, block='a')
x = identity_block(x, 128, stage=3, block='b')
x = conv_block(x, 256, stage=4, block='a')
x = identity_block(x, 256, stage=4, block='b')
x = AveragePooling2D((5, 5), name='avg_pool')(x)
x = Flatten()(x)
x = Dense(n_classes, activation='softmax', name='dense')(x)
return Model(input_tensor, x, name='resnet34')
def cifar_resnet(blocks, filters, repetations, input_shape=(3, 32, 32)):
if blocks != len(repetations) or blocks != len(filters):
print "size of blocks, size of repetations, size of filters should match"
return None
input = Input(shape=input_shape)
conv1 = Convolution2D(nb_filter=16,
nb_row=3,
nb_col=3,
border_mode="same",
W_regularizer=l2(l=0.0001),
b_regularizer=l2(l=0.0001))(input)
norm1 = BatchNormalization(mode=0, axis=1)(conv1)
relu1 = Activation("relu")(norm1)
# block_fun = getattr(resnet, "_basic_block")
block_fun = _basic_block
data = relu1
for i in range(blocks):
is_first_layer = False
if i == 0:
is_first_layer = True
data = _residual_block(block_fun,
nb_filters=filters[i],
repetations=repetations[i],
is_first_layer=is_first_layer)(data)
global_pool = AveragePooling2D(pool_size=(8, 8),
strides=(8, 8),
border_mode="valid")(data)
flatten = Flatten()(global_pool)
dense = Dense(output_dim=10,
init="he_normal",
activation="softmax",
W_regularizer=l2(l=0.0001),
b_regularizer=l2(l=0.0001))(flatten)
model = Model(input=input, output=dense)
return model
def build(width, height, depth, classes, stages, filters, reg = 0.0001, bnEps = 2e-5, bnMom = 0.9, dataset = "cifar"):
inputShape = (height, width, depth)
chanDim = -1
if K.image_data_format() == "channels_first":
inputShape = (depth, height, width)
chanDim = 1
inputs = Input(shape = inputShape)
x = BatchNormalization(axis = chanDim, epsilon = bnEps, momentum = bnMom)(inputs)
if dataset == "cifar":
x = Conv2D(filters[0], (3, 3), use_bias = False, padding = "same", kernel_regularizer = l2(reg))(x)
elif dataset == "tiny_imagenet":
x = Conv2D(filters[0], (5, 5), use_bias = False, padding = "same", kernel_regularizer = l2(reg))(x)
x = BatchNormalization(axis = chanDim, epsilon = bnEps, momentum = bnMom)(x)
x = Activation("relu")(x)
x = ZeroPadding2D((1, 1))(x)
x = MaxPooling2D((3, 3), strides = (2, 2))(x)
for i in range(0, len(stages)):
stride = (1, 1) if i == 0 else (2, 2)
x = ResNet.residual_module(x, filters[i + 1], stride, chanDim, red = True, bnEps = bnEps, bnMom = bnMom)
for j in range(0, stages[i] - 1):
x = ResNet.residual_module(x, filters[i + 1], (1, 1), chanDim, bnEps = bnEps, bnMom = bnMom)
x = BatchNormalization(axis = chanDim, epsilon = bnEps, momentum = bnMom)(x)
x = Activation("relu")(x)
x = AveragePooling2D((8, 8))(x)
x = Flatten()(x)
x = Dense(classes, kernel_regularizer = l2(reg))(x)
x = Activation("softmax")(x)
model = Model(inputs, x, name = "resnet")
return model
def build(width, height, depth, classes):
# initialize the input shape to be "channels last" and the
# channels dimension itself
inputShape = (height, width, depth)
chanDim = -1
# if we are using "channels first", update the input shape
# and channels dimension
if K.image_data_format() == "channels_first":
inputShape = (depth, height, width)
chanDim = 1
# define the model input and first CONV module
inputs = Input(shape=inputShape)
x = MiniGoogLeNet.conv_module(inputs, 96, 3, 3, (1, 1),
chanDim)
# two Inception modules followed by a downsample module
x = MiniGoogLeNet.inception_module(x, 32, 32, chanDim)
x = MiniGoogLeNet.inception_module(x, 32, 48, chanDim)
x = MiniGoogLeNet.downsample_module(x, 80, chanDim)
# four Inception modules followed by a downsample module
x = MiniGoogLeNet.inception_module(x, 112, 48, chanDim)
x = MiniGoogLeNet.inception_module(x, 96, 64, chanDim)
x = MiniGoogLeNet.inception_module(x, 80, 80, chanDim)
x = MiniGoogLeNet.inception_module(x, 48, 96, chanDim)
x = MiniGoogLeNet.downsample_module(x, 96, chanDim)
# two Inception modules followed by global POOL and dropout
x = MiniGoogLeNet.inception_module(x, 176, 160, chanDim)
x = MiniGoogLeNet.inception_module(x, 176, 160, chanDim)
x = AveragePooling2D((7, 7))(x)
x = Dropout(0.5)(x)
# softmax classifier
x = Flatten()(x)
x = Dense(classes)(x)
x = Activation("softmax")(x)
# create the model
model = Model(inputs, x, name="googlenet")
# return the constructed network architecture
return model
def make_symbol(input_shape, num_classes=1000):
K.set_image_dim_ordering('th')
data = Input(input_shape)
#stage 1
conv = conv_factory(32, 3, 3, stride=(2, 2))(data)
conv_1 = conv_factory(32, 3, 3)(conv)
conv_2 = conv_factory(64, 3, 3, pad=(1, 1))(conv_1)
pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv_2)
#stage 2
conv_3 = conv_factory(80)(pool1)
conv_4 = conv_factory(192, 3, 3)(conv_3)
pool2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv_4)
#stage 3
in3a = inception7a(pool2, 64, 64, 96, 96, 48, 64, "avg", 32)
in3b = inception7a(in3a, 64, 64, 96, 96, 48, 64, "avg", 64)
in3c = inception7a(in3b, 64, 64, 96, 96, 48, 64, "avg", 64)
in3d = inception7b(in3c, 384, 64, 96, 96, "max")
# stage 4
in4a = inception7c(in3d, 192, 128, 128, 192, 128, 128, 128, 128, 192,
"avg", 192)
in4b = inception7c(in4a, 192, 160, 160, 192, 160, 160, 160, 160, 192,
"avg", 192)
in4c = inception7c(in4b, 192, 160, 160, 192, 160, 160, 160, 160, 192,
"avg", 192)
in4d = inception7c(in4c, 192, 192, 192, 192, 192, 192, 192, 192, 192,
"avg", 192)
in4e = inception7d(in4d, 192, 320, 192, 192, 192, 192, "max")
# stage 5
in5a = inception7e(in4e, 320, 384, 384, 384, 448, 384, 384, 384, "avg",
192)
in5b = inception7e(in5a, 320, 384, 384, 384, 448, 384, 384, 384, "max",
192)
# pool
pool = AveragePooling2D(pool_size=(8, 8), strides=(1, 1))(in5b)
flatten = Flatten()(pool)
out = Dense(output_dim=num_classes, activation='softmax')(flatten)
model = Model(input=data, output=out)
return model
def inception_resnet_v2(scale=True):
init = Input((settings.img_rows, settings.img_cols, 3, ))
x = resnet_v2_stem(init) # Output: 35 * 35 * 256
# 5 x Inception A
for i in range(5):
x = inception_resnet_v2_A(x, scale_residual=scale)
# Output: 35 * 35 * 256
# Reduction A
x = reduction_resnet_v2_A(x) # Output: 17 * 17 * 896
# 10 x Inception B
for i in range(10):
x = inception_resnet_v2_B(x, scale_residual=scale)
# Output: 17 * 17 * 896
# Reduction B
x = reduction_resnet_v2_B(x) # Output: 8 * 8 * 1792
# 5 x Inception C
for i in range(5):
x = inception_resnet_v2_C(x, scale_residual=scale)
# Output: 8 * 8 * 1792
# Average Pooling
x = AveragePooling2D((8, 8))(x) # Output: 1792
# Dropout
x = Dropout(0.2)(x)
x = Flatten()(x) # Output: 1792
# Output layer
output = Dense(units=len(data_setting.objects_num_name), activation="softmax")(x) # Output: 10000
model = Model(init, output, name="Inception-ResNet-v2")
return model
def _create_graph(self):
logging.debug("Creating model...")
assert ((self._depth - 4) % 6 == 0)
n = (self._depth - 4) / 6
inputs = Input(shape=self._input_shape)
n_stages = [16, 16 * self._k, 32 * self._k, 64 * self._k]
conv1 = Conv2D(filters=n_stages[0], kernel_size=(3, 3),
strides=(1, 1),
padding="same",
kernel_initializer=self._weight_init,
kernel_regularizer=l2(self._weight_decay),
use_bias=self._use_bias)(inputs) # "One conv at the beginning (spatial size: 32x32)"
# Add wide residual blocks
block_fn = self._wide_basic
conv2 = self._layer(block_fn, n_input_plane=n_stages[0], n_output_plane=n_stages[1], count=n, stride=(1, 1))(
conv1)
conv3 = self._layer(block_fn, n_input_plane=n_stages[1], n_output_plane=n_stages[2], count=n, stride=(2, 2))(
conv2)
conv4 = self._layer(block_fn, n_input_plane=n_stages[2], n_output_plane=n_stages[3], count=n, stride=(2, 2))(
conv3)
batch_norm = BatchNormalization(axis=self._channel_axis)(conv4)
relu = Activation("relu")(batch_norm)
# Classifier block
pool = AveragePooling2D(pool_size=(8, 8), strides=(1, 1), padding="same")(relu)
flatten = Flatten()(pool)
predictions_g = Dense(units=2, kernel_initializer=self._weight_init, use_bias=self._use_bias,
kernel_regularizer=l2(self._weight_decay), activation="softmax")(flatten)
predictions_a = Dense(units=101, kernel_initializer=self._weight_init, use_bias=self._use_bias,
kernel_regularizer=l2(self._weight_decay), activation="softmax")(flatten)
self._model = Model(inputs=inputs, outputs=[predictions_g, predictions_a])
self._graph = tf.get_default_graph()
def create(self):
bn_axis = 3
img_input = Input(shape=(224, 224, 3))
x = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), padding='valid', name='conv1')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = 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')
x = self.identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = self.identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = self.identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x = self.conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = self.identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = self.identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = self.identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = self.identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = self.identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
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 = AveragePooling2D((7, 7), name='avg_pool')(x)
x = Flatten()(x)
x = Dense(1000, activation='softmax', name='fc1000')(x)
self.model = Model(img_input, x, name='resnet50')
self.model.load_weights(get_file(self.weight_filename, self.WEIGHT_FILE_PATH + self.weight_filename, cache_subdir='models'))
def squeezenet(num_classes):
inp = Input(shape=(224, 224, 3))
conv1 = Conv2D(64, (3, 3),
strides=(2, 2),
activation='relu',
padding='valid')(inp)
maxpool1 = MaxPooling2D(pool_size=(3, 3), strides=2)(conv1)
fire2 = fire(maxpool1, 16, 64)
fire3 = fire(fire2, 16, 64)
fire4 = fire(fire3, 32, 128)
maxpool4 = MaxPooling2D(pool_size=(3, 3), strides=2)(fire4)
fire5 = fire(maxpool4, 32, 128)
fire6 = fire(fire5, 48, 192)
fire7 = fire(fire6, 48, 192)
fire8 = fire(fire7, 64, 256)
maxpool8 = MaxPooling2D(pool_size=(3, 3), strides=2)(fire8)
fire9 = fire(maxpool8, 64, 256)
conv10 = Conv2D(num_classes, (1, 1), activation='relu',
padding='valid')(fire9)
# # dr = Dropout(0.5)(conv10)
avgpool = AveragePooling2D(pool_size=(13, 13), strides=1)(conv10)
avgpool = Flatten()(conv10)
avgpool = Dense(4096, activation='relu')(avgpool)
# avgpool = Dropout(0.5)(avgpool)
avgpool = Dense(4096, activation='relu')(avgpool)
# avgpool = Dropout(0.5)(avgpool)
out = Dense(num_classes, activation='sigmoid')(avgpool)
model = Model(inputs=inp, outputs=out)
print(model.summary())
return model
