Adapting VGG16_cifar10 keras script to use new Benchmark class

llvm/projects/keras/src/vgg16_cifar10.py

@@ -14,102 +14,84 @@ from keras import backend as K
 from keras import regularizers
 import os
 import sys
+from Benchmark import Benchmark
 from frontend.approxhpvm_translator import translate_to_approxhpvm
 from frontend.weight_utils import dumpCalibrationData
 
 
 
-class cifar10vgg:
-    def __init__(self,train=True):
-        self.num_classes = 10
+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]
 
-        self.model = self.build_model()
-        if train:
-            self.model = self.train(self.model)
-        else:
-            self.model.load_weights('cifar10vgg.h5')
-
-
-    def build_model(self):
-        # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper.
-
         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'))
@@ -127,30 +109,28 @@ class cifar10vgg:
         X_test = (X_test-mean)/(std+1e-7)
         return X_train, X_test
 
-    
-    def normalize_production(self,x):
-        #this function is used to normalize instances in production according to saved training set statistics
-        # Input: X - a training set
-        # Output X - a normalized training set according to normalization constants.
 
-        #these values produced during first training and are general for the standard cifar10 training set normalization
-        mean = 120.707
-        std = 64.15
-        return (x-mean)/(std+1e-7)
+    def data_preprocess(self):
 
-    
-    def predict(self,x,normalize=True,batch_size=50):
-        if normalize:
-            x = self.normalize_production(x)
-        return self.model.predict(x,batch_size)
+        (X_train, Y_train), (X_test, Y_test) = cifar10.load_data()
+        #X_train = X_train / 255.0
+        #X_test = X_test / 255.0
+
+        mean = np.mean(X_train,axis=(0,1,2,3))
+        std = np.std(X_train,axis=(0,1,2,3))   
+        X_train = (X_train-mean)/(std+1e-7)
+        X_test = (X_test-mean)/(std+1e-7)  
+
+        return X_train, Y_train, X_test, Y_test
 
+
+        
     
-    def train(self,model):
+    def trainModel(self, model):
 
         #training parameters
         batch_size = 128
         #maxepoches = 250
-        #maxepoches = 250
         maxepoches = 30
         learning_rate = 0.01
         lr_decay = 1e-6
@@ -159,7 +139,7 @@ class cifar10vgg:
         (x_train, y_train), (x_test, y_test) = cifar10.load_data()
         x_train = x_train.astype('float32')
         x_test = x_test.astype('float32')
-        x_train, x_test = self.normalize(x_train, x_test)
+        x_train, y_train, x_test, y_test = self.data_preprocess()
 
         y_train = keras.utils.to_categorical(y_train, self.num_classes)
         y_test = keras.utils.to_categorical(y_test, self.num_classes)
@@ -184,7 +164,6 @@ class cifar10vgg:
         datagen.fit(x_train)
 
 
-
         #optimization details
         sgd = optimizers.SGD(lr=learning_rate, decay=lr_decay, momentum=0.9, nesterov=True)
         model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'])
@@ -193,49 +172,35 @@ class cifar10vgg:
         # training process in a for loop with learning rate drop every 25 epoches.
 
         historytemp = model.fit_generator(datagen.flow(x_train, y_train,
-                                         batch_size=batch_size),
-                            steps_per_epoch=x_train.shape[0] // batch_size,
-                            epochs=maxepoches,
-                            validation_data=(x_test, y_test),callbacks=[reduce_lr],verbose=2)
+                                          batch_size=batch_size),
+                                          steps_per_epoch=x_train.shape[0] // batch_size,
+                                          epochs=maxepoches,
+                                          validation_data=(x_test, y_test),callbacks=[reduce_lr],verbose=2)
         
-        model.save_weights('cifar10vgg.h5')
         return model
 
 
-    
-if __name__ == '__main__':
-
-    K.set_image_data_format('channels_first')
 
-    os.environ["CUDA_VISIBLE_DEVICES"] = "1"
     
-    (x_train, y_train), (x_test, y_test) = cifar10.load_data()
-    test_labels = y_test
-    train_labels = y_train
-    x_train = x_train.astype('float32')
-    x_test = x_test.astype('float32')
-
-    y_train = keras.utils.to_categorical(y_train, 10)
-    y_test = keras.utils.to_categorical(y_test, 10)
-
-    model = cifar10vgg()
-
-    predicted_x = model.predict(x_test)
 
-    norm_test = model.normalize_production(x_test)
 
-    # Normalizing train data before dumping
-    #x_train, x_test = model.normalize(x_train, x_test)
-    x_train = model.normalize_production(x_train)
     
-    # dumpCalibrationData("vgg16_cifar_calib.bin", x_train, "vgg16_train_labels.bin", train_labels)
-    
-    translate_to_approxhpvm(model.model, "data/vgg16_cifar10/", norm_test, test_labels, 10)
+if __name__ == "__main__":
 
-    residuals = np.argmax(predicted_x,1)!=np.argmax(y_test,1)
+      
+    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+    # Changing to NCHW format
+    K.set_image_data_format('channels_first')
 
-    loss = sum(residuals)/len(residuals)
-    print("the validation 0/1 loss is: ",loss)
 
+    ### Parameters specific to each benchmark
+    reload_dir = "/home/hsharif3/Gitlab/hpvm/llvm/projects/hpvm-tensor-rt/model_params/vgg16_cifar10/"
+    keras_model_file = "vgg16_cifar10.h5"
+    hpvm_dir = "data/vgg16_cifar10/" 
+    num_classes = 10
 
+    vgg16_cifar10 = VGG16_CIFAR10("vgg16_cifar10", reload_dir, keras_model_file, hpvm_dir, num_classes)
+    
+    vgg16_cifar10.run(sys.argv)
 
+