def test_layers_connected(self):
train_dir = os.path.join(file_dir, 'unit_test_images/')
validation_dir = os.path.join(file_dir, 'unit_test_images/')
test_dir = os.path.join(file_dir, 'unit_test_images/')
model = rt.KerasInception(dense_layers=1, dropout=0, dense_dim=1024)
# initialize model (size of dense layer), 0 epochs
model.train(
train_dir=train_dir,
validation_dir=validation_dir,
epochs=0,
)
self.assertTrue(
np.array_equal(
model.model.get_layer('base_output').output,
model.model.get_layer('pooling').input))
self.assertTrue(
np.array_equal(
model.model.get_layer('pooling').output,
model.model.get_layer('dense0').input))
self.assertTrue(
np.array_equal(
model.model.get_layer('dense0').output,
model.model.get_layer('softmax').input))
def test_full_training(self):
path_of_zip = os.path.join(file_dir, 'unit_test_images_zipped.zip')
train_dir = rt.unzip_and_return_path_to_folder(path_of_zip)
# dummy directories with black/white images
validation_dir = os.path.join(file_dir, 'unit_test_images/')
test_dir = os.path.join(file_dir, 'unit_test_images/')
# train
model = rt.KerasInception(dense_layers=1, dropout=0, dense_dim=1024)
model.train(train_dir=train_dir,
validation_dir=validation_dir,
fine_tune=True,
epochs=2,
salt_pepper=True,
classes_txt_dir=os.getcwd(),
unfrozen_layers=311,
steps_per_epoch=1000)
# evaluate
score = model.evaluate(test_dir=test_dir)
print("accuracy on test images")
print(score[1])
# check if significantly better than random
self.assertTrue(score[1] > 0.6)
def test_base_model_stable(self):
# dummy directories with black/white images
train_dir = os.path.join(file_dir, 'unit_test_images/')
validation_dir = os.path.join(file_dir, 'unit_test_images/')
test_dir = os.path.join(file_dir, 'unit_test_images/')
# initialize two lists for weights
before_transferred_weights = []
after_transferred_weights = []
# store all weights before
base_model = rt.InceptionV3(weights='imagenet', include_top=False)
# create model
model = rt.KerasInception(dense_layers=1, dropout=0.01, dense_dim=1024)
# initialize model (size of dense layer), 0 epochs
model.train(
train_dir=train_dir,
validation_dir=validation_dir,
epochs=0,
augmentation_params=rt.get_augmentation_params(1),
)
for layer_bm, layer_fm in zip(base_model.layers, model.model.layers):
before_transferred_weights.append(layer_fm.get_weights())
# train
model.train(train_dir=train_dir,
validation_dir=validation_dir,
epochs=1,
salt_pepper=True,
classes_txt_dir=os.getcwd(),
unfrozen_layers=0,
augmentation_params=rt.get_augmentation_params(0),
steps_per_epoch=1000)
# store all weights after
for layer_bm, layer_fm in zip(base_model.layers, model.model.layers):
after_transferred_weights.append(layer_fm.get_weights())
# check that nothing changed for any of the layers
for b, a in zip(before_transferred_weights, after_transferred_weights):
self.assertTrue(np.array_equal(b, a))
def test_training_last_layers(self):
train_dir = os.path.join(file_dir,
os.path.join(file_dir, 'unit_test_images/'))
validation_dir = os.path.join(
file_dir, os.path.join(file_dir, 'unit_test_images/'))
test_dir = os.path.join(file_dir,
os.path.join(file_dir, 'unit_test_images/'))
# create model
model = rt.KerasInception(dense_layers=1, dropout=0, dense_dim=1024)
# initialize model (size of dense layer), 0 epochs
model.train(
train_dir=train_dir,
validation_dir=validation_dir,
epochs=0,
)
# store weights before
before_softmax = model.model.layers[-1].get_weights()
before_dense = model.model.layers[-2].get_weights()
# train
model.train(train_dir=train_dir,
validation_dir=validation_dir,
fine_tune=True,
epochs=1,
salt_pepper=True,
classes_txt_dir=os.getcwd(),
unfrozen_layers=311,
steps_per_epoch=1000,
validation_dir_2=validation_dir)
# store weights after
after_softmax = model.model.layers[-1].get_weights()
after_dense = model.model.layers[-2].get_weights()
# check that something has changed
self.assertFalse(np.array_equal(before_softmax, after_softmax))
self.assertFalse(np.array_equal(before_dense, after_dense))
def main():
train_dir = 'PATH/TO/DIRECTORY'
validation_dir = 'PATH/TO/DIRECTORY'
test_dir = 'PATH/TO/DIRECTORY'
# can add second dir if need two validation sets
extra_validation_dir = None
dense_layers = 1
input_dim = 224
batch_size = 64
# if true, 2 inception layers will be trained for 1 epoch at end of training
fine_tune = False
# if True, it adds SP noise
add_salt_pepper_noise = False
augmentation_mode = 0
epochs = 10
# has to be a number between 0 and 311
unfrozen_layers = 311
learning_rate = 0.0031622777
model = rt.KerasInception(input_dim=input_dim,
batch_size=batch_size,
dense_layers=dense_layers)
model.train(
train_dir=train_dir,
validation_dir=validation_dir,
fine_tune=fine_tune,
epochs=epochs,
unfrozen_layers=unfrozen_layers,
salt_pepper=add_salt_pepper_noise,
augmentation_params=rt.get_augmentation_params(augmentation_mode),
validation_dir_2=extra_validation_dir)
model.evaluate(test_dir=test_dir)
model.save_model('model.h5')
def grid_search():
logging = True
log_filename = 'log_unfrozen_layers_grid_1epoch.csv'
train_dir = '/data/g1753002_ocado/manhattan_project/training_data/split_ten_set_model_official_SUN_back_2018-04-07_13_19_16/train'
validation_dir = '/data/g1753002_ocado/manhattan_project/training_data/split_ten_set_model_official_SUN_back_2018-04-07_13_19_16/validation'
test_dir = '/data/g1753002_ocado/manhattan_project/test_data/extended_test_set_ambient'
learning_rate_grid = np.logspace(-2, 0, 6) # originally 10 pow -5
unfrozen_layers_grid = np.linspace(0, 311, 10)
dropout_grid = [0, 0.2, 0.5]
layer_grid = [1, 2]
batch_size_grid = [16, 32, 64]
# go through grid of parameters
for lr in learning_rate_grid:
# set parameters
input_dim = 224
fine_tune = False
add_salt_pepper_noise = False # if True, it adds SP noise
augmentation_mode = 0 # 0 = no augmentation, 1 = rotation only, 2 = rotation & zoom
epochs = 18
unfrozen_layers = 311
learning_rate = lr # 0.0001
dense_layers = 1
batch_size = 64
dropout = 0
# initialize & train model
model = retrain.KerasInception(input_dim=input_dim,
batch_size=batch_size,
dense_layers=dense_layers,
dropout=dropout,
lr=learning_rate)
model.train(
train_dir=train_dir,
validation_dir=validation_dir,
fine_tune=fine_tune,
epochs=epochs,
salt_pepper=add_salt_pepper_noise,
augmentation_params=get_augmentation_params(augmentation_mode),
save_model=True,
unfrozen_layers=unfrozen_layers)
# get accuracy score
test_loss, test_acc = model.evaluate(test_dir=test_dir)
# store accuracy & model parameters
if logging:
print("logging now...")
my_file = Path(log_filename)
# write header if this is the first run
if not my_file.is_file():
print("writing head")
with open(log_filename, "w") as log:
log.write(
"datetime,epochs,learning_rate,batch_size,unfrozen_layers,input_dim,dense_layers,dropout,test_loss,test_acc\n"
)
# append parameters
with open(log_filename, "a") as log:
log.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
log.write(',')
log.write(str(epochs))
log.write(',')
log.write(str(learning_rate))
log.write(',')
log.write(str(batch_size))
log.write(',')
log.write(str(unfrozen_layers))
log.write(',')
log.write(str(input_dim))
log.write(',')
log.write(str(dense_layers))
log.write(',')
log.write(str(dropout))
log.write(',')
log.write(str(test_loss))
log.write(',')
log.write(str(test_acc))
log.write('\n')
def evaluate_cnn(learning_rate, dense_layers, batch_size, dropout, dense_dim):
"""
script which takes a number of parameters for neural network training and
returns the best resulting validation accuracy from these parameters
results are also logged to log_filename defined below
"""
# turn float inputs from BO to ints
dense_layers = int(dense_layers + 0.5)
dense_dim = int(dense_dim + 0.5) * 512
batch_size = int(batch_size + 0.5) * 16
logging = True
log_filename = 'log_bo_cnn_' + launch_datetime + '.csv'
# load train images from one zip file
unzipped_dir = retrain.unzip_and_return_path_to_folder(path_of_zip)
train_dir = unzipped_dir + '/images'
# get path for classes.txt
main_dir, filename = os.path.split(path_of_zip)
# set parameters
fine_tune = False # if true, some of the inceptionV3 layers will be trained for 5 epochs at the end of training
add_salt_pepper_noise = False # if True, it adds SP noise
augmentation_mode = 0 # 0 = no augmentation, 1 = rotation only, 2 = rotation & zoom
epochs = 600 / 4
input_dim = 224
# initialize & train model
model = retrain.KerasInception(input_dim=input_dim,
batch_size=batch_size,
dense_layers=dense_layers,
dropout=dropout,
lr=learning_rate,
dense_dim=dense_dim)
history = model.train(
train_dir=train_dir,
validation_dir=validation_dir,
fine_tune=fine_tune,
epochs=epochs,
salt_pepper=add_salt_pepper_noise,
augmentation_params=retrain.get_augmentation_params(augmentation_mode),
classes_txt_dir=main_dir,
save_model=True)
# get accuracy score
# score = model.evaluate(test_dir=test_dir)
# test_accuracy = score[1]
test_accuracy = 0
# store accuracy & model parameters
if logging:
print("logging now...")
my_file = Path(log_filename)
# write header if this is the first run
if not my_file.is_file():
print("writing head")
with open(log_filename, "w") as log:
log.write("datetime,epochs,learning_rate,batch_size,input_dim,\
dense_layers,dropout,dense_dim,best_validation_accuracy,\
test_accuracy,file\n")
# append parameters
with open(log_filename, "a") as log:
log.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
log.write(',')
log.write(str(epochs))
log.write(',')
log.write(str(learning_rate))
log.write(',')
log.write(str(batch_size))
log.write(',')
log.write(str(input_dim))
log.write(',')
log.write(str(dense_layers))
log.write(',')
log.write(str(dropout))
log.write(',')
log.write(str(dense_dim))
log.write(',')
log.write(str(max(history.val_accs)))
log.write(',')
log.write(str(test_accuracy))
log.write(',')
log.write(path_of_zip)
log.write('\n')
return max(history.val_accs) # return best validation accuracy