def train_model(data,
labels,
tuning=False,
randomtune=True,
n_iter=20,
params=None,
test_size=0.25,
logfile=None,
verbose=0,
savefile=None,
epochs=20,
batch_size=128):
if logfile:
orig_stdout = sys.stdout
f = open(logfile, 'a', buffering=0)
sys.stdout = f
timestamp = time.strftime("%d/%m %H:%M:%S")
print '\n' * 2 + '----\n' + timestamp
if tuning:
print "tuning model" + "with RandomSearchCV" if randomtune else "with GridSearchCV"
trainData, trainLabels = data, labels
else:
print "Training model"
#trying with onedimensional output layer
#labels = np.array([0,1])[labels.argmax(1)]
(trainData, testData, trainLabels,
testLabels) = train_test_split(data,
labels,
test_size=test_size,
random_state=16)
def create_model(neurons=(1824, 612), activations = ("relu", "softplus"), inits=("uniform","uniform"),\
dropout_rates=(0.0,0.0), weight_constraints=(0,0)):
model = Sequential()
model.add(
Dense(neurons[0],
input_dim=5160,
kernel_initializer=inits[0],
activation=activations[0],
kernel_constraint=None if dropout_rates[0] == 0.0 else
maxnorm(weight_constraints[0])))
if dropout_rates[0] > 0:
model.add(Dropout(dropout_rates[0]))
model.add(
Dense(neurons[1],
kernel_initializer=inits[1],
activation=activations[1],
kernel_constraint=None if dropout_rates[1] == 0.0 else
maxnorm(weight_constraints[1])))
model.add(Dropout(dropout_rates[1]))
model.add(Dense(2))
model.add(Activation("softmax"))
#previously: sgd = SGD(lr=0.01)
adagrad = Adagrad()
if not tuning:
print model.summary()
model.compile(loss="binary_crossentropy",
optimizer=adagrad,
metrics=["accuracy"])
return model
start = time.time()
if tuning:
model = KerasClassifier(build_fn=create_model,
epochs=epochs,
batch_size=batch_size,
verbose=verbose)
print model.build_fn().summary()
print "tuning with: ", params
if randomtune: # tune the hyperparameters via a randomized search
print "tuning randomly with RandomSearchCV"
grid = RandomizedSearchCV(model,
param_grid,
n_iter=n_iter,
verbose=1)
grid_result = grid.fit(trainData, trainLabels)
else:
grid = GridSearchCV(estimator=model, param_grid=params, n_jobs=1)
grid_result = grid.fit(trainData, trainLabels)
# evaluate the best randomized searched model on the testing data
print("[INFO] randomized search took {:.2f} seconds".format(
time.time() - start))
# summarize results
print("Best: %f using %s" %
(grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
print("%f (%f) with: %r" % (mean, stdev, param))
else:
#train
print "fitting..."
print "with params", params
#model = create_model()
model = None
if params:
try:
model = KerasClassifier(build_fn=create_model, **params)
except ValueError as e:
m = e.message
m = m[m.find("'") + 1:]
m = m[:m.find("'")]
params.pop(m, None)
except Exception as e:
print e
else:
model = KerasClassifier(build_fn=create_model)
model.fit(trainData,
trainLabels,
epochs=epochs,
batch_size=batch_size,
verbose=1,
validation_data=(testData, testLabels))
# testing the model on testData and testLabels is not needed anymore because validation_data was used.
"""# show the accuracy on the testing set
print("[INFO] evaluating on testing set...")
(loss, accuracy) = model.evaluate(testData, testLabels,
batch_size=128, verbose=1)
print("[INFO] loss={:.4f}, accuracy: {:.4f}%".format(loss,
accuracy * 100))
"""
#save model to file
if savefile:
#this will be much more important for the following tests on more input datasets
model.model.save(savefile)
print "time to fit: {:d}min {:.2f}sec".format(
*(lambda t: (int(t / 60), t % 60))(time.time() - start))
if logfile:
#close file
sys.stdout = orig_stdout
f.close()
