Update DenseNet with ImageNet models and CIFAR 10 models

Author: titu1994

cifar10.py

@@ -10,10 +10,10 @@
 from keras.utils import np_utils
 from keras.preprocessing.image import ImageDataGenerator
 from keras.optimizers import Adam
-from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping
+from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
 from keras import backend as K
 
-batch_size = 64
+batch_size = 100
 nb_classes = 10
 nb_epoch = 300
 
@@ -24,15 +24,15 @@
 depth = 40
 nb_dense_block = 3
 growth_rate = 12
-nb_filter = 16
+nb_filter = -1
 dropout_rate = 0.0 # 0.0 for data augmentation
 
 model = densenet.DenseNet(img_dim, classes=nb_classes, depth=depth, nb_dense_block=nb_dense_block,
-                          growth_rate=growth_rate, nb_filter=nb_filter, dropout_rate=dropout_rate)
+                          growth_rate=growth_rate, nb_filter=nb_filter, dropout_rate=dropout_rate, weights=None)
 print("Model created")
 
 model.summary()
-optimizer = Adam(lr=1e-4) # Using Adam instead of SGD to speed up training
+optimizer = Adam(lr=1e-3) # Using Adam instead of SGD to speed up training
 model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=["accuracy"])
 print("Finished compiling")
 print("Building model...")
@@ -42,38 +42,39 @@
 trainX = trainX.astype('float32')
 testX = testX.astype('float32')
 
-trainX /= 255.
-testX /= 255.
+trainX = densenet.preprocess_input(trainX)
+testX = densenet.preprocess_input(testX)
 
 Y_train = np_utils.to_categorical(trainY, nb_classes)
 Y_test = np_utils.to_categorical(testY, nb_classes)
 
 generator = ImageDataGenerator(rotation_range=15,
                                width_shift_range=5./32,
-                               height_shift_range=5./32)
+                               height_shift_range=5./32,
+                               horizontal_flip=True)
 
 generator.fit(trainX, seed=0)
 
 # Load model
-weights_file="weights/DenseNet-40-12CIFAR10-tf.h5"
+weights_file="weights/DenseNet-40-12-CIFAR10.h5"
 if os.path.exists(weights_file):
-    model.load_weights(weights_file)
+    #model.load_weights(weights_file, by_name=True)
     print("Model loaded.")
 
 out_dir="weights/"
 
-lr_reducer      = ReduceLROnPlateau(monitor='val_loss', factor=np.sqrt(0.1), 
-                                    cooldown=0, patience=10, min_lr=0.5e-6)
-early_stopper   = EarlyStopping(monitor='val_acc', min_delta=0.0001, patience=20)
+lr_reducer      = ReduceLROnPlateau(monitor='val_acc', factor=np.sqrt(0.1),
+                                    cooldown=0, patience=5, min_lr=1e-5)
 model_checkpoint= ModelCheckpoint(weights_file, monitor="val_acc", save_best_only=True,
-                                  save_weights_only=True,mode='auto')
+                                  save_weights_only=True, verbose=1)
 
-callbacks=[lr_reducer,early_stopper,model_checkpoint]
+callbacks=[lr_reducer, model_checkpoint]
 
-model.fit_generator(generator.flow(trainX, Y_train, batch_size=batch_size), samples_per_epoch=len(trainX), nb_epoch=nb_epoch,
-                   callbacks=callbacks,
-                   validation_data=(testX, Y_test),
-                   nb_val_samples=testX.shape[0], verbose=2)
+model.fit_generator(generator.flow(trainX, Y_train, batch_size=batch_size),
+                    steps_per_epoch=len(trainX) // batch_size, epochs=nb_epoch,
+                    callbacks=callbacks,
+                    validation_data=(testX, Y_test),
+                    validation_steps=testX.shape[0] // batch_size, verbose=1)
 
 yPreds = model.predict(testX)
 yPred = np.argmax(yPreds, axis=1)

densenet.py

@@ -0,0 +1,27 @@
+from __future__ import print_function
+from __future__ import absolute_import
+
+from keras.preprocessing import image
+
+from densenet import DenseNetImageNet121, DenseNetImageNet169, DenseNetImageNet161, preprocess_input, decode_predictions
+
+import numpy as np
+
+if __name__ == '__main__':
+    size = 224
+
+    model = DenseNetImageNet121(input_shape=(size, size, 3))
+    model.summary()
+
+
+    img_path = 'images/elephant.jpg'
+    img = image.load_img(img_path, target_size=(size, size))
+    x = image.img_to_array(img)
+    x = np.expand_dims(x, axis=0)
+
+    x = preprocess_input(x)
+
+    preds = model.predict(x)
+
+    print('Predicted:', decode_predictions(preds))
+

imagenet_inference.py

@@ -0,0 +1,115 @@
+import h5py
+import os
+
+# Note : Weights obtained from https://github.com/flyyufelix/DenseNet-Keras
+f = h5py.File('densenet121_weights_tf.h5')
+
+conv_weights = []
+bn_weights = []
+
+dense_classifier_weights = None
+
+for name in f.attrs['layer_names']:
+    if 'data' in str(name):
+        continue
+
+    if 'zeropadding' in str(name):
+        continue
+
+    if 'relu' in str(name):
+        continue
+
+    if 'prob' in str(name):
+        continue
+
+    if 'pool' in str(name):
+        continue
+
+    if 'concat' in str(name):
+        continue
+
+    if 'fc' in str(name):
+        v = f[name]
+        v = [v[attr][:] for attr in v.attrs['weight_names']]
+        dense_classifier_weights = v
+        break
+
+    if 'bn' in str(name):
+        v = f[name]
+        v_w = [v[attr][:] for attr in v.attrs['weight_names']]
+        bn_weights.append(v_w)
+        continue
+
+    if 'scale' in str(name):
+        v = f[name]
+        v_w = [v[attr][:] for attr in v.attrs['weight_names']]
+        bn_weights[-1][0] = v_w[0]
+        bn_weights[-1][1] = v_w[1]
+        continue
+
+    v = f[name]
+    v_w = v[v.attrs['weight_names'][0]][:]
+    conv_weights.append(v_w)
+
+count_layers = 1 # for dense matrix
+count_layers += len(conv_weights)
+count_layers += len(bn_weights)
+
+print('Copying %d weights. (%d layers)' % (count_layers, count_layers // 2))
+
+import densenet
+
+model = densenet.DenseNetImageNet121((224, 224, 3), weights=None)
+
+conv_layer_ids = []
+bn_layer_ids = []
+
+for i, layer in enumerate(model.layers):
+    if layer.__class__.__name__ == 'Input':
+        continue
+
+    if layer.__class__.__name__ == 'Activation':
+        continue
+
+    if layer.__class__.__name__ == 'MaxPooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'AveragePooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'Concatenate':
+        continue
+
+    if layer.__class__.__name__ == 'GlobalAveragePooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'Conv2D':
+        conv_layer_ids.append(i)
+        continue
+
+    if layer.__class__.__name__ == 'BatchNormalization':
+        bn_layer_ids.append(i)
+        continue
+
+
+count = 0
+for i, weights in enumerate(conv_weights):
+    conv_idx = conv_layer_ids[i]
+    model.layers[conv_idx].set_weights([weights])
+    count += 1
+
+for i, weights in enumerate(bn_weights):
+    bn_idx = bn_layer_ids[i]
+
+    model.layers[bn_idx].set_weights(weights)
+    count += 1
+
+model.layers[-1].set_weights(dense_classifier_weights)
+count += 1
+
+print("Sanity check : %d weights loaded" % count)
+
+model.save_weights('DenseNet-BC-121-32.h5', overwrite=True)
+
+print("Finished saving weights")
+

images/cheetah.jpg

@@ -0,0 +1,115 @@
+import h5py
+import os
+
+# Note : Weights obtained from https://github.com/flyyufelix/DenseNet-Keras
+f = h5py.File('densenet161_weights_tf.h5')
+
+conv_weights = []
+bn_weights = []
+
+dense_classifier_weights = None
+
+for name in f.attrs['layer_names']:
+    if 'data' in str(name):
+        continue
+
+    if 'zeropadding' in str(name):
+        continue
+
+    if 'relu' in str(name):
+        continue
+
+    if 'prob' in str(name):
+        continue
+
+    if 'pool' in str(name):
+        continue
+
+    if 'concat' in str(name):
+        continue
+
+    if 'fc' in str(name):
+        v = f[name]
+        v = [v[attr][:] for attr in v.attrs['weight_names']]
+        dense_classifier_weights = v
+        break
+
+    if 'bn' in str(name):
+        v = f[name]
+        v_w = [v[attr][:] for attr in v.attrs['weight_names']]
+        bn_weights.append(v_w)
+        continue
+
+    if 'scale' in str(name):
+        v = f[name]
+        v_w = [v[attr][:] for attr in v.attrs['weight_names']]
+        bn_weights[-1][0] = v_w[0]
+        bn_weights[-1][1] = v_w[1]
+        continue
+
+    v = f[name]
+    v_w = v[v.attrs['weight_names'][0]][:]
+    conv_weights.append(v_w)
+
+count_layers = 1 # for dense matrix
+count_layers += len(conv_weights)
+count_layers += len(bn_weights)
+
+print('Copying %d weights. (%d layers)' % (count_layers, count_layers // 2))
+
+import densenet
+
+model = densenet.DenseNetImageNet161((224, 224, 3), weights=None)
+
+conv_layer_ids = []
+bn_layer_ids = []
+
+for i, layer in enumerate(model.layers):
+    if layer.__class__.__name__ == 'Input':
+        continue
+
+    if layer.__class__.__name__ == 'Activation':
+        continue
+
+    if layer.__class__.__name__ == 'MaxPooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'AveragePooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'Concatenate':
+        continue
+
+    if layer.__class__.__name__ == 'GlobalAveragePooling2D':
+        continue
+
+    if layer.__class__.__name__ == 'Conv2D':
+        conv_layer_ids.append(i)
+        continue
+
+    if layer.__class__.__name__ == 'BatchNormalization':
+        bn_layer_ids.append(i)
+        continue
+
+
+count = 0
+for i, weights in enumerate(conv_weights):
+    conv_idx = conv_layer_ids[i]
+    model.layers[conv_idx].set_weights([weights])
+    count += 1
+
+for i, weights in enumerate(bn_weights):
+    bn_idx = bn_layer_ids[i]
+
+    model.layers[bn_idx].set_weights(weights)
+    count += 1
+
+model.layers[-1].set_weights(dense_classifier_weights)
+count += 1
+
+print("Sanity check : %d weights loaded" % count)
+
+model.save_weights('DenseNet-BC-161-48.h5', overwrite=True)
+
+print("Finished saving weights")
+