Copying working Keras benchmarks to dnn_benchmarks subdirectory

hpvm/test/dnn_benchmarks/keras/Benchmark.py

+
+
+import sys
+import os
+import shutil
+import subprocess
+from keras.utils.np_utils import to_categorical
+from keras.models import load_model
+from keras_frontend.approxhpvm_translator import translate_to_approxhpvm
+from keras_frontend.weight_utils import dumpCalibrationData
+from keras_frontend.weight_utils import reloadHPVMWeights
+
+
+# Every CNN Benchmark must inherit from Benchmark class
+# Defines common interfaces and virtual methods to be overridden by child classes
+class Benchmark:
+
+    def __init__(self, name, reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size=500):
+        self.name = name
+        self.reload_dir = reload_dir
+        self.keras_model_file = keras_model_file
+        self.data_dir = data_dir
+        self.src_dir = src_dir
+        self.num_classes = num_classes
+        self.batch_size = batch_size
+        
+        
+    def buildModel(self):
+        return
+
+    def data_preprocess(self):
+        return
+    
+    def trainModel(self, X_train, y_train, X_test, y_test):
+        return
+
+    def inference(self):
+        return
+
+
+    # Compiles frontend generated sources
+    def compileSource(self, working_dir, src_name, binary_name):
+              
+        src_file = os.getcwd() + "/" + working_dir + "/" + src_name   #  approxhpvm_src.cc"
+        target_binary = os.getcwd() + "/" + working_dir + "/" + binary_name    # HPVM_binary"
+        approx_conf_file = "tuner_confs.txt"
+
+        FNULL = open(os.devnull, 'w')
+        
+        try:
+            subprocess.run([
+                "approxhpvm.py", 
+                "-h"
+            ], check=True, stdout=FNULL)
+            
+        except:
+            print ("\n\n ERROR: Could not find approxhpvm.py (HPVM compile script)!! \n\n")
+            print ("To Compile, Must set PATH to include approxhpvm.py script. Do the following: ")
+            print ("**** export PATH=${PATH_TO_YOUR_HPVM_INSTALLATION}/build/bin/:$PATH *****")
+            sys.exit(1)
+
+
+        try:
+            subprocess.run([
+                "approxhpvm.py", src_file, target_binary,
+                "-t", "tensor", "--conf-file", approx_conf_file
+            ], check=True)
+        except:
+            print ("\n\n ERROR: HPVM Compilation Failed!! \n\n")
+            sys.exit(1)
+
+        f = open("working_dir.txt", "w+")
+        f.write(working_dir)
+        f.close()
+       
+            
+        
+    def printUsage(self):
+
+        print ("Usage: python ${benchmark.py} [hpvm_reload|train] [frontend] [compile]")
+        sys.exit(0)
+
+        
+    def run(self, argv):
+
+      if len(argv) < 2:
+          self.printUsage()
+          
+      print ("Build Model ...")
+      # Virtual method call implemented by each CNN
+      model = self.buildModel()
+
+      print ("Data Preprocess... \n")
+      # Virtual method call to preprocess test and train data 
+      X_train, y_train, X_test, y_test, X_tuner, y_tuner = self.data_preprocess()   
+
+      if argv[1] == "hpvm_reload":
+        print ("loading weights .....\n\n")  
+        model = reloadHPVMWeights(model, self.reload_dir, self.keras_model_file)
+
+      elif argv[1] == "keras_reload":
+        model.load_weights(self.keras_model_file)
+        model.compile(loss='categorical_crossentropy',
+                    optimizer='adam',
+                    metrics=['accuracy'])   
+
+      elif argv[1] == "train":
+        print ("Train Model ...")
+        model = self.trainModel(model, X_train, y_train, X_test, y_test)
+      else:
+          self.printUsage()
+
+          
+      score = model.evaluate(X_test, to_categorical(y_test, self.num_classes), verbose=0)
+      print('Test accuracy2:', score[1])
+
+      f = open("final_accuracy", "w+")
+      f.write(str(score[1] * 100))
+      f.close()
+
+
+      if len(argv) > 2:
+        if argv[2] == "frontend":
+
+          if argv[1] == "hpvm_reload": # If reloading HPVM weights use this as directory to load from in HPVM-C generated src
+              self.data_dir = self.reload_dir
+          
+          # Main call to ApproxHPVM-Keras Frontend
+          working_dir = translate_to_approxhpvm(model,
+                                                self.data_dir, self.src_dir,   
+                                                X_test, y_test,
+                                                X_tuner, y_tuner,
+                                                self.batch_size, # FIXIT
+                                                self.num_classes,
+                                                (argv[1] == "hpvm_reload")) # Do not redump HPVM weights if `hpvm_reload` used
+
+          if len(argv) > 3 and argv[3] == "compile":
+            self.compileSource(working_dir, "approxhpvm_src.cc", "HPVM_binary")
+          else:
+            self.printUsage()
+
+          if len(argv) > 4 and argv[4] == "compile_tuner":
+            self.compileSource(working_dir, "approxhpvm_tuner_src.cc", "HPVM_tuner_binary")
+          else:
+            self.printUsage()
+
+
+        if argv[2] == "keras_dump":
+          model.save_weights(self.keras_model_file)
+
+          
+      #elif len(argv) > 2:
+      #  self.printUsage()
+            
+
+    
+
+        

hpvm/test/dnn_benchmarks/keras/Config.py

+
+import pathlib
+
+
+# Path Relative to Model Params Directory
+abs_path = pathlib.Path(__file__).parent.absolute()
+MODEL_PARAMS_DIR = str(abs_path) + "/../../../../hpvm/test/dnn_benchmarks/model_params/"
+
+
+if __name__ == "__main__":
+
+    abs_path = pathlib.Path(__file__).parent.absolute()
+    print (abs_path)

hpvm/test/dnn_benchmarks/keras/alexnet.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar10
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+# Inherits from Benchmark class defined in src/Benchmark.py
+class AlexNet_CIFAR10(Benchmark):
+
+    # buildModel overrides the buildModel declared in src/Benchmark.py
+    # Goal: Build a Keras Sequential Model (other model types not supported) and return the (uninitalized/untrained) Model 
+    def buildModel(self):
+
+        activation_type = 'tanh'
+        weight_decay = 1e-4
+
+        model = Sequential()
+        
+        model.add(Conv2D(64, (11, 11), padding='same', activation=activation_type,
+                         kernel_regularizer=regularizers.l2(weight_decay), input_shape=(3, 32, 32)))
+        model.add(MaxPooling2D(2, 2))
+        model.add(Dropout(0.2))
+        
+        model.add(Conv2D(192, (5, 5), padding='same', activation=activation_type,
+                         kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(MaxPooling2D(2, 2))
+        model.add(Dropout(0.3))
+
+        model.add(Conv2D(384, (3, 3), padding='same', activation=activation_type, 
+                       kernel_regularizer=regularizers.l2(weight_decay)))   
+        model.add(Conv2D(256, (3, 3), padding='same', activation=activation_type, 
+                       kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Conv2D(256, (3, 3), padding='same', activation=activation_type, 
+                       kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(MaxPooling2D(2, 2))
+        model.add(Dropout(0.4))
+
+        model.add(Flatten())
+        model.add(Dense(self.num_classes))
+        model.add(Activation('softmax'))
+        
+        return model
+
+
+    # This routine is called from the common `run` method in src/Benchmark.py
+    # Goal: Return Training and Testing data after preprocessing/normalization
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar10.load_data()
+
+        X_train = X_train / 255.0
+ 
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean) / (std + 1e-7)
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_cifar10/test_input.bin', dtype=np.float32)
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_cifar10/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_cifar10/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_cifar10/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    # Goal: Given a Keras Sequential Model - setup the training parameters, train, and return the trained Model
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        model.compile(
+            loss='categorical_crossentropy',
+            optimizer=Adam(lr=0.0001, decay=1e-6),
+            metrics=['accuracy']
+        )
+
+        datagen = ImageDataGenerator(
+            rotation_range=15,
+            width_shift_range=0.1,
+            height_shift_range=0.1,
+            horizontal_flip=True,
+        )
+        datagen.fit(X_train)
+
+
+        def lr_schedule(epoch):
+            lrate = 0.001
+            if epoch > 20:
+                lrate = 0.0005
+            if epoch > 40:
+                lrate = 0.0003
+            if epoch > 60:
+                lrate = 0.0001
+            if epoch > 80:
+                lrate = 0.00005  
+            return lrate
+
+        model.fit(
+            X_train,
+            y_train,
+            batch_size=128,
+            shuffle=True,
+            epochs=100,
+            validation_data=(X_test, y_test), 
+            callbacks=[LearningRateScheduler(lr_schedule)]
+        )
+
+        return model
+
+
+    
+if __name__ == '__main__':
+
+    # Using GPU ID 0 - Change to use different GPU
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format - HPVM currently supports NCHW - NHWC format is not supported
+    K.set_image_data_format('channels_first')
+
+
+    # *** Below are Parameters specific to each benchmark *****
+    reload_dir = MODEL_PARAMS_DIR + '/alexnet_cifar10/'
+    ## Either the HPVM weights are loaded (above) or the Keras Model from the path below 
+    keras_model_file = MODEL_PARAMS_DIR + '/alexnet_cifar10/weights.h5'
+    data_dir = ''   # if reloading weights, data_dir can be set to empty string (value is ignored)
+ 
+    src_dir = 'data/alexnet_cifar10_src/'  # Directory where HPVM sources are downloaded
+    num_classes = 10  # Specify num out output classes - CIFAR10 has `10` classes
+    batch_size = 500  # Batch Size set to 500 - Adjust this value based on your GPU memory 
+
+    # All Classes inherit from 'Benchmark` class in src/Benchmark.py and have a common Constructor
+    model = AlexNet_CIFAR10('AlexNet_CIFAR10', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+
+    # This invokes the common run function in src/Benchmark.py 
+    model.run(sys.argv)
+
+    

hpvm/test/dnn_benchmarks/keras/alexnet2.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar10
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class AlexNet2_CIFAR10(Benchmark):
+
+    def buildModel(self):
+
+        weight_decay = 1e-4  
+        activation_type = 'tanh'
+
+        model = Sequential()
+        model.add(Conv2D(32, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay), input_shape=(3, 32, 32)))
+        model.add(Activation(activation_type))
+        model.add(Conv2D(32, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation(activation_type))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+        model.add(Dropout(0.2))
+
+        model.add(Conv2D(64, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation(activation_type))
+        model.add(Conv2D(64, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation(activation_type))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+        model.add(Dropout(0.3))
+
+        model.add(Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation(activation_type))
+        model.add(Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation(activation_type))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+        model.add(Dropout(0.4))
+
+        model.add(Flatten())
+        model.add(Dense(self.num_classes))
+        model.add(Activation('softmax'))
+
+        return model
+
+    
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar10.load_data()
+
+        X_train = X_train / 255.0
+
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean) / (std + 1e-7)
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet2_cifar10/test_input.bin', dtype=np.float32)
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet2_cifar10/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet2_cifar10/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet2_cifar10/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        model.compile(
+            loss='categorical_crossentropy',
+            optimizer=Adam(lr=0.0001),
+            metrics=['accuracy']
+        )
+
+        datagen = ImageDataGenerator(
+            rotation_range=15,
+            width_shift_range=0.1,
+            height_shift_range=0.1,
+            horizontal_flip=True,
+        )
+        datagen.fit(X_train)
+
+
+        def lr_schedule(epoch):
+            lrate = 0.001
+            if epoch > 20:
+                lrate = 0.0005
+            if epoch > 40:
+                lrate = 0.0003
+            if epoch > 60:
+                lrate = 0.0001
+            return lrate
+
+        model.fit(
+            X_train,
+            y_train,
+            batch_size=128,
+            shuffle=True,
+            epochs=100,
+            validation_data=(X_test, y_test), 
+            callbacks=[LearningRateScheduler(lr_schedule)]
+        )
+
+        return model
+
+
+    
+if __name__ == '__main__':
+
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/alexnet2_cifar10/'
+    keras_model_file = MODEL_PARAMS_DIR + '/alexnet2_cifar10/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/alexnet2_cifar10_src/'
+    num_classes = 10
+    batch_size = 500
+
+    model = AlexNet2_CIFAR10('AlexNet2_CIFAR10', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)

hpvm/test/dnn_benchmarks/keras/alexnet_imagenet.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class AlexNet(Benchmark):
+
+    def data_preprocess(self):
+        X_train, y_train = None, None
+        
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_imagenet/test_input.bin', dtype=np.float32)
+        X_test = X_test.reshape((-1, 3, 224, 224)) 
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_imagenet/test_labels.bin', dtype=np.uint32)
+        
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_imagenet/tune_input.bin', dtype=np.float32)
+        X_tuner = X_tuner.reshape((-1, 3, 224, 224)) 
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/alexnet_imagenet/tune_labels.bin', dtype=np.uint32)
+ 
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+    
+    
+    def buildModel(self):
+
+        input_layer = Input((3, 224, 224))
+
+        x = ZeroPadding2D((2, 2))(input_layer)
+        x = Conv2D(64, (11, 11), strides=4, padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D(3, 2)(x)
+
+        x = ZeroPadding2D((2, 2))(x)
+        x = Conv2D(192, (5, 5), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D(3, 2)(x)
+
+        x = Conv2D(384, (3, 3), padding='same')(x)
+        x = Activation('relu')(x)
+
+        x = Conv2D(256, (3, 3), padding='same')(x)
+        x = Activation('relu')(x)
+
+        x = Conv2D(256, (3, 3), padding='same')(x)
+        x = Activation('relu')(x)
+
+        x = MaxPooling2D(3, 2)(x)
+
+        x = Flatten()(x)
+        x = Dropout(0.5)(x)
+        x = Dense(4096)(x)
+        x = Activation('relu')(x)
+        x = Dropout(0.5)(x)
+        x = Dense(4096)(x) 
+        x = Activation('relu')(x)
+        x = Dense(self.num_classes)(x)
+        x = Activation('softmax')(x)
+        
+        model = Model(input_layer, x)
+
+        return model
+
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        assert False, "ImageNet training not supported - use Pretrained weights"
+
+
+    
+if __name__ == '__main__':
+
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/alexnet_imagenet/'
+    keras_model_file = MODEL_PARAMS_DIR + '/alexnet_imagenet/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/alexnet_imagenet_src/'
+    num_classes = 1000
+    batch_size = 50
+
+    model = AlexNet('AlexNet_Imagenet', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+
+
+    

hpvm/test/dnn_benchmarks/keras/lenet.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import mnist
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class LeNet_MNIST(Benchmark):
+
+    def buildModel(self):
+
+        # Network Compostion: 2 Conv Layers, 2 Dense Layers
+        model = Sequential()
+
+        # ConvLayer1
+        model.add(Conv2D(32, kernel_size=(5, 5), padding='same', activation='tanh', input_shape=(1, 28, 28)))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        # ConvLayer2
+        model.add(Conv2D(64, (5, 5), activation='tanh', padding='same'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Flatten())
+        
+        # DenseLayer1
+        model.add(Dense(1024, activation='tanh'))
+        # DenseLayer2
+        
+        model.add(Dense(self.num_classes, activation='tanh'))
+        # Softmax Layer
+        model.add(Activation('softmax'))
+
+        return model
+
+
+    def data_preprocess(self):
+        (X_train, y_train), (X_val, y_val) = mnist.load_data()
+        test_labels = y_val
+
+        X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+        X_train = X_train.astype('float32')
+        X_train /= 255
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/lenet_mnist/test_input.bin', dtype=np.float32)
+        X_test = X_test.reshape((-1, 1, 28, 28)) 
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/lenet_mnist/test_labels.bin', dtype=np.uint32)
+        
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/lenet_mnist/tune_input.bin', dtype=np.float32)
+        X_tuner = X_tuner.reshape((-1, 1, 28, 28)) 
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/lenet_mnist/tune_labels.bin', dtype=np.uint32)
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+    
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+        
+        model.compile(
+            loss='categorical_crossentropy',
+            optimizer=keras.optimizers.Adadelta(),
+            metrics=['accuracy']
+        )
+
+        model.fit(
+            X_train, 
+            y_train,
+            batch_size=128,
+            epochs=10,
+            verbose=1,
+            validation_data=(X_test, y_test)
+        )
+        
+        return model
+  
+
+    
+if __name__ == '__main__':
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/lenet_mnist/'
+    keras_model_file = MODEL_PARAMS_DIR + '/lenet_mnist/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/lenet_mnist_src/'
+    num_classes = 10
+    batch_size = 500
+    
+    print (reload_dir)
+
+    model = LeNet_MNIST('LeNet_MNIST', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)

hpvm/test/dnn_benchmarks/keras/mobilenet_cifar10.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar10
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class MobileNet_CIFAR10(Benchmark):
+
+    def buildModel(self):
+        alpha=1
+        depth_multiplier=1
+
+        model = Sequential()
+
+        def _conv_block(filters, alpha, kernel=(3, 3), strides=(1, 1)):
+            channel_axis = 1
+
+            model.add(Conv2D(filters, kernel,
+                              padding='same',
+                              use_bias=False,
+                              strides=strides, 
+                              input_shape=(3, 32, 32)))
+            model.add(BatchNormalization(axis=channel_axis))
+            model.add(Activation('relu'))
+
+        def _depthwise_conv_block(pointwise_conv_filters, alpha, depth_multiplier=1, strides=(1, 1)):
+            channel_axis = 1 
+
+            model.add(ZeroPadding2D(padding=((1,1), (1,1))))
+
+            model.add(DepthwiseConv2D((3, 3),
+                                       padding='valid',
+                                       #depth_multiplier=depth_multiplier,
+                                       strides=strides,
+                                       use_bias=False))    
+            model.add(BatchNormalization(axis=channel_axis))
+
+            model.add(Activation('relu'))
+            model.add(Conv2D(pointwise_conv_filters, (1, 1),
+                              padding='same',
+                              use_bias=False,
+                              strides=(1, 1)))
+            model.add(BatchNormalization(axis=channel_axis))
+            model.add(Activation('relu'))
+
+
+        _conv_block(32, alpha, strides=(1, 1))
+
+        _depthwise_conv_block(64, alpha, depth_multiplier)
+
+        _depthwise_conv_block(128, alpha, depth_multiplier,
+                                  strides=(2, 2))
+        _depthwise_conv_block(128, alpha, depth_multiplier)
+        model.add(Dropout(rate=0.5))
+
+        _depthwise_conv_block(256, alpha, depth_multiplier, 
+                          strides=(2, 2))
+        _depthwise_conv_block(256, alpha, depth_multiplier)
+        model.add(Dropout(rate=0.5))
+
+        _depthwise_conv_block(512, alpha, depth_multiplier,
+                          strides=(2, 2))
+        _depthwise_conv_block(512, alpha, depth_multiplier)
+        _depthwise_conv_block(512, alpha, depth_multiplier)
+        model.add(Dropout(rate=0.5))
+
+        _depthwise_conv_block(512, alpha, depth_multiplier)
+        _depthwise_conv_block(512, alpha, depth_multiplier)
+        _depthwise_conv_block(512, alpha, depth_multiplier)
+        model.add(Dropout(rate=0.5))
+
+        _depthwise_conv_block(1024, alpha, depth_multiplier,
+                             strides=(2, 2))
+        _depthwise_conv_block(1024, alpha, depth_multiplier)
+        model.add(Dropout(rate=0.5))
+
+        model.add(AveragePooling2D(pool_size=2))
+        model.add(Flatten())
+        model.add(Dense(self.num_classes))    
+        model.add(Activation('softmax'))
+
+        return model
+
+    
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar10.load_data()
+
+        X_train = X_train / 255.0
+        #X_val = X_val / 255.0
+
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean) / (std + 1e-7)
+        #X_val = (X_val - mean) / (std + 1e-7)
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/mobilenet_cifar10/test_input.bin', dtype=np.float32)
+        y_test= np.fromfile(MODEL_PARAMS_DIR + '/mobilenet_cifar10/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/mobilenet_cifar10/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/mobilenet_cifar10/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        # data augmentation, horizontal flips only
+        datagen = ImageDataGenerator(
+                featurewise_center=False,
+                featurewise_std_normalization=False,
+                rotation_range=0.0,
+                width_shift_range=0.0,
+                height_shift_range=0.0,
+                vertical_flip=False,
+                horizontal_flip=True)
+        datagen.fit(X_train)
+
+
+        learning_rates=[]
+        for i in range(50):
+            learning_rates.append(0.01)
+        for i in range(75-50):
+            learning_rates.append(0.001)
+        for i in range(100-75):
+            learning_rates.append(0.0001)
+        for i in range(125-100):
+            learning_rates.append(0.00001)
+            
+        callbacks = [
+            LearningRateScheduler(lambda epoch: float(learning_rates[epoch]))
+        ]
+
+        model.compile(optimizer=keras.optimizers.SGD(lr=learning_rates[0], momentum=0.9, decay=0.0), 
+                               loss='categorical_crossentropy', 
+                               metrics=['accuracy'])
+
+        model.fit_generator(
+            datagen.flow(X_train, y_train, batch_size=128),
+            steps_per_epoch=int(np.ceil(50000 / 128)),
+            validation_data=(X_test, y_test),
+            epochs=125,
+            callbacks=callbacks
+        )
+
+        return model
+
+  
+    
+if __name__ == '__main__':
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/mobilenet_cifar10/'
+    keras_model_file = MODEL_PARAMS_DIR + '/mobilenet_cifar10/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/mobilenet_cifar10_src/'
+    num_classes = 10
+    batch_size = 500
+
+    model = MobileNet_CIFAR10('MobileNet_CIFAR10', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+

hpvm/test/dnn_benchmarks/keras/resnet18_cifar10.py

+"""
+#Trains a ResNet on the CIFAR10 dataset.
+
+ResNet v1:
+[Deep Residual Learning for Image Recognition
+](https://arxiv.org/pdf/1512.03385.pdf)
+
+ResNet v2:
+[Identity Mappings in Deep Residual Networks
+](https://arxiv.org/pdf/1603.05027.pdf)
+
+
+Model|n|200-epoch accuracy|Original paper accuracy |sec/epoch GTX1080Ti
+:------------|--:|-------:|-----------------------:|---:
+ResNet20   v1|  3| 92.16 %|                 91.25 %|35
+ResNet32   v1|  5| 92.46 %|                 92.49 %|50
+ResNet44   v1|  7| 92.50 %|                 92.83 %|70
+ResNet56   v1|  9| 92.71 %|                 93.03 %|90
+ResNet110  v1| 18| 92.65 %|            93.39+-.16 %|165
+ResNet164  v1| 27|     - %|                 94.07 %|  -
+ResNet1001 v1|N/A|     - %|                 92.39 %|  -
+
+ 
+
+Model|n|200-epoch accuracy|Original paper accuracy |sec/epoch GTX1080Ti
+:------------|--:|-------:|-----------------------:|---:
+ResNet20   v2|  2|     - %|                     - %|---
+ResNet32   v2|N/A| NA    %|            NA         %| NA
+ResNet44   v2|N/A| NA    %|            NA         %| NA
+ResNet56   v2|  6| 93.01 %|            NA         %|100
+ResNet110  v2| 12| 93.15 %|            93.63      %|180
+ResNet164  v2| 18|     - %|            94.54      %|  -
+ResNet1001 v2|111|     - %|            95.08+-.14 %|  -
+"""
+
+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar10
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+# Training parameters
+batch_size = 32  # orig paper trained all networks with batch_size=128
+epochs = 200
+
+
+# Model parameter
+# ----------------------------------------------------------------------------
+#           |      | 200-epoch | Orig Paper| 200-epoch | Orig Paper| sec/epoch
+# Model     |  n   | ResNet v1 | ResNet v1 | ResNet v2 | ResNet v2 | GTX1080Ti
+#           |v1(v2)| %Accuracy | %Accuracy | %Accuracy | %Accuracy | v1 (v2)
+# ----------------------------------------------------------------------------
+# ResNet20  | 3 (2)| 92.16     | 91.25     | -----     | -----     | 35 (---)
+# ResNet32  | 5(NA)| 92.46     | 92.49     | NA        | NA        | 50 ( NA)
+# ResNet44  | 7(NA)| 92.50     | 92.83     | NA        | NA        | 70 ( NA)
+# ResNet56  | 9 (6)| 92.71     | 93.03     | 93.01     | NA        | 90 (100)
+# ResNet110 |18(12)| 92.65     | 93.39+-.16| 93.15     | 93.63     | 165(180)
+# ResNet164 |27(18)| -----     | 94.07     | -----     | 94.54     | ---(---)
+# ResNet1001| (111)| -----     | 92.39     | -----     | 95.08+-.14| ---(---)
+# ---------------------------------------------------------------------------
+n = 3
+
+# Model version
+# Orig paper: version = 1 (ResNet v1), Improved ResNet: version = 2 (ResNet v2)
+version = 1
+
+# Computed depth from supplied model parameter n
+if version == 1:
+    depth = n * 6 + 2
+elif version == 2:
+    depth = n * 9 + 2
+
+# Model name, depth and version
+model_type = 'ResNet%dv%d' % (depth, version)
+
+
+    
+def resnet_layer(inputs,
+                 num_filters=16,
+                 kernel_size=3,
+                 strides=1,
+                 activation='relu',
+                 batch_normalization=True,
+                 conv_first=True):
+    """2D Convolution-Batch Normalization-Activation stack builder
+
+    # Arguments
+        inputs (tensor): input tensor from input image or previous layer
+        num_filters (int): Conv2D number of filters
+        kernel_size (int): Conv2D square kernel dimensions
+        strides (int): Conv2D square stride dimensions
+        activation (string): activation name
+        batch_normalization (bool): whether to include batch normalization
+        conv_first (bool): conv-bn-activation (True) or
+            bn-activation-conv (False)
+
+    # Returns
+        x (tensor): tensor as input to the next layer
+    """
+    conv = Conv2D(num_filters,
+                  kernel_size=kernel_size,
+                  strides=strides,
+                  padding='valid', # NOTE: using valid convs with explicit pad operation
+                  kernel_initializer='he_normal',
+                  kernel_regularizer=regularizers.l2(1e-4))
+
+    padding_value = int((kernel_size - 1) / 2)
+    zero_padding = ZeroPadding2D(padding = (padding_value, padding_value))
+
+    # FIXME: Temporarily disabled batch normalization
+    batch_normalization = False
+
+    x = inputs
+    x = zero_padding(x)
+    if conv_first:
+        x = conv(x)
+        if batch_normalization:
+            x = BatchNormalization()(x)
+        if activation is not None:
+            x = Activation(activation)(x)
+    else:
+        if batch_normalization:
+            x = BatchNormalization()(x)
+        if activation is not None:
+            x = Activation(activation)(x)
+        x = conv(x)
+    return x
+
+
+class ResNet18_CIFAR10(Benchmark):
+
+    def lr_schedule(self, epoch):
+        """Learning Rate Schedule
+
+        Learning rate is scheduled to be reduced after 80, 120, 160, 180 epochs.
+        Called automatically every epoch as part of callbacks during training.
+
+        # Arguments
+            epoch (int): The number of epochs
+
+        # Returns
+            lr (float32): learning rate
+        """
+        lr = 1e-3
+        if epoch > 180:
+            lr *= 0.5e-3
+        elif epoch > 160:
+            lr *= 1e-3
+        elif epoch > 120:
+            lr *= 1e-2
+        elif epoch > 80:
+            lr *= 1e-1
+            
+        return lr
+    
+
+    def resnet_v0(self, input_shape, depth, num_classes=10):
+        """ResNet Version 1 Model builder [a]
+
+        Stacks of 2 x (3 x 3) Conv2D-BN-ReLU
+        Last ReLU is after the shortcut connection.
+        At the beginning of each stage, the feature map size is halved (downsampled)
+        by a convolutional layer with strides=2, while the number of filters is
+        doubled. Within each stage, the layers have the same number filters and the
+        same number of filters.
+        Features maps sizes:
+        stage 0: 32x32, 16
+        stage 1: 16x16, 32
+        stage 2:  8x8,  64
+        The Number of parameters is approx the same as Table 6 of [a]:
+        ResNet20 0.27M
+        ResNet32 0.46M
+        ResNet44 0.66M
+        ResNet56 0.85M
+        ResNet110 1.7M
+
+        # Arguments
+            input_shape (tensor): shape of input image tensor
+            depth (int): number of core convolutional layers
+            num_classes (int): number of classes (CIFAR10 has 10)
+
+        # Returns
+            model (Model): Keras model instance
+        """
+        if (depth - 2) % 6 != 0:
+            raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])')
+        # Start model definition.
+        num_filters = 16
+        num_res_blocks = int((depth - 2) / 6)
+
+        inputs = Input(shape=input_shape)
+        x = resnet_layer(inputs=inputs)
+        # Instantiate the stack of residual units
+        for stack in range(3):
+            for res_block in range(num_res_blocks):
+                strides = 1
+                if stack > 0 and res_block == 0:  # first layer but not first stack
+                    strides = 2  # downsample
+                y = resnet_layer(inputs=x,
+                                 num_filters=num_filters,
+                                 strides=strides)
+                y = resnet_layer(inputs=y,
+                                 num_filters=num_filters,
+                                 activation=None)
+                if stack > 0 and res_block == 0:  # first layer but not first stack
+                    # linear projection residual shortcut connection to match
+                    # changed dims
+                    x = resnet_layer(inputs=x,
+                                     num_filters=num_filters,
+                                     kernel_size=1,
+                                     strides=strides,
+                                     activation=None,
+                                     batch_normalization=False)
+                x = keras.layers.add([x, y])
+                x = Activation('relu')(x)
+            num_filters *= 1
+
+        # Add classifier on top.
+        # v1 does not use BN after last shortcut connection-ReLU
+        #-- x = AveragePooling2D(pool_size=8)(x)
+        y = Flatten()(x)
+        x = Dense(64)(y)
+        outputs = Dense(num_classes,
+                        activation='softmax',
+                        kernel_initializer='he_normal')(x)
+
+        # Instantiate model.
+        model = Model(inputs=inputs, outputs=outputs)
+        return model
+
+
+    def resnet_v1_1(self, input_shape, depth, num_classes=10):
+        """ResNet Version 1 Model builder [a]
+
+        Stacks of 2 x (3 x 3) Conv2D-BN-ReLU
+        Last ReLU is after the shortcut connection.
+        At the beginning of each stage, the feature map size is halved (downsampled)
+        by a convolutional layer with strides=2, while the number of filters is
+        doubled. Within each stage, the layers have the same number filters and the
+        same number of filters.
+        Features maps sizes:
+        stage 0: 32x32, 16
+        stage 1: 16x16, 32
+        stage 2:  8x8,  64
+        The Number of parameters is approx the same as Table 6 of [a]:
+        ResNet20 0.27M
+        ResNet32 0.46M
+        ResNet44 0.66M
+        ResNet56 0.85M
+        ResNet110 1.7M
+
+        # Arguments
+            input_shape (tensor): shape of input image tensor
+            depth (int): number of core convolutional layers
+            num_classes (int): number of classes (CIFAR10 has 10)
+
+        # Returns
+            model (Model): Keras model instance
+        """
+        if (depth - 2) % 6 != 0:
+            raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])')
+        # Start model definition.
+        num_filters = 16
+        num_res_blocks = int((depth - 2) / 6)
+
+        inputs = Input(shape=input_shape)
+        x = resnet_layer(inputs=inputs)
+        # Instantiate the stack of residual units
+        for stack in range(3):
+            for res_block in range(num_res_blocks):
+                strides = 1
+                if stack > 0 and res_block == 0:  # first layer but not first stack
+                    strides = 2  # downsample
+                y = resnet_layer(inputs=x,
+                                 num_filters=num_filters,
+                                 strides=strides)
+                y = resnet_layer(inputs=y,
+                                 num_filters=num_filters,
+                                 activation=None)
+                if stack > 0 and res_block == 0:  # first layer but not first stack
+                    # linear projection residual shortcut connection to match
+                    # changed dims
+                    x = resnet_layer(inputs=x,
+                                     num_filters=num_filters,
+                                     kernel_size=1,
+                                     strides=strides,
+                                     activation=None,
+                                     batch_normalization=False)
+                x = keras.layers.add([x, y])
+                x = Activation('relu')(x)
+            num_filters *= 2
+
+
+        x = AveragePooling2D(pool_size=8)(x)
+        y = Flatten()(x)
+        outputs = Dense(num_classes,
+                        #activation='softmax',
+                        kernel_initializer='he_normal')(y)
+
+        outputs = Activation('softmax')(outputs)
+
+
+        # Instantiate model.
+        model = Model(inputs=inputs, outputs=outputs)
+        return model
+
+
+
+    def resnet_v2(self, input_shape, depth, num_classes=10):
+        """ResNet Version 2 Model builder [b]
+
+        Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as
+        bottleneck layer
+        First shortcut connection per layer is 1 x 1 Conv2D.
+        Second and onwards shortcut connection is identity.
+        At the beginning of each stage, the feature map size is halved (downsampled)
+        by a convolutional layer with strides=2, while the number of filter maps is
+        doubled. Within each stage, the layers have the same number filters and the
+        same filter map sizes.
+        Features maps sizes:
+        conv1  : 32x32,  16
+        stage 0: 32x32,  64
+        stage 1: 16x16, 128
+        stage 2:  8x8,  256
+
+        # Arguments
+            input_shape (tensor): shape of input image tensor
+            depth (int): number of core convolutional layers
+            num_classes (int): number of classes (CIFAR10 has 10)
+
+        # Returns
+            model (Model): Keras model instance
+        """
+        if (depth - 2) % 9 != 0:
+            raise ValueError('depth should be 9n+2 (eg 56 or 110 in [b])')
+        # Start model definition.
+        num_filters_in = 16
+        num_res_blocks = int((depth - 2) / 9)
+
+        inputs = Input(shape=input_shape)
+        # v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
+        x = resnet_layer(inputs=inputs,
+                         num_filters=num_filters_in,
+                         conv_first=True)
+
+        # Instantiate the stack of residual units
+        for stage in range(3):
+            for res_block in range(num_res_blocks):
+                activation = 'relu'
+                batch_normalization = True
+                strides = 1
+                if stage == 0:
+                    num_filters_out = num_filters_in * 4
+                    if res_block == 0:  # first layer and first stage
+                        activation = None
+                        batch_normalization = False
+                else:
+                    num_filters_out = num_filters_in * 2
+                    if res_block == 0:  # first layer but not first stage
+                        strides = 2    # downsample
+
+                # bottleneck residual unit
+                y = resnet_layer(inputs=x,
+                                 num_filters=num_filters_in,
+                                 kernel_size=1,
+                                 strides=strides,
+                                 activation=activation,
+                                 batch_normalization=batch_normalization,
+                                 conv_first=False)
+                y = resnet_layer(inputs=y,
+                                 num_filters=num_filters_in,
+                                 conv_first=False)
+                y = resnet_layer(inputs=y,
+                                 num_filters=num_filters_out,
+                                 kernel_size=1,
+                                 conv_first=False)
+                if res_block == 0:
+                    # linear projection residual shortcut connection to match
+                    # changed dims
+                    x = resnet_layer(inputs=x,
+                                     num_filters=num_filters_out,
+                                     kernel_size=1,
+                                     strides=strides,
+                                     activation=None,
+                                     batch_normalization=False)
+                x = keras.layers.add([x, y])
+
+            num_filters_in = num_filters_out
+
+        # Add classifier on top.
+        # v2 has BN-ReLU before Pooling
+        x = BatchNormalization()(x)
+        x = Activation('relu')(x)
+        x = AveragePooling2D(pool_size=8)(x)
+        y = Flatten()(x)
+        outputs = Dense(num_classes,
+                        activation='softmax',
+                        kernel_initializer='he_normal')(y)
+
+        # Instantiate model.
+        model = Model(inputs=inputs, outputs=outputs)
+        return model
+
+    
+    def buildModel(self):
+
+        depth = 20
+        input_shape = (3, 32, 32)
+        
+        if version == 2:
+            model = self.resnet_v2(input_shape=input_shape, depth=depth)
+        else:
+            model = self.resnet_v1_1(input_shape=input_shape, depth=depth)
+
+        return model
+    
+    
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar10.load_data()
+
+        X_train = X_train / 255.0
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean)
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/resnet18_cifar10/test_input.bin', dtype=np.float32)
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/resnet18_cifar10/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/resnet18_cifar10/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/resnet18_cifar10/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        model.compile(
+            loss='categorical_crossentropy',
+            optimizer=Adam(lr=self.lr_schedule(0)),
+            metrics=['accuracy']
+        )
+
+        
+        lr_scheduler = LearningRateScheduler(self.lr_schedule)
+
+        lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1),
+                                       cooldown=0,
+                                       patience=5,
+                                       min_lr=0.5e-6)
+
+        callbacks = [lr_reducer, lr_scheduler]
+
+        # Run training, with or without data augmentation.
+        if not data_augmentation:
+            print('Not using data augmentation.')
+            model.fit(X_train, y_train,
+                      batch_size=batch_size,
+                      epochs=epochs,
+                      validation_data=(X_test, y_test),
+                      shuffle=True,
+                      callbacks=callbacks)
+        else:
+            print('Using real-time data augmentation.')
+            # This will do preprocessing and realtime data augmentation:
+            datagen = ImageDataGenerator(
+                # set input mean to 0 over the dataset
+                featurewise_center=False,
+                # set each sample mean to 0
+                samplewise_center=False,
+                # divide inputs by std of dataset
+                featurewise_std_normalization=False,
+                # divide each input by its std
+                samplewise_std_normalization=False,
+                # apply ZCA whitening
+                zca_whitening=False,
+                # epsilon for ZCA whitening
+                zca_epsilon=1e-06,
+                # randomly rotate images in the range (deg 0 to 180)
+                rotation_range=0,
+                # randomly shift images horizontally
+                width_shift_range=0.1,
+                # randomly shift images vertically
+                height_shift_range=0.1,
+                # set range for random shear
+                shear_range=0.,
+                # set range for random zoom
+                zoom_range=0.,
+                # set range for random channel shifts
+                channel_shift_range=0.,
+                # set mode for filling points outside the input boundaries
+                fill_mode='nearest',
+                # value used for fill_mode = "constant"
+                cval=0.,
+                # randomly flip images
+                horizontal_flip=True,
+                # randomly flip images
+                vertical_flip=False,
+                # set rescaling factor (applied before any other transformation)
+                rescale=None,
+                # set function that will be applied on each input
+                preprocessing_function=None,
+                # image data format, either "channels_first" or "channels_last"
+                data_format="channels_first",
+                # fraction of images reserved for validation (strictly between 0 and 1)
+                validation_split=0.0)
+
+            # Compute quantities required for featurewise normalization
+            # (std, mean, and principal components if ZCA whitening is applied).
+            datagen.fit(X_train)
+
+            # Fit the model on the batches generated by datagen.flow().
+            model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size),
+                                validation_data=(X_test, y_test),
+                                epochs=epochs, verbose=1, workers=4,
+                                callbacks=callbacks)
+
+        return model
+
+  
+    
+if __name__ == '__main__':
+
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/resnet18_cifar10/'
+    keras_model_file = MODEL_PARAMS_DIR + '/resnet18_cifar10/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/resnet18_cifar10_src/'
+    num_classes = 10
+    batch_size = 500
+
+    model = ResNet18_CIFAR10('ResNet18_CIFAR10', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+    

hpvm/test/dnn_benchmarks/keras/resnet50_imagenet.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class ResNet50(Benchmark):
+    
+    def buildModel(self):
+        
+        def identity_block(input_tensor, kernel_size, filters, stage, block):
+            filters1, filters2, filters3 = filters
+            bn_axis = 1
+
+            x = Conv2D(filters1, (1, 1))(input_tensor)
+            x = BatchNormalization(axis=bn_axis)(x)
+            x = Activation('relu')(x)
+
+            x = Conv2D(filters2, kernel_size,
+                              padding='same')(x)
+            x = BatchNormalization(axis=bn_axis)(x)
+            x = Activation('relu')(x)
+
+            x = Conv2D(filters3, (1, 1))(x)
+            x = BatchNormalization(axis=bn_axis)(x)
+
+            x = add([x, input_tensor])
+            x = Activation('relu')(x)
+            return x
+
+        def conv_block(input_tensor,
+                       kernel_size,
+                       filters,
+                       stage,
+                       block,
+                       strides=(2, 2)):
+            filters1, filters2, filters3 = filters
+            bn_axis = 1
+            x = Conv2D(filters1, (1, 1), strides=strides)(input_tensor)
+            x = BatchNormalization(axis=bn_axis)(x)
+            x = Activation('relu')(x)
+
+            x = Conv2D(filters2, kernel_size, padding='same')(x)
+            x = BatchNormalization(axis=bn_axis)(x)
+            x = Activation('relu')(x)
+
+            x = Conv2D(filters3, (1, 1))(x)
+            x = BatchNormalization(axis=bn_axis)(x)
+
+            shortcut = Conv2D(filters3, (1, 1), strides=strides)(input_tensor)
+            shortcut = BatchNormalization(
+                axis=bn_axis)(shortcut)
+
+            x = add([x, shortcut])
+            x = Activation('relu')(x)
+            return x
+
+        img_input = Input(shape=(3, 224, 224))
+        bn_axis = 1
+
+        x = ZeroPadding2D((3, 3))(img_input)
+        x = Conv2D(64, (7, 7), strides=(2, 2))(x)
+    #     x = BatchNormalization(axis=bn_axis)(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((3, 3), strides=(2, 2))(x)
+        x = BatchNormalization(axis=bn_axis)(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')
+        x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
+        x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
+        x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
+
+        x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
+        x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
+        x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
+        x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
+        x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
+        x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
+
+        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')
+
+        x = AveragePooling2D((7, 7))(x)
+        x = Flatten()(x)
+        x = Dense(1000)(x)
+        x = Activation('softmax')(x)
+
+        model = Model(img_input, x)
+        
+        return model
+
+    
+    def data_preprocess(self):
+        X_train, y_train = None, None
+        
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/resnet50_imagenet/test_input.bin', dtype=np.float32)
+        X_test = X_test.reshape((-1, 3, 224, 224)) 
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/resnet50_imagenet/test_labels.bin', dtype=np.uint32)
+        
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/resnet50_imagenet/tune_input.bin', dtype=np.float32)
+        X_tuner = X_tuner.reshape((-1, 3, 224, 224)) 
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/resnet50_imagenet/tune_labels.bin', dtype=np.uint32)
+ 
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+    
+
+    def trainModel(self, model):
+
+        assert False, "ImageNet training not supported - use Pretrained weights"
+
+
+    
+if __name__ == '__main__':
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/resnet50_imagenet/'
+    keras_model_file = MODEL_PARAMS_DIR + '/resnet50_imagenet/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/resnet50_imagenet_src/'
+    num_classes = 1000
+    batch_size = 50
+
+    model = ResNet50('ResNet50_imagenet', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+
+
+    

hpvm/test/dnn_benchmarks/keras/vgg16_cifar10.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar10
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class VGG16_CIFAR10(Benchmark):
+        
+    def buildModel(self):
+        # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper.
+
+        self.weight_decay = 0.0005
+        self.x_shape = [3, 32, 32]
+
+        model = Sequential()
+        weight_decay = self.weight_decay
+
+        model.add(Conv2D(64, (3, 3), padding='same',
+                         input_shape=self.x_shape,kernel_regularizer=regularizers.l2(weight_decay)))
+        
+        model.add(Activation('relu'))
+        model.add(Dropout(0.3))
+
+        model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+        model.add(Dropout(0.5))
+
+        model.add(Flatten())
+        model.add(Dense(512,kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+    
+        model.add(Dropout(0.5))
+        model.add(Dense(self.num_classes))
+        model.add(Activation('softmax'))
+        return model
+
+    
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar10.load_data()
+
+        X_train = X_train / 255.0
+        #X_val = X_val / 255.0
+
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean) / (std + 1e-7)
+        #X_val = (X_val - mean) / (std + 1e-7)
+
+        X_test= np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar10/test_input.bin', dtype=np.float32)
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar10/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+        X_tuner= np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar10/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar10/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    def trainModel(self, model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        batch_size = 128
+        learning_rate = 0.01
+        lr_drop = 20
+
+
+        def lr_scheduler(epoch):
+            return learning_rate * (0.5 ** (epoch // lr_drop))
+
+        reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
+
+        #data augmentation
+        datagen = ImageDataGenerator(
+            featurewise_center=False,  # set input mean to 0 over the dataset
+            samplewise_center=False,  # set each sample mean to 0
+            featurewise_std_normalization=False,  # divide inputs by std of the dataset
+            samplewise_std_normalization=False,  # divide each input by its std
+            zca_whitening=False,  # apply ZCA whitening
+            rotation_range=15,  # randomly rotate images in the range (degrees, 0 to 180)
+            width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
+            height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
+            horizontal_flip=True,  # randomly flip images
+            vertical_flip=False)  # randomly flip images
+        # (std, mean, and principal components if ZCA whitening is applied).
+        datagen.fit(X_train)
+
+
+        model.compile(
+            loss='categorical_crossentropy', 
+            optimizer=keras.optimizers.SGD(lr=learning_rate, decay=1e-6, momentum=0.9, nesterov=True),
+            metrics=['accuracy']
+        )
+
+        # training process in a for loop with learning rate drop every 20 epoches.
+        
+        model.fit_generator(
+            datagen.flow(X_train, y_train, batch_size=batch_size),
+            steps_per_epoch=X_train.shape[0] // batch_size,
+            epochs=250,
+            validation_data=(X_test, y_test),
+            callbacks=[reduce_lr]
+        )
+        
+        return model
+
+
+    
+if __name__ == '__main__':
+      
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/vgg16_cifar10/'
+    keras_model_file = MODEL_PARAMS_DIR + '/vgg16_cifar10/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/vgg16_cifar10_src/'
+    num_classes = 10
+    batch_size = 500
+
+    model = VGG16_CIFAR10('VGG16_CIFAR10', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+
+    

hpvm/test/dnn_benchmarks/keras/vgg16_cifar100.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from keras.datasets import cifar100
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class VGG16_CIFAR100(Benchmark):
+
+    def buildModel(self):
+
+        # Build the network of vgg for 100 classes 
+        self.weight_decay = 0.0005
+        self.x_shape = [3, 32, 32]
+
+        model = Sequential()
+        weight_decay = self.weight_decay
+
+        model.add(Conv2D(64, (3, 3), padding='same',
+                         input_shape=self.x_shape,kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.3))
+
+        model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+        model.add(Dropout(0.4))
+
+        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+
+        model.add(MaxPooling2D(pool_size=(2, 2)))
+        model.add(Dropout(0.5))
+
+        model.add(Flatten())
+        model.add(Dense(512,kernel_regularizer=regularizers.l2(weight_decay)))
+        model.add(Activation('relu'))
+        #model.add(BatchNormalization())
+
+        model.add(Dropout(0.5))
+        model.add(Dense(self.num_classes))
+        model.add(Activation('softmax'))
+        return model
+
+
+    def data_preprocess(self):
+
+        (X_train, y_train), (X_val, y_val) = cifar100.load_data()
+
+        X_train = X_train / 255.0
+        #X_val = X_val / 255.0
+
+        mean = np.mean(X_train)
+        std = np.std(X_train)
+        X_train = (X_train - mean) / (std + 1e-7)
+        #X_val = (X_val - mean) / (std + 1e-7)
+
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar100/test_input.bin', dtype=np.float32)
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar100/test_labels.bin', dtype=np.uint32)
+
+        X_test = X_test.reshape((-1,3,32,32))
+
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar100/tune_input.bin', dtype=np.float32)
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_cifar100/tune_labels.bin', dtype=np.uint32)
+
+        X_tuner = X_tuner.reshape((-1,3,32,32))
+
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+
+
+    def trainModel(self,model, X_train, y_train, X_test, y_test):
+
+        y_train = to_categorical(y_train, self.num_classes)
+        y_test = to_categorical(y_test, self.num_classes)
+
+        batch_size = 128
+        learning_rate = 0.1
+        lr_drop = 30
+
+
+        def lr_scheduler(epoch):
+            return learning_rate * (0.5 ** (epoch // lr_drop))
+
+        reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
+
+        #data augmentation
+        datagen = ImageDataGenerator(
+            featurewise_center=False,  # set input mean to 0 over the dataset
+            samplewise_center=False,  # set each sample mean to 0
+            featurewise_std_normalization=False,  # divide inputs by std of the dataset
+            samplewise_std_normalization=False,  # divide each input by its std
+            zca_whitening=False,  # apply ZCA whitening
+            rotation_range=15,  # randomly rotate images in the range (degrees, 0 to 180)
+            width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
+            height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
+            horizontal_flip=True,  # randomly flip images
+            vertical_flip=False)  # randomly flip images
+        # (std, mean, and principal components if ZCA whitening is applied).
+        datagen.fit(X_train)
+
+
+        model.compile(
+            loss='categorical_crossentropy',
+            optimizer=optimizers.Adam(lr=learning_rate),
+            metrics=['accuracy']
+        )
+        
+        # training process in a for loop with learning rate drop every 25 epoches.
+        
+        model.fit_generator(
+            datagen.flow(X_train, y_train, batch_size=batch_size),
+            steps_per_epoch=X_train.shape[0] // batch_size,
+            epochs=250,
+            validation_data=(X_test, y_test),
+            callbacks=[reduce_lr]
+        )
+
+        return model
+
+
+    
+if __name__ == '__main__':
+
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/vgg16_cifar100/'
+    keras_model_file = MODEL_PARAMS_DIR + '/vgg16_cifar100/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/vgg16_cifar100_src/'
+    num_classes = 100
+    batch_size = 100
+
+    model = VGG16_CIFAR100('VGG16_CIFAR100', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    model.run(sys.argv)
+    

hpvm/test/dnn_benchmarks/keras/vgg16_imagenet.py

+import os
+import sys
+import glob
+
+import numpy as np
+import tensorflow as tf
+import scipy
+import scipy.io
+import keras
+from keras.models import Model, Sequential
+from keras.layers import *
+from keras.optimizers import Adam
+from keras import regularizers
+from keras import backend as K
+from keras.utils import to_categorical
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import LearningRateScheduler
+
+from Benchmark import Benchmark
+from Config import MODEL_PARAMS_DIR
+
+
+
+class VGG16(Benchmark):
+
+    def buildModel(self):
+        img_input = Input(shape=(3, 224, 224))
+
+        # Block 1
+        x = ZeroPadding2D(padding=(1, 1))(img_input)
+        x = Conv2D(64, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(64, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((2, 2), strides=(2, 2))(x)
+
+        # Block 2
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(128, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(128, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((2, 2), strides=(2, 2))(x)
+
+        # Block 3
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(256, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(256, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(256, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((2, 2), strides=(2, 2))(x)
+
+        # Block 4
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((2, 2), strides=(2, 2))(x)
+
+        # Block 5
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = ZeroPadding2D(padding=(1, 1))(x)
+        x = Conv2D(512, (3, 3), padding='valid')(x)
+        x = Activation('relu')(x)
+        x = MaxPooling2D((2, 2), strides=(2, 2))(x)
+
+    #     x = Flatten(data_format='channels_first')(x)
+        x = Flatten()(x)
+
+        x = Dense(4096)(x)
+        x = Activation('relu')(x)
+        x = Dropout(0.5)(x)
+        x = Dense(4096)(x)   
+        x = Activation('relu')(x)
+        x = Dropout(0.5)(x)
+        x = Dense(1000)(x)
+        x = Activation('softmax')(x)
+
+        model = Model(img_input, x)
+            
+        return model
+
+
+    def data_preprocess(self):
+        X_train, y_train = None, None
+        
+        X_test = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_imagenet/test_input.bin', dtype=np.float32)
+        X_test = X_test.reshape((-1, 3, 224, 224)) 
+        y_test = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_imagenet/test_labels.bin', dtype=np.uint32)
+        
+        X_tuner = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_imagenet/tune_input.bin', dtype=np.float32)
+        X_tuner = X_tuner.reshape((-1, 3, 224, 224)) 
+        y_tuner = np.fromfile(MODEL_PARAMS_DIR + '/vgg16_imagenet/tune_labels.bin', dtype=np.uint32)
+ 
+        return X_train, y_train, X_test, y_test, X_tuner, y_tuner
+    
+    
+    def trainModel(self, model):
+
+        assert False, "ImageNet training not supported - use Pretrained weights"
+
+
+    
+if __name__ == '__main__':
+
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
+
+
+    ### Parameters specific to each benchmark
+    reload_dir = MODEL_PARAMS_DIR + '/vgg16_imagenet/'
+    keras_model_file = MODEL_PARAMS_DIR + '/vgg16_imagenet/weights.h5'
+    data_dir = '' 
+    src_dir = 'data/vgg16_imagenet_src/'
+    num_classes = 1000
+    batch_size = 25
+
+    alexnet = VGG16('VGG16_imagenet', reload_dir, keras_model_file, data_dir, src_dir, num_classes, batch_size)
+    
+    alexnet.run(sys.argv)
+
+
+