From ff80f7ebaf884f0d1284d8840176f283ff410490 Mon Sep 17 00:00:00 2001
From: Hashim Sharif <hsharif3@miranda.cs.illinois.edu>
Date: Fri, 19 Mar 2021 21:55:48 -0500
Subject: [PATCH] Removing Keras sources from Frontend location
---
hpvm/projects/keras/src/Benchmark.py | 158 ------
hpvm/projects/keras/src/Config.py | 13 -
hpvm/projects/keras/src/alexnet.py | 159 ------
hpvm/projects/keras/src/alexnet2.py | 147 -----
hpvm/projects/keras/src/alexnet_imagenet.py | 107 ----
hpvm/projects/keras/src/lenet.py | 115 ----
hpvm/projects/keras/src/mobilenet_cifar10.py | 194 -------
hpvm/projects/keras/src/resnet18_cifar10.py | 566 -------------------
hpvm/projects/keras/src/resnet50_imagenet.py | 155 -----
hpvm/projects/keras/src/vgg16_cifar10.py | 197 -------
hpvm/projects/keras/src/vgg16_cifar100.py | 211 -------
hpvm/projects/keras/src/vgg16_imagenet.py | 140 -----
12 files changed, 2162 deletions(-)
delete mode 100644 hpvm/projects/keras/src/Benchmark.py
delete mode 100644 hpvm/projects/keras/src/Config.py
delete mode 100644 hpvm/projects/keras/src/alexnet.py
delete mode 100644 hpvm/projects/keras/src/alexnet2.py
delete mode 100644 hpvm/projects/keras/src/alexnet_imagenet.py
delete mode 100644 hpvm/projects/keras/src/lenet.py
delete mode 100644 hpvm/projects/keras/src/mobilenet_cifar10.py
delete mode 100644 hpvm/projects/keras/src/resnet18_cifar10.py
delete mode 100644 hpvm/projects/keras/src/resnet50_imagenet.py
delete mode 100644 hpvm/projects/keras/src/vgg16_cifar10.py
delete mode 100644 hpvm/projects/keras/src/vgg16_cifar100.py
delete mode 100644 hpvm/projects/keras/src/vgg16_imagenet.py
diff --git a/hpvm/projects/keras/src/Benchmark.py b/hpvm/projects/keras/src/Benchmark.py
deleted file mode 100644
index b0df9d98d6..0000000000
--- a/hpvm/projects/keras/src/Benchmark.py
+++ /dev/null
@@ -1,158 +0,0 @@
-
-
-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()
-
-
-
-
-
diff --git a/hpvm/projects/keras/src/Config.py b/hpvm/projects/keras/src/Config.py
deleted file mode 100644
index 99e696d632..0000000000
--- a/hpvm/projects/keras/src/Config.py
+++ /dev/null
@@ -1,13 +0,0 @@
-
-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)
diff --git a/hpvm/projects/keras/src/alexnet.py b/hpvm/projects/keras/src/alexnet.py
deleted file mode 100644
index 0eefe1b3d3..0000000000
--- a/hpvm/projects/keras/src/alexnet.py
+++ /dev/null
@@ -1,159 +0,0 @@
-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)
-
-
diff --git a/hpvm/projects/keras/src/alexnet2.py b/hpvm/projects/keras/src/alexnet2.py
deleted file mode 100644
index d2c7d566bb..0000000000
--- a/hpvm/projects/keras/src/alexnet2.py
+++ /dev/null
@@ -1,147 +0,0 @@
-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)
diff --git a/hpvm/projects/keras/src/alexnet_imagenet.py b/hpvm/projects/keras/src/alexnet_imagenet.py
deleted file mode 100644
index 1cfe7a79c2..0000000000
--- a/hpvm/projects/keras/src/alexnet_imagenet.py
+++ /dev/null
@@ -1,107 +0,0 @@
-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)
-
-
-
diff --git a/hpvm/projects/keras/src/lenet.py b/hpvm/projects/keras/src/lenet.py
deleted file mode 100644
index 70dd73a66a..0000000000
--- a/hpvm/projects/keras/src/lenet.py
+++ /dev/null
@@ -1,115 +0,0 @@
-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)
diff --git a/hpvm/projects/keras/src/mobilenet_cifar10.py b/hpvm/projects/keras/src/mobilenet_cifar10.py
deleted file mode 100644
index 34335b0f1a..0000000000
--- a/hpvm/projects/keras/src/mobilenet_cifar10.py
+++ /dev/null
@@ -1,194 +0,0 @@
-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)
-
diff --git a/hpvm/projects/keras/src/resnet18_cifar10.py b/hpvm/projects/keras/src/resnet18_cifar10.py
deleted file mode 100644
index 02753f9eac..0000000000
--- a/hpvm/projects/keras/src/resnet18_cifar10.py
+++ /dev/null
@@ -1,566 +0,0 @@
-"""
-#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)
-
diff --git a/hpvm/projects/keras/src/resnet50_imagenet.py b/hpvm/projects/keras/src/resnet50_imagenet.py
deleted file mode 100644
index de42ae48d8..0000000000
--- a/hpvm/projects/keras/src/resnet50_imagenet.py
+++ /dev/null
@@ -1,155 +0,0 @@
-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)
-
-
-
diff --git a/hpvm/projects/keras/src/vgg16_cifar10.py b/hpvm/projects/keras/src/vgg16_cifar10.py
deleted file mode 100644
index 9a5071ee94..0000000000
--- a/hpvm/projects/keras/src/vgg16_cifar10.py
+++ /dev/null
@@ -1,197 +0,0 @@
-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)
-
-
diff --git a/hpvm/projects/keras/src/vgg16_cifar100.py b/hpvm/projects/keras/src/vgg16_cifar100.py
deleted file mode 100644
index 0fd51ebe03..0000000000
--- a/hpvm/projects/keras/src/vgg16_cifar100.py
+++ /dev/null
@@ -1,211 +0,0 @@
-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)
-
diff --git a/hpvm/projects/keras/src/vgg16_imagenet.py b/hpvm/projects/keras/src/vgg16_imagenet.py
deleted file mode 100644
index 6b9458b537..0000000000
--- a/hpvm/projects/keras/src/vgg16_imagenet.py
+++ /dev/null
@@ -1,140 +0,0 @@
-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)
-
-
-
--
GitLab