def __init__(self, nn_type="resnet50", restore = None, session=None, use_imagenet_pretrain=False, use_softmax=True):
self.image_size = 224
self.num_channels = 3
self.num_labels = 8
input_layer = Input(shape=(self.image_size, self.image_size, self.num_channels))
weights = "imagenet" if use_imagenet_pretrain else None
if nn_type == "resnet50":
base_model = ResNet50(weights=weights, input_tensor=input_layer)
elif nn_type == "vgg16":
base_model = VGG16(weights=weights, input_tensor=input_layer)
# base_model = VGG16(weights=None, input_tensor=input_layer)
x = base_model.output
x = LeakyReLU()(x)
x = Dense(1024)(x)
x = Dropout(0.2)(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Dense(8)(x)
if use_softmax:
x = Activation("softmax")(x)
model = Model(inputs=base_model.input, outputs=x)
# for layer in base_model.layers:
# layer.trainable = False
if restore:
print("Load: {}".format(restore))
model.load_weights(restore)
self.model = model
def build_models(seq_len=12, num_classes=4, load_weights=False):
# DST-Net: ResNet50
resnet = ResNet50(weights='imagenet', include_top=False)
for layer in resnet.layers:
layer.trainable = False
resnet.load_weights('model/resnet.h5')
# DST-Net: Conv3D + Bi-LSTM
inputs = Input(shape=(seq_len, 7, 7, 2048))
# conv1_1, conv3D and flatten
conv1_1 = TimeDistributed(Conv2D(128, 1, 1, activation='relu'))(inputs)
conv3d = Conv3D(64, 3, 1, 'SAME', activation='relu')(conv1_1)
flatten = Reshape(target_shape=(seq_len, 7 * 7 * 64))(conv3d)
# 2 Layers Bi-LSTM
bilstm_1 = Bidirectional(LSTM(128, dropout=0.5,
return_sequences=True))(flatten)
bilstm_2 = Bidirectional(LSTM(128, dropout=0.5,
return_sequences=False))(bilstm_1)
outputs = Dense(num_classes, activation='softmax')(bilstm_2)
dstnet = Model(inputs=inputs, outputs=outputs)
dstnet.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.001, momentum=0.9, nesterov=True))
# load models
if load_weights:
dstnet.load_weights('model/dstnet.h5')
return resnet, dstnet
def SqueezeNet(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the SqueezeNet architecture.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if weights == 'imagenet' and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
input_shape = _obtain_input_shape(input_shape,
default_size=227,
min_size=48,
data_format=K.image_data_format(),
include_top=include_top)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Convolution2D(64, (3, 3),
strides=(2, 2),
padding='valid',
name='conv1')(img_input)
x = Activation('relu', name='relu_conv1')(x)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool1')(x)
x = fire_module(x, fire_id=2, squeeze=16, expand=64)
x = fire_module(x, fire_id=3, squeeze=16, expand=64)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool3')(x)
x = fire_module(x, fire_id=4, squeeze=32, expand=128)
x = fire_module(x, fire_id=5, squeeze=32, expand=128)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x)
x = fire_module(x, fire_id=6, squeeze=48, expand=192)
x = fire_module(x, fire_id=7, squeeze=48, expand=192)
x = fire_module(x, fire_id=8, squeeze=64, expand=256)
x = fire_module(x, fire_id=9, squeeze=64, expand=256)
if include_top:
# It's not obvious where to cut the network...
# Could do the 8th or 9th layer... some work recommends cutting earlier layers.
x = Dropout(0.5, name='drop9')(x)
x = Convolution2D(classes, (1, 1), padding='valid', name='conv10')(x)
x = Activation('relu', name='relu_conv10')(x)
x = GlobalAveragePooling2D()(x)
x = Activation('softmax', name='loss')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
elif pooling == None:
pass
else:
raise ValueError("Unknown argument for 'pooling'=" + pooling)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
model = Model(inputs, x, name='squeezenet')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'squeezenet_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file(
'squeezenet_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
return model
def train(data,
file_name,
nlayer,
num_epochs=10,
batch_size=128,
train_temp=1,
init=None,
activation=tf.nn.relu):
"""
Train a n-layer CNN for MNIST and CIFAR
"""
inputs = Input(shape=(28, 28, 1))
if nlayer == 2:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 3:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 4:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = Residual(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 5:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = Residual(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
model = Model(inputs=inputs, outputs=x)
# load initial weights when given
if init != None:
model.load_weights(init)
# define the loss function which is the cross entropy between prediction and true label
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted /
train_temp)
# initiate the Adam optimizer
sgd = Adam()
# compile the Keras model, given the specified loss and optimizer
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
model.summary()
# run training with given dataset, and print progress
history = model.fit(data.train_data,
data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data,
data.validation_labels),
epochs=num_epochs,
shuffle=True)
# save model to a file
if file_name != None:
model.save(file_name)
return {'model': model, 'history': history}
