refactor cifar10 classifier

Author: chen0040

demo/cnn_cifar10_train.py

@@ -1,72 +1,38 @@
-from keras.models import Sequential
-from keras.layers import Conv2D, MaxPooling2D, Dense, Activation, Flatten, Dropout
-from keras.utils import np_utils
-from keras.preprocessing.image import ImageDataGenerator
 from keras.datasets import cifar10
 import keras.backend as K
-from keras.callbacks import ModelCheckpoint
 
-train_data_dir = 'multi_classifier_data/training'
-validation_data_dir = 'multi_classifier_data/validation'
-img_width, img_height = 32, 32
-batch_size = 128
-epochs= 20
-nb_classes = 10
-WEIGHT_FILE_PATH = 'models/cnn_cifar10_weights.h5'
+from keras_image_classifier.library.cifar10_classifier import Cifar10Classifier
 
-(Xtrain, Ytrain), (Xtest, Ytest) = cifar10.load_data()
 
-Xtrain = Xtrain.astype('float32') / 255
-Xtest = Xtest.astype('float32') / 255
+def main():
+    img_width, img_height = 32, 32
+    batch_size = 128
+    epochs = 20
+    nb_classes = 10
+    output_dir_path = './models'
 
-Ytrain = np_utils.to_categorical(Ytrain, nb_classes)
-Ytest = np_utils.to_categorical(Ytest, nb_classes)
+    (Xtrain, Ytrain), (Xtest, Ytest) = cifar10.load_data()
 
-if K.image_data_format() == 'channels_first':
-    input_shape = (3, img_width, img_height)
-else:
-    input_shape = (img_width, img_height, 3)
+    if K.image_data_format() == 'channels_first':
+        input_shape = (3, img_width, img_height)
+    else:
+        input_shape = (img_width, img_height, 3)
 
-model = Sequential()
-model.add(Conv2D(filters=32, input_shape=input_shape, padding='same', kernel_size=(3, 3)))
-model.add(Activation('relu'))
-model.add(MaxPooling2D(pool_size=(2, 2)))
+    classifier = Cifar10Classifier()
 
-model.add(Conv2D(filters=32, padding='same', kernel_size=(3, 3)))
-model.add(Activation('relu'))
-model.add(MaxPooling2D(pool_size=(2, 2)))
+    classifier.fit(Xtrain, Ytrain, model_dir_path=output_dir_path,
+                   batch_size=batch_size,
+                   epochs=epochs,
+                   input_shape=input_shape, nb_classes=nb_classes)
 
-model.add(Dropout(rate=0.25))
+    score = classifier.evaluate(Xtest, Ytest, batch_size=batch_size)
 
-model.add(Conv2D(filters=64, kernel_size=(3, 3), padding='same', input_shape=input_shape))
-model.add(Activation('relu'))
-model.add(MaxPooling2D(pool_size=(2, 2)))
+    print('score: ', score[0])
+    print('accurarcy: ', score[1])
 
-model.add(Conv2D(filters=64, padding='same', kernel_size=(3, 3)))
-model.add(Activation('relu'))
-model.add(MaxPooling2D(pool_size=(2, 2)))
+    classifier.export_tensorflow_model(output_fld='./models/tf')
 
-model.add(Dropout(rate=0.25))
 
-model.add(Flatten())
-model.add(Dense(units=512))
-model.add(Activation('relu'))
-model.add(Dropout(rate=0.5))
-model.add(Dense(units=nb_classes))
-model.add(Activation('softmax'))
-
-model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
-
-json = model.to_json()
-open('models/cnn_cifar10_architecture.json', 'w').write(json)
-
-checkpoint = ModelCheckpoint(filepath=WEIGHT_FILE_PATH, save_best_only=True)
-model.fit(x=Xtrain, y=Ytrain, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.2, callbacks=[checkpoint])
-
-score = model.evaluate(x=Xtest, y=Ytest, batch_size=batch_size, verbose=1)
-
-print('score: ', score[0])
-print('accurarcy: ', score[1])
-
-model.save_weights(WEIGHT_FILE_PATH, overwrite=True)
+if __name__ == '__main__':
+    main()
 

demo/models/cnn_cifar10_weights.h5

@@ -106,7 +106,7 @@ def cats_vs_dogs_result(filename):
 @app.route('/cifar10_result/<filename>')
 def cifar10_result(filename):
     filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-    predicted_class, predicted_label = cifar10_classifier.predict(filepath)
+    predicted_class, predicted_label = cifar10_classifier.predict_label(filepath)
     return render_template('cifar10_result.html', filename=filename,
                            predicted_class=predicted_class, predicted_label=predicted_label)
 

demo_web/flaskr.py

@@ -1,19 +1,49 @@
+from keras.callbacks import ModelCheckpoint
 from keras.models import model_from_json
 from PIL import Image
 import numpy as np
 import os
+from keras.models import Sequential
+from keras.layers import Conv2D, MaxPooling2D, Dense, Activation, Flatten, Dropout
+from keras.utils import np_utils
+import tensorflow as tf
+import keras.backend as K
+
 
 class Cifar10Classifier:
-    cifar10_model = None
+    model_name = 'cnn_cifar10'
 
     def __init__(self):
-        # load and configure the cifar19 classifier model
-        self.cifar10_model = model_from_json(
-            open(os.path.join('../training/models', 'cnn_cifar10_architecture.json')).read())
-        self.cifar10_model.load_weights(os.path.join('../training/models', 'cnn_cifar10_weights.h5'))
-        self.cifar10_model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
+        self.model = None
+        self.input_shape = None
+        self.nb_classes = None
+
+    @staticmethod
+    def get_architecture_file_path(model_dir_path):
+        return os.path.join(model_dir_path, Cifar10Classifier.model_name + '_architecture.json')
+
+    @staticmethod
+    def get_weight_file_path(model_dir_path):
+        return os.path.join(model_dir_path, Cifar10Classifier.model_name + '_weights.h5')
+
+    @staticmethod
+    def get_config_file_path(model_dir_path):
+        return os.path.join(model_dir_path, Cifar10Classifier.model_name + '_config.npy')
+
+    def load_model(self, model_dir_path):
+
+        config_file_path = self.get_config_file_path(model_dir_path)
 
-    def predict(self, filename):
+        config = np.load(config_file_path).item()
+
+        self.input_shape = config['input_shape']
+        self.nb_classes = config['nb_classes']
+
+        self.model = model_from_json(open(self.get_architecture_file_path(model_dir_path)).read())
+        self.model.load_weights(self.get_weight_file_path(model_dir_path))
+        self.model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
+
+    def predict_label(self, filename):
         img = Image.open(filename)
         img = img.resize((32, 32), Image.ANTIALIAS)
 
@@ -23,7 +53,7 @@ def predict(self, filename):
 
         print(input.shape)
 
-        predicted_class = self.cifar10_model.predict_classes(input)[0]
+        predicted_class = self.model.predict_classes(input)[0]
 
         labels = [
             "airplane",
@@ -39,5 +69,137 @@ def predict(self, filename):
         ]
         return predicted_class, labels[predicted_class]
 
+    @staticmethod
+    def create_model(input_shape, nb_classes):
+        model = Sequential()
+        model.add(Conv2D(filters=32, input_shape=input_shape, padding='same', kernel_size=(3, 3)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(filters=32, padding='same', kernel_size=(3, 3)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Dropout(rate=0.25))
+
+        model.add(Conv2D(filters=64, kernel_size=(3, 3), padding='same', input_shape=input_shape))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(filters=64, padding='same', kernel_size=(3, 3)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Dropout(rate=0.25))
+
+        model.add(Flatten())
+        model.add(Dense(units=512))
+        model.add(Activation('relu'))
+        model.add(Dropout(rate=0.5))
+        model.add(Dense(units=nb_classes))
+        model.add(Activation('softmax'))
+
+        model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
+
+        return model
+
     def run_test(self):
-        print(self.predict('../training/bi_classifier_data/training/cat/cat.2.jpg'))
+        print(self.predict_label('../training/bi_classifier_data/training/cat/cat.2.jpg'))
+
+    def fit(self, Xtrain, Ytrain, model_dir_path, input_shape=None, nb_classes=None, test_size=None, batch_size=None,
+            epochs=None):
+
+        if batch_size is None:
+            batch_size = 64
+        if epochs is None:
+            epochs = 20
+        if test_size is None:
+            test_size = 0.2
+
+        if input_shape is None:
+            input_shape = (32, 32, 3)
+
+        if nb_classes is None:
+            nb_classes = 10
+
+        Xtrain = Xtrain.astype('float32') / 255
+        Ytrain = np_utils.to_categorical(Ytrain, nb_classes)
+
+        self.input_shape = input_shape
+        self.nb_classes = nb_classes
+
+        config_file_path = self.get_config_file_path(model_dir_path)
+
+        config = dict()
+        config['input_shape'] = input_shape
+        config['nb_classes'] = nb_classes
+
+        np.save(config_file_path, config)
+
+        weight_file_path = self.get_weight_file_path(model_dir_path)
+
+        self.model = self.create_model(input_shape, nb_classes)
+
+        checkpoint = ModelCheckpoint(filepath=weight_file_path, save_best_only=True)
+        history = self.model.fit(x=Xtrain, y=Ytrain, batch_size=batch_size, epochs=epochs, verbose=1,
+                                 validation_split=test_size,
+                                 callbacks=[checkpoint])
+        self.model.save_weights(weight_file_path)
+
+        np.save(os.path.join(model_dir_path, Cifar10Classifier.model_name + '-history.npy'), history.history)
+
+        return history
+
+    def evaluate(self, Xtest, Ytest, batch_size=None):
+
+        if batch_size is None:
+            batch_size = 64
+
+        Xtest = Xtest.astype('float32') / 255
+        Ytest = np_utils.to_categorical(Ytest, self.nb_classes)
+
+        return self.model.evaluate(x=Xtest, y=Ytest, batch_size=batch_size, verbose=1)
+
+    def export_tensorflow_model(self, output_fld, output_model_file=None,
+                                output_graphdef_file=None,
+                                num_output=None,
+                                quantize=False,
+                                save_output_graphdef_file=False,
+                                output_node_prefix=None):
+
+        K.set_learning_phase(0)
+
+        if output_model_file is None:
+            output_model_file = Cifar10Classifier.model_name + '.pb'
+
+        if output_graphdef_file is None:
+            output_graphdef_file = 'model.ascii'
+        if num_output is None:
+            num_output = 1
+        if output_node_prefix is None:
+            output_node_prefix = 'output_node'
+
+        pred = [None] * num_output
+        pred_node_names = [None] * num_output
+        for i in range(num_output):
+            pred_node_names[i] = output_node_prefix + str(i)
+            pred[i] = tf.identity(self.model.outputs[i], name=pred_node_names[i])
+        print('output nodes names are: ', pred_node_names)
+
+        sess = K.get_session()
+
+        if save_output_graphdef_file:
+            tf.train.write_graph(sess.graph.as_graph_def(), output_fld, output_graphdef_file, as_text=True)
+            print('saved the graph definition in ascii format at: ', output_graphdef_file)
+
+        from tensorflow.python.framework import graph_util
+        from tensorflow.python.framework import graph_io
+        from tensorflow.tools.graph_transforms import TransformGraph
+        if quantize:
+            transforms = ["quantize_weights", "quantize_nodes"]
+            transformed_graph_def = TransformGraph(sess.graph.as_graph_def(), [], pred_node_names, transforms)
+            constant_graph = graph_util.convert_variables_to_constants(sess, transformed_graph_def, pred_node_names)
+        else:
+            constant_graph = graph_util.convert_variables_to_constants(sess, sess.graph.as_graph_def(), pred_node_names)
+        graph_io.write_graph(constant_graph, output_fld, output_model_file, as_text=False)
+        print('saved the freezed graph (ready for inference) at: ', output_model_file)