# LOADING WEIGHTS TO FINE-TUNNE THEM
model.load_weights(weights_path)
pop_layer(model)
pop_layer(model)
# for layer in model.layers:
# layer.trainable= False
nb_classes=13
layer_last=Dense(nb_classes)
layer_last.trainable=True
layer_last2=Activation('softmax')
layer_last2.trainable=True
model.add(layer_last)
model.add(layer_last2)
print(model.summary())
# let's train the model using SGD + momentum (how original).
#sgd = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer="sgd",
metrics=['accuracy'])
(X_train, y_train), (X_test, y_test) = terrassa.load_data_without_unknown_class()
def resnet8(img_width, img_height, img_channels, output_dim):
"""
Define model architecture.
# Arguments
img_width: Target image widht.
img_height: Target image height.
img_channels: Target image channels.
output_dim: Dimension of model output.
# Returns
model: A Model instance.
"""
# Input
img_input = Input(shape=(img_height, img_width, img_channels))
x1 = Conv2D(32, (5, 5), strides=[2, 2], padding='same')(img_input)
x1 = MaxPooling2D(pool_size=(3, 3), strides=[2, 2])(x1)
x1.trainable = False
# First residual block
x2 = keras.layers.normalization.BatchNormalization()(x1)
x2 = Activation('relu')(x2)
x2 = Conv2D(32, (3, 3),
strides=[2, 2],
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x2)
x2 = keras.layers.normalization.BatchNormalization()(x2)
x2 = Activation('relu')(x2)
x2 = Conv2D(32, (3, 3),
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x2)
x2.trainable = False
x1 = Conv2D(32, (1, 1), strides=[2, 2], padding='same')(x1)
x3 = add([x1, x2])
# Second residual block
x4 = keras.layers.normalization.BatchNormalization()(x3)
x4 = Activation('relu')(x4)
x4 = Conv2D(64, (3, 3),
strides=[2, 2],
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x4)
x4 = keras.layers.normalization.BatchNormalization()(x4)
x4 = Activation('relu')(x4)
x4 = Conv2D(64, (3, 3),
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x4)
x4.trainable = False
x3 = Conv2D(64, (1, 1), strides=[2, 2], padding='same')(x3)
x5 = add([x3, x4])
# Third residual block
x6 = keras.layers.normalization.BatchNormalization()(x5)
x6 = Activation('relu')(x6)
x6 = Conv2D(128, (3, 3),
strides=[2, 2],
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x6)
x6 = keras.layers.normalization.BatchNormalization()(x6)
x6 = Activation('relu')(x6)
x6 = Conv2D(128, (3, 3),
padding='same',
kernel_initializer="he_normal",
kernel_regularizer=regularizers.l2(1e-4))(x6)
x5 = Conv2D(128, (1, 1), strides=[2, 2], padding='same')(x5)
x7 = add([x5, x6])
x = Flatten()(x7)
x = Activation('relu')(x)
x = Dropout(0.5)(x)
# Steering channel
steer = Dense(output_dim)(x)
# Collision channel
coll = Dense(output_dim)(x)
coll = Activation('sigmoid')(coll)
# Define steering-collision model
model = Model(inputs=[img_input], outputs=[steer, coll])
print(model.summary())
return model
train_y,
validation_data=(test_x, test_y),
batch_size=BS,
epochs=NUM_EPOCHS,
callbacks=[tensorboard_callback])
# This saves the weights to the specified file in HDF5 format
old_model.save_weights('./files/mnist_model.h5')
# Loading the weights previously obtained by training the network
old_model.load_weights("./files/mnist_model.h5")
# We now iterate over all the layers in the model
# In order to freeze them, we don't want to train this model
for layer in old_model.layers:
layer.trainable = False
# Now we create the new model, that will take advantage of the old models structure
layer = Dense(512)(old_model.get_layer("features").output)
layer = Activation("relu")(layer)
layer = BatchNormalization()(layer)
layer = Dropout(0.5)(layer)
layer = Dense(256)(layer)
layer = Activation("relu")(layer)
layer = BatchNormalization()(layer)
layer = Dropout(0.2)(layer)
layer = Dense(26)(layer)
layer = Activation("softmax")(layer)
# Here we say that the model starts where the old model ends