def iris_model(x_train, y_train, x_val, y_val, params):
# note how instead of passing the value, we pass a dictionary entry
model = Sequential()
model.add(Dense(params['first_neuron'],
input_dim=x_train.shape[1],
activation='relu'))
# same here, just passing a dictionary entry
model.add(Dropout(params['dropout']))
# with this call we can create any number of hidden layers
hidden_layers(model, params, y_train.shape[1])
# again, instead of the activation name, we have a dictionary entry
model.add(Dense(y_train.shape[1],
activation=params['last_activation']))
# here are using a learning rate boundary
model.compile(optimizer=params['optimizer'](lr=lr_normalizer(params['lr'],
params['optimizer'])),
loss=params['losses'],
metrics=['acc'])
# here we are also using the early_stopper function for a callback
out = model.fit(x_train, y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
verbose=0,
validation_data=[x_val, y_val],
callbacks=early_stopper(params['epochs'], mode=[1,1]))
return out, model
def cervix_model(x_train, y_train, x_val, y_val, params):
model = Sequential()
model.add(Dense(params['first_neuron'],
input_dim=x_train.shape[1],
activation='relu'))
model.add(Dropout(params['dropout']))
hidden_layers(model, params, 1)
model.add(Dense(1, activation=params['last_activation']))
model.compile(optimizer=params['optimizer'](lr=lr_normalizer(params['lr'], params['optimizer'])),
loss=params['loss'],
metrics=['acc',
fmeasure,
recall,
precision,
matthews_correlation])
results = model.fit(x_train, y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
verbose=0,
validation_data=[x_val, y_val],
callbacks=early_stopper(params['epochs'], mode='moderate', monitor='val_fmeasure'))
return results, model
def get_model(m_input_shape, m_params=None):
global OUTPUT_RES
if m_params is None:
m_params = {'input_shape': x[0].shape,
'optimizer': Adam,
'lr': 2.2,
'batch_size': 100,
'second_layer': 0,
'dense_size_1': 3000,
'dense_size_2': 0,
'dropout': 0.005,
'dense_activation': 'relu',
'output_activation': 'linear'}
m_model = Sequential()
m_model.add(Conv2D(8, (3, 3), input_shape=m_input_shape, activation="relu", data_format="channels_first"))
m_model.add(Conv2D(32, (3, 3), activation="relu", dim_ordering="th"))
m_model.add(MaxPooling2D((2, 2)))
m_model.add(Conv2D(32, (3, 3), activation="relu", dim_ordering="th"))
m_model.add(Conv2D(64, (3, 3), activation="relu", dim_ordering="th"))
m_model.add(MaxPooling2D((2, 2)))
m_model.add(Flatten())
m_model.add(Dense(m_params['dense_size_1'], activation=m_params['dense_activation']))
m_model.add(Dropout(m_params['dropout']))
if m_params['second_layer'] == 1:
m_model.add(Dense(m_params['dense_size_2'], activation=m_params['dense_activation']))
m_model.add(Dropout(m_params['dropout']))
m_model.add(Dense(OUTPUT_RES * OUTPUT_RES, activation=m_params['output_activation']))
m_model.compile(m_params['optimizer'](lr=lr_normalizer(m_params['lr'], m_params['optimizer'])),
'mean_squared_error', metrics=['mean_absolute_error'])
return m_model
def cactus_model(x_train, y_train, x_test, y_test, p):
global model
model = resnet_model(p)
model.compile(
loss=p['losses'],
optimizer=p['optimizer'](lr=lr_normalizer(p['lr'], p['optimizer'])),
metrics=['accuracy'])
model.summary()
# LOGS
tb_callback = TensorBoard(log_dir=logs_name(p))
history = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=p['batch_size'],
epochs=p['epochs'],
callbacks=[
tb_callback,
LambdaCallback(on_train_begin=logs_refresh_mlf_run,
on_epoch_end=logs_on_epoch_end)
],
verbose=0)
return history, model
def mlp_main(x, y, x_val, y_val, params):
model_mlp = Sequential()
nSNP = x.shape[1]
try:
out_c = y.shape[1]
except IndexError:
out_c = 1
model_mlp.add(
Dense(params['first_neuron'],
input_dim=nSNP,
activation=params['activation'],
kernel_initializer='normal',
kernel_regularizer=regularizers.l2(params['reg1'])))
model_mlp.add(Dropout(params['dropout_1']))
if (params['hidden_layers'] != 0):
# if we want to also test for number of layers and shapes, that's possible
for _ in range(params['hidden_layers']):
model_mlp.add(
Dense(params['hidden_neurons'],
activation=params['activation'],
kernel_regularizer=regularizers.l2(params['reg1'])))
# hidden_layers(model, params, 1)
model_mlp.add(Dropout(params['dropout_2']))
model_mlp.add(
Dense(out_c,
activation=params['last_activation'],
kernel_regularizer=regularizers.l2(params['reg2'])))
if params['optimizer'] == 'Adam':
params['optimizer'] = Adam
if params['optimizer'] == 'Nadam':
params['optimizer'] = Nadam
if params['optimizer'] == 'sgd':
params['optimizer'] = sgd
model_mlp.compile(loss=mean_squared_error,
optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=[acc_pearson_r])
#es = EarlyStopping(monitor=mean_squared_error, mode='min', verbose=1)
# callbacks=[live()] see the output
# callbacks= es to EarlyStopping
out_mlp = model_mlp.fit(x,
y,
validation_split=0.2,
verbose=0,
batch_size=params['batch_size'],
epochs=params['epochs'])
return out_mlp, model_mlp
def mlp_main_cat(x, y, x_val, y_val, params):
model_mlp = Sequential()
nSNP = x.shape[1]
last_layer = y.shape[1]
model_mlp.add(
Dense(params['first_neuron'],
input_dim=nSNP,
activation=params['activation'],
kernel_initializer='normal',
activity_regularizer=regularizers.l1(params['reg1'])))
model_mlp.add(Dropout(params['dropout_1']))
if (params['hidden_layers'] != 0):
# if we want to also test for number of layers and shapes, that's possible
for _ in range(params['hidden_layers']):
model_mlp.add(
Dense(params['hidden_neurons'],
activation=params['activation'],
activity_regularizer=regularizers.l2(params['reg1'])))
# hidden_layers(model, params, 1)
model_mlp.add(Dropout(params['dropout_2']))
model_mlp.add(Dense(last_layer, activation='softmax'))
if params['optimizer'] == 'Adam':
params['optimizer'] = Adam
if params['optimizer'] == 'Nadam':
params['optimizer'] = Nadam
if params['optimizer'] == 'sgd':
params['optimizer'] = sgd
model_mlp.compile(loss='categorical_crossentropy',
optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=['accuracy'])
#acc or mean_squared_error in metrics
# simple early stopping
# if you monitor is an accuracy parameter (pearson here, you should chose mode="max"), otherwise it would be "min"
#es = EarlyStopping(monitor=mean_squared_error, mode='min', verbose=1)
# callbacks=[live()] see the output
# callbacks= es to EarlyStopping
out_mlp = model_mlp.fit(x,
y,
validation_split=0.2,
verbose=0,
batch_size=params['batch_size'],
epochs=params['epochs'])
return out_mlp, model_mlp
def AmazonModel(x_train_throwaway, y_train_throwaway, x_val_throwaway,
y_val_throwaway, params):
# Pull quantities from params here for convenience
# Create our training data inside the model
batch_size = params['batch_size']
max_length = params['max_length']
vocab_size = params['vocab_size']
loss = params['loss']
num_data_points = params['num_data_points']
num_units = params['num_units']
embedding_size = params['embedding_size']
multiple_LSTM_layers = params['multiple_LSTM_layers']
x_train, y_train, x_valid, y_valid, = train_data[(vocab_size, max_length,
num_data_points)]
earlyStopper = EarlyStopping(patience=3,
verbose=0,
restore_best_weights=True,
monitor="val_acc")
model = Sequential()
model.add(
Embedding(input_dim=vocab_size + 1,
output_dim=embedding_size,
input_length=max_length))
model.add(CuDNNLSTM(num_units, return_sequences=multiple_LSTM_layers))
if multiple_LSTM_layers:
model.add(CuDNNLSTM(num_units))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss=loss,
optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
validation_data=[x_valid, y_valid],
batch_size=batch_size,
epochs=30,
callbacks=[earlyStopper],
verbose=2)
return history, model
def cervical_cancer(x_train, y_train, x_val, y_val, params):
from keras.models import Sequential
from keras.layers import Dropout, Dense
from talos.model import lr_normalizer, early_stopper, hidden_layers
from talos.metrics.keras_metrics import matthews_correlation_acc, precision_acc
from talos.metrics.keras_metrics import recall_acc, fmeasure_acc
model = Sequential()
model.add(
Dense(params['first_neuron'],
input_dim=x_train.shape[1],
activation='relu'))
model.add(Dropout(params['dropout']))
hidden_layers(model, params, 1)
model.add(Dense(1, activation=params['last_activation']))
model.compile(optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
loss=params['losses'],
metrics=[
'acc', fmeasure_acc, recall_acc, precision_acc,
matthews_correlation_acc
])
results = model.fit(x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
verbose=0,
validation_data=[x_val, y_val],
callbacks=[
early_stopper(params['epochs'],
mode='moderate',
monitor='val_fmeasure')
])
return results, model
def cactus_model(x_train, y_train, x_test, y_test, p):
# create and train model
global model
model = Sequential()
model.add(Flatten(input_shape=(32, 32, 3)))
model.add(
Dense(p['first_neuron'],
activation=p['activation'],
kernel_initializer='normal'))
model.add(Dropout(p['dropout']))
hidden_layers(model, p, 1)
model.add(
Dense(NUM_CLASSES,
activation=p['last_activation'],
kernel_initializer='normal'))
model.compile(
loss=p['losses'],
optimizer=p['optimizer'](lr=lr_normalizer(p['lr'], p['optimizer'])),
metrics=['accuracy'])
model.summary()
# LOGS
tb_callback = TensorBoard(log_dir=logs_name(p))
history = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=p['batch_size'],
epochs=p['epochs'],
callbacks=[
tb_callback,
LambdaCallback(on_train_begin=logs_refresh_mlf_run,
on_epoch_end=logs_on_epoch_end)
],
verbose=0)
return history, model
def fp_model(x_train, y_train, x_val, y_val, params):
# To train
model = Sequential()
layers = params['neuron_tuple']
num_h = len(layers)
for i in range(num_h):
num_neurons = layers[i]
model.add(Dense(num_neurons, activation=params['activation']))
model.add(Dropout(params['dropout']))
model.add(Dense(1, activation=params['last_activation']))
model.compile(optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
loss=params['losses'],
metrics=['accuracy'])
#Train the model, iterating on the data in batches of 32 samples
history = model.fit(x_train,
y_train,
epochs=params['epochs'],
batch_size=params['batch_size'],
verbose=1,
validation_data=[x_val, y_val])
return history, model
def fake_news_model(self, x_train, y_train, x_val, y_val, params):
model = Sequential()
model.add(Dense(10, input_dim=(len(self.HEADERS) - 1),
activation=params['activation'],
kernel_initializer='normal'))
model.add(Dropout(params['dropout']))
hidden_layers(model, params, 1)
model.add(Dense(1, activation=params['last_activation'],
kernel_initializer='normal'))
model.compile(loss=params['losses'],
optimizer=params['optimizer'](lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=['acc'])
history = model.fit(x_train, y_train,
validation_data=[x_val, y_val],
batch_size=params['batch_size'],
epochs=params['epochs'],
verbose=0)
return history, model
model_json = json_file.read()
json_file.close()
# load weights
new_model = model_from_json(model_json)
new_model.load_weights(BACKUP_PATH + "/" + filename + ".h5")
return new_model
dataset, filenames = imagesToDataset(PROJECT_PATH + '/data/test/')
model = build_model()
model.summary()
model.compile(loss=params['losses'],
optimizer=params['optimizer'](lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=['accuracy'])
results = model.predict(x=dataset)
# clean predict
hascactus_column_results = np.rint(results[:, [1]]).astype(int)
clean_results = np.column_stack([filenames, hascactus_column_results])
# export
np.savetxt(
PREDICTIONS_PATH + "/" + filename + ".csv", clean_results,
header="id,has_cactus",
delimiter=",", fmt="%s", comments='')
def cnn_main(x, y, x_val, y_val, params):
# next we can build the model exactly like we would normally do it
# Instantiate
model_cnn = Sequential()
nSNP = x.shape[1]
try:
out_c = y.shape[1]
except IndexError:
out_c = 1
x = np.expand_dims(x, axis=2)
x_val = np.expand_dims(x_val, axis=2)
# add convolutional layer
if (params['nconv'] == 1):
model_cnn.add(
Conv1D(params['nFilter'],
kernel_size=params['kernel_size'],
strides=params['nStride'],
input_shape=(nSNP, 1),
kernel_regularizer=regularizers.l2(params['reg2']),
kernel_initializer='normal',
activity_regularizer=regularizers.l1(params['reg1']),
activation=params['activation_1']))
model_cnn.add(MaxPooling1D(pool_size=params['pool']))
# Solutions above are linearized to accommodate a standard layer
else:
for _ in range(params['nconv']):
if (_ == 0):
model_cnn.add(
Conv1D(params['nFilter'],
kernel_size=params['kernel_size'],
strides=params['nStride'],
input_shape=(nSNP, 1),
kernel_regularizer=regularizers.l2(params['reg2']),
kernel_initializer='normal',
activity_regularizer=regularizers.l1(
params['reg1']),
activation=params['activation_1']))
model_cnn.add(MaxPooling1D(pool_size=params['pool']))
# Solutions above are linearized to accommodate a standard layer
else:
model_cnn.add(
Conv1D(params['nFilter'],
kernel_size=params['kernel_size'],
strides=params['nStride'],
kernel_regularizer=regularizers.l2(params['reg2']),
kernel_initializer='normal',
activity_regularizer=regularizers.l1(
params['reg1']),
activation=params['activation_1']))
model_cnn.add(MaxPooling1D(pool_size=params['pool']))
model_cnn.add(Flatten())
if (params['hidden_layers'] != 0):
# if we want to also test for number of layers and shapes, that's possible
for _ in range(params['hidden_layers']):
model_cnn.add(
Dense(params['hidden_neurons'],
activation=params['activation_2'],
kernel_regularizer=regularizers.l2(params['reg2'])))
model_cnn.add(Dropout(params['dropout_2']))
model_cnn.add(
Dense(out_c,
activation=params['last_activation'],
kernel_regularizer=regularizers.l2(params['reg3'])))
if params['optimizer'] == 'Adam':
params['optimizer'] = Adam
if params['optimizer'] == 'Nadam':
params['optimizer'] = Nadam
if params['optimizer'] == 'sgd':
params['optimizer'] = sgd
model_cnn.compile(loss=mean_squared_error,
optimizer=params['optimizer'](
lr=lr_normalizer(params['lr'], params['optimizer'])),
metrics=[acc_pearson_r])
# simple early stopping
# if you monitor is an accuracy parameter (pearson here, you should chose mode="max"), otherwise it would be "min"
# 7/08/2019 change mean_squared_error here by acc_pearson_r and mode='min' by mode='max'
#es = EarlyStopping(monitor=acc_pearson_r, mode='max', verbose=1)
# callbacks=[live()] see the output
# callbacks= es to EarlyStopping
out_cnn = model_cnn.fit(x,
y,
validation_split=0.2,
verbose=0,
batch_size=params['batch_size'],
epochs=params['epochs'],
callbacks=[live()])
return out_cnn, model_cnn
