def run(data, base_logdir, session_id, hparams):
"""Run a training/validation session.
Flags must have been parsed for this function to behave.
Args:
data: The data as loaded by `prepare_data()`.
base_logdir: The top-level logdir to which to write summary data.
session_id: A unique string ID for this session.
hparams: A dict mapping hyperparameters in `HPARAMS` to values.
"""
model = model_fn(hparams=hparams, seed=session_id)
logdir = os.path.join(base_logdir, session_id)
callback = tf.keras.callbacks.TensorBoard(
logdir,
update_freq=flags.FLAGS.summary_freq,
profile_batch=0, # workaround for issue #2084
)
hparams_callback = hp.KerasCallback(logdir, hparams)
((x_train, y_train), (x_test, y_test)) = data
result = model.fit(
x=x_train,
y=y_train,
epochs=flags.FLAGS.num_epochs,
shuffle=False,
validation_data=(x_test, y_test),
callbacks=[callback, hparams_callback],
)
def train_model(r_name, hparams, model):
"""Train the model by feeding it data."""
hp_log_dir = log_dir + session_name + "/" + r_name
history = model.fit(
generate_arrays_from_file(tens_path + training_file,
hparams[HP_BATCH_SIZE]),
steps_per_epoch=train_rows // hparams[HP_BATCH_SIZE],
epochs=n_epochs,
validation_data=generate_arrays_from_file(tens_path + validation_file,
hparams[HP_BATCH_SIZE]),
validation_steps=valid_rows // hparams[HP_BATCH_SIZE],
callbacks=[
tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=1),
tf.keras.callbacks.TensorBoard(log_dir=hp_log_dir,
histogram_freq=1), # log_dir
hp.KerasCallback(hp_log_dir + "/validation",
hparams) # log hparams
])
# To track the progression of training, gather a snapshot
# of the model's metrics at each epoch.
epochs = history.epoch
hist = pd.DataFrame(history.history)
# save model
model.save(save_dir + session_name + "/" + r_name)
test_results = model.evaluate(generate_arrays_from_file(
tens_path + test_file, hparams[HP_BATCH_SIZE]),
steps=test_rows // hparams[HP_BATCH_SIZE])
return epochs, hist, test_results
def train_test_model(hparams):
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(hparams[HP_NUM_UNITS], activation=tf.nn.relu),
tf.keras.layers.Dropout(hparams[HP_DROPOUT]),
tf.keras.layers.Dense(10, activation=tf.nn.softmax),
])
model.compile(
optimizer=hparams[HP_OPTIMIZER],
loss='sparse_categorical_crossentropy',
metrics=['accuracy'],
)
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
model.fit(
x_train,
y_train,
epochs=15,
callbacks=[
tf.keras.callbacks.TensorBoard(log_dir), # log metrics
hp.KerasCallback(log_dir, hparams), # log hparams
]) # Run with 1 epoch to speed things up for demo purposes
_, accuracy = model.evaluate(x_test, y_test)
return accuracy
def train_test_model(logdir, hparams):
start = timer()
classifier = tf.keras.Sequential()
classifier.add(tf.keras.layers.Conv2D(filters=int(hparams[HP_CNN_FILTER_1]), kernel_size=int(hparams[HP_CNN_KERNEL_1]), activation='relu', input_shape=(x_train[0].shape[0], x_train[0].shape[1], 1)))
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(0.4))
classifier.add(tf.keras.layers.Conv2D(filters=int(hparams[HP_CNN_FILTER_2]), kernel_size=int(hparams[HP_CNN_KERNEL_2]), activation='relu'))
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(0.4))
classifier.add(tf.keras.layers.Conv2D(filters=int(hparams[HP_CNN_FILTER_3]), kernel_size=int(hparams[HP_CNN_KERNEL_3]), activation='relu'))
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.GlobalAvgPool2D())
classifier.add(tf.keras.layers.Dense(hparams[HP_NUM_UNITS], activation='relu'))
classifier.add(tf.keras.layers.Dense(1, activation='sigmoid'))
classifier.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=hparams[HP_LEARNING_RATE], decay=0.001), loss='binary_crossentropy', metrics=['accuracy'])
cb = [
tf.keras.callbacks.TensorBoard(log_dir=logdir),
hp.KerasCallback(logdir, hparams)
]
classifier.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=64, epochs=100, callbacks=cb, verbose=0)
_, accuracy = classifier.evaluate(x_test, y_test)
end = timer()
print(timedelta(seconds=end-start))
return accuracy
def train_test_model(hparams, training_generator, test_generator,
val_generator, model):
clip_size = hparams[HP_clip_size]
# steps = int((train_images.shape[1]/clip_size))$
steps = int((train_images_horiz.shape[1] / clip_size))
# steps = 5
callbacks = [
tf.keras.callbacks.TensorBoard(logdir), # log metrics
hp.KerasCallback(logdir, hparams), # log hparams
tf.keras.callbacks.EarlyStopping(monitor='loss', patience=17),
# tf.keras.callbacks.LearningRateScheduler(scheduler)
ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=4)
]
val_steps = int((val_images_horiz.shape[1] / clip_size))
history = model.fit(training_generator,
verbose=2,
epochs=200,
callbacks=callbacks,
steps_per_epoch=steps,
validation_data=val_generator,
validation_steps=val_steps)
test_steps = int((test_images_horiz.shape[1] / clip_size))
_, accuracy = model.evaluate(test_generator, steps=test_steps)
return accuracy, history
def train_test_model(hparams, logdir):
model = Sequential(
[Dense(units=hparams[HP_HIDDEN], activation='relu'),
Dense(units=1)])
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(
hparams[HP_LEARNING_RATE]),
metrics=['mean_squared_error'])
model.fit(
X_scaled_train,
y_train,
validation_data=(X_scaled_test, y_test),
epochs=hparams[HP_EPOCHS],
verbose=False,
callbacks=[
tf.keras.callbacks.TensorBoard(logdir), # log metrics
hp.KerasCallback(logdir, hparams), # log hparams
tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0,
patience=200,
verbose=0,
mode='auto',
)
],
)
_, mse = model.evaluate(X_scaled_test, y_test)
pred = model.predict(X_scaled_test)
r2 = r2_score(y_test, pred)
return mse, r2
def run(train_dataset, val_dataset, base_logdir, session_id, hparams):
"""Run a training/validation session.
Flags must have been parsed for this function to behave.
Args:
data: The data as loaded by `prepare_data()`.
base_logdir: The top-level logdir to which to write summary data.
session_id: A unique string ID for this session.
hparams: A dict mapping hyperparameters in `HPARAMS` to values.
"""
model = model_fn(hparams=hparams, seed=session_id)
logdir = os.path.join(base_logdir, session_id)
EPOCHS = 600
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir,
profile_batch=0)
callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss',
patience=40,
restore_best_weights=True)
hparams_callback = hp.KerasCallback(logdir, hparams)
model.fit(train_dataset,
epochs=EPOCHS,
callbacks=[tensorboard_callback, callback, hparams_callback],
validation_data=val_dataset)
def run(data, base_path, session_id, hparams):
""" Run a training/validation session
Args:
data: the train and validation data
base_path: The top-level logdir to which to write summary data.
session_id: A unique string ID for this session.
hparams: A dict mapping hyperparameters in `HPARAMS` to values.
"""
logdir = os.path.join(base_path, session_id)
((x_train, y_train), (x_val, y_val)) = data
model = build_multilayer_lstm_hp(input_dim=x_train.shape[1:],
hparams=hparams,
seed=session_id,
num_classes=flags.FLAGS.num_classes)
tensorboard_callback = tf.keras.callbacks.TensorBoard(
log_dir=logdir,
histogram_freq=2,
update_freq=flags.FLAGS.summary_freq,
profile_batch=0)
hparams_callback = hp.KerasCallback(logdir, hparams)
model.fit(
x=x_train,
epochs=flags.FLAGS.epochs,
y=y_train,
batch_size=flags.FLAGS.batch_size,
shuffle=False,
validation_data=(x_val, y_val),
callbacks=[tensorboard_callback, hparams_callback],
)
model_file = "model_%d_stages_%ds_%s_%d_seq_%s_%s.h5" % (
flags.FLAGS.num_classes, flags.FLAGS.hrv_win_len,
flags.FLAGS.nn_type, flags.FLAGS.seq_len, flags.FLAGS.modality,
convert_args_to_str(hparams))
model_save_path = os.path.join(logdir, model_file)
model.save(model_save_path, save_format='h5')
def train_test_model(logdir, hparams):
classifier = tf.keras.Sequential()
classifier.add(tf.keras.layers.Conv2D(filters=hparams['filter_1'], kernel_size=hparams['kernel_1'], activation='relu', input_shape=(x_train[0].shape[0], x_train[0].shape[1], 1)))
if hparams['batch_norm']:
classifier.add(tf.keras.layers.BatchNormalization())
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(hparams['dropout']))
classifier.add(tf.keras.layers.Conv2D(filters=hparams['filter_2'], kernel_size=hparams['kernel_2'], activation='relu'))
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(hparams['dropout']))
classifier.add(tf.keras.layers.Flatten())
classifier.add(tf.keras.layers.Dense(hparams['units'], activation='relu'))
classifier.add(tf.keras.layers.Dense(1, activation='sigmoid'))
if not os.path.exists(logdir):
os.makedirs(logdir)
plot_model(classifier, logdir + '/model.png', show_shapes=True, show_layer_names=False)
classifier.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=hparams['lr']), loss='binary_crossentropy', metrics=['accuracy'])
cb = [
tf.keras.callbacks.TensorBoard(log_dir=logdir),
hp.KerasCallback(logdir, hparams)
]
classifier.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=16, epochs=250, callbacks=cb, verbose=0)
_, accuracy = classifier.evaluate(x_test, y_test)
end = timer()
return accuracy
def train_model(run_dir,hparams):
hp.hparams(hparams)
[X_train, y_train] = create_data(data_unscaled=data, start_train=start_train, end_train=end_train, n_windows=hparams[HP_WINDOW], n_outputs=hparams[HP_OUTPUT])
[X_test, y_test] = create_data(data_unscaled=data, start_train=end_train, end_train=end_test, n_windows=hparams[HP_WINDOW], n_outputs=hparams[HP_OUTPUT])
tf.compat.v1.keras.backend.clear_session()
model = Sequential()
model.add(TimeDistributed(Masking(mask_value=0., input_shape=(hparams[HP_WINDOW], n_inputs+1)), input_shape=(n_company, hparams[HP_WINDOW], n_inputs+1)))
model.add(TimeDistributed(LSTM(hparams[HP_NUM_UNITS], stateful=False, activation='tanh', return_sequences=True, input_shape=(hparams[HP_WINDOW], n_inputs+1), kernel_initializer='TruncatedNormal' ,bias_initializer=initializers.Constant(value=0.1), dropout=hparams[HP_DROPOUT] ,recurrent_dropout=hparams[HP_DROPOUT])))
model.add(TimeDistributed(LSTM(hparams[HP_NUM_UNITS], stateful=False, activation='tanh' ,return_sequences=False ,kernel_initializer='TruncatedNormal' ,bias_initializer=initializers.Constant(value=0.1) ,dropout=hparams[HP_DROPOUT], recurrent_dropout=hparams[HP_DROPOUT])))
#model.add(TimeDistributed(LSTM(hparams[HP_NUM_UNITS], stateful=False, activation='tanh' ,return_sequences=True ,kernel_initializer='TruncatedNormal' ,bias_initializer=initializers.Constant(value=0.1) ,dropout=hparams[HP_DROPOUT], recurrent_dropout=hparams[HP_DROPOUT])))
#model.add(TimeDistributed(LSTM(hparams[HP_NUM_UNITS], stateful=False, activation='tanh' ,return_sequences=False ,kernel_initializer='TruncatedNormal' ,bias_initializer=initializers.Constant(value=0.1) ,dropout=hparams[HP_DROPOUT], recurrent_dropout=hparams[HP_DROPOUT])))
model.add(Dense(units=20, activation='softmax'))
model.compile(optimizer=hparams[HP_OPTIMIZER], loss='categorical_crossentropy', metrics=['accuracy']) #get_weighted_loss(weights=weights)) # metrics=['mae'])
model.build(input_shape=(None, n_company, hparams[HP_WINDOW], n_inputs+1))
model.summary()
#model.fit(X_train, to_categorical(y_train[:, :, hparams[HP_WINDOW]-1:hparams[HP_WINDOW], 0],20), epochs=100, batch_size=batch_size, validation_data=(X_test, to_categorical(y_test[:, :, hparams[HP_WINDOW]-1:hparams[HP_WINDOW], 0],20)))
model.fit(X_train, to_categorical(y_train[:, :, hparams[HP_WINDOW]-1:hparams[HP_WINDOW],0],20), epochs=1000, batch_size=batch_size, validation_data=(X_test, to_categorical(y_test[:, :, hparams[HP_WINDOW]-1:hparams[HP_WINDOW],0],20)), callbacks=[
TensorBoard(log_dir=run_dir, histogram_freq=50, write_graph=True, write_grads=True, update_freq='epoch'),
hp.KerasCallback(writer=run_dir, hparams=hparams)])
model.save('model_' + str(hparams[HP_NUM_UNITS]) + '_' + str(hparams[HP_DROPOUT]) + '_' + str(hparams[HP_OPTIMIZER]) + '_' + str(hparams[HP_WINDOW]) + '_' + str(hparams[HP_OUTPUT]) + '.h5')
pd.DataFrame(np.argmax(model.predict(X_test),axis=2)).to_csv('pred.csv')
pd.DataFrame(np.reshape(np.transpose(model.predict(X_test),axes=(1,0,2)), (X_test.shape[0]*X_test.shape[1],20))).to_csv('pred_weights.csv')
return 0
def train_test_model(log_dir, hparams: dict):
dataset = DataSet(fraction=1.0)
optimiser = getattr(tf.keras.optimizers, hparams['optimizer'])
schedule = scheduler(hparams, dataset)
model = SequentialCNN(input_shape=dataset.input_shape(),
output_shape=dataset.output_shape())
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=optimiser(learning_rate=hparams['learning_rate']),
metrics=['accuracy'])
history = model.fit(
dataset.data['train_X'],
dataset.data['train_Y'],
batch_size=hparams["batch_size"],
epochs=250,
verbose=False,
validation_data=(dataset.data["valid_X"], dataset.data["valid_Y"]),
callbacks=[
EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=hparams['patience']),
schedule,
tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=1), # log metrics
hp.KerasCallback(log_dir, hparams) # log hparams
])
print({key: value[-1] for key, value in history.history.items()})
def train_and_evaluate(model, hparams):
tensorboard = TensorBoard(log_dir = log_dir, histogram_freq=10, write_graph=True, write_images=False)
hp_tuning = hp.KerasCallback(log_dir,hparams)
cbs = [tensorboard,hp_tuning]
history = model.fit(gen, validation_split=0.15, epochs=p.epochs, batch_size=p.batch_size, callbacks=cbs, verbose=1, shuffle = True)
mse, rmse = model.evaluate(test_gen)
return rmse, history
def test_duplicate_hparam_names_from_two_objects(self):
hparams = {
hp.HParam("foo"): 1,
hp.HParam("foo"): 1,
}
with six.assertRaisesRegex(
self, ValueError, "multiple values specified for hparam 'foo'"):
hp.KerasCallback(self.get_temp_dir(), hparams)
def get_callbacks(name, hparams, log_path):
return [
EarlyStopping(monitor="val_loss",
patience=_patience,
restore_best_weights=True),
TensorBoard(log_dir=log_path, profile_batch=2, histogram_freq=1),
hp.KerasCallback(log_path, hparams, name)
]
def configure_callbacks(hparams,
log_dir,
weight_dir,
no_early_stopping=False,
lr_reducer=True,
histogram_freq=1,
early_stopping_patience=25):
callbacks = []
# Initialize model checkpoint
model_checkpoint = tf.keras.callbacks.ModelCheckpoint(
weight_dir +
"/weights.{epoch:02d}-{val_loss:.2f}-{val_precision:.2f}-{val_recall:.2f}.hdf5",
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto')
tensorboard_callback = tf.keras.callbacks.TensorBoard(
log_dir=log_dir,
histogram_freq=histogram_freq,
write_grads=True,
write_images=True)
# Learning rate scheduler
#def scheduler(epoch, lr):
# if epoch < 10:
# return lr
# else:
# return lr * tf.math.exp(-0.1)
#
# learning_rate_scheduler_callback = tf.keras.callbacks.LearningRateScheduler(scheduler)
# Hyperparameter search callback
hparams_callback = hp.KerasCallback(log_dir, hparams)
callbacks = [model_checkpoint, tensorboard_callback, hparams_callback]
if not no_early_stopping:
print('early stopping')
early_stopping_callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0,
patience=early_stopping_patience,
verbose=0,
mode='auto',
baseline=None,
restore_best_weights=True)
callbacks.append(early_stopping_callback)
if lr_reducer:
print('Using lr reducer')
# Control the learning rate on plateau
reduce_lr_callback = tf.keras.callbacks.ReduceLROnPlateau(
monitor='val_loss', factor=0.1, patience=5, min_lr=0.001)
callbacks.append(reduce_lr_callback)
return callbacks
def train_test_model(hparams, data_dir, log_dir, run_name, epochs):
print("train_test_model started")
config = SunRGBDConfig()
dataset_train = SunRGBDDataset()
dataset_train.load_sun_rgbd(data_dir, "train13")
dataset_train.prepare()
dataset_val = SunRGBDDataset()
dataset_val.load_sun_rgbd(data_dir, "split/val13")
dataset_val.prepare()
# Create model in training mode
if hparams['HP_BACKBONE'] == "resnet50_batch_size1":
backbone = "resnet50"
batch_size = 1
elif hparams['HP_BACKBONE'] == "resnet50_batch_size2":
backbone = "resnet50"
batch_size = 2
else:
backbone = "resnet101"
batch_size = 1
config.BACKBONE = backbone
config.BATCH_SIZE = batch_size
config.IMAGES_PER_GPU = batch_size
config.OPTIMIZER = hparams['HP_OPTIMIZER']
if config.OPTIMIZER == "ADAM":
config.LEARNING_RATE = config.LEARNING_RATE / 10
# config.VALIDATION_STEPS = 1000 # bigger val steps
# config.STEPS_PER_EPOCH = 10
model = modellib.MaskRCNN(mode="training", config=config,
model_dir=log_dir, unique_log_name=False)
augmentation = iaa.Sequential([
iaa.Fliplr(0.5)
])
custom_callbacks = [tbhp.KerasCallback(log_dir, hparams)]
print("start training")
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=epochs,
layers='all',
augmentation=augmentation,
custom_callbacks=custom_callbacks)
print("save model")
model_path = log_dir + run_name + ".h5"
model.keras_model.save_weights(model_path)
# inference calculation
print("calculate inference")
config.BATCH_SIZE = 1
config.IMAGES_PER_GPU = 1
m_ap, f1s = inference_calculation(config=config, model_path=model_path, model_dir=log_dir, dataset_val=dataset_val)
print("train_test_model finished")
return m_ap, f1s
def train(model: tf.keras.Model, data_csv: str, data_root: str, hparams: dict,
hp_space: dict, run_name: str):
train_split = hparams[hp_space['train_split']]
num_imgs = hparams[hp_space['num_imgs']]
num_epochs = hparams[hp_space['num_epochs']]
batch_size = hparams[hp_space['batch_size']]
# Load csv data
examples_df = pd.read_csv(data_csv, header=0, skipinitialspace=True)
label_dict = {'Fish': 0, 'Flower': 1, 'Gravel': 2, 'Sugar': 3}
filenames = np.array(
[data_root + fname for fname in examples_df['Image'].tolist()],
dtype=object)
labels = np.array(
[label_dict[fname] for fname in examples_df['Label'].tolist()],
dtype=int)
if num_imgs == -1: num_imgs = len(filenames)
train_idxs, val_idxs = split_train_val(examples_df, train_split, num_imgs)
train_filenames = filenames[train_idxs]
train_labels = labels[train_idxs]
val_filenames = filenames[val_idxs]
val_labels = labels[val_idxs]
train_dataset, num_train = create_dataset(files=train_filenames,
labels=train_labels,
batch_size=batch_size,
training=True)
val_dataset, num_val = create_dataset(files=val_filenames,
labels=val_labels,
batch_size=batch_size,
training=False)
print("Num train: {}, num val: {}".format(num_train, num_val))
log_dir = './logs/{}'.format(run_name)
train_history = model.fit(
train_dataset,
epochs=num_epochs,
steps_per_epoch=num_train // batch_size,
validation_steps=num_val // batch_size,
validation_data=val_dataset,
callbacks=[
tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=5),
tf.keras.callbacks.TensorBoard(log_dir=log_dir),
tf.keras.callbacks.ModelCheckpoint(
filepath="experiments/{}/".format(run_name) +
"best_model.hdf5",
save_best_only=True,
save_weights_only=False),
hp.KerasCallback(log_dir, hparams)
])
def train_test_model(hparams, data_dir, log_dir, run_name, epochs):
print("train_test_model started")
config = SunRGBDFusenetConfig()
dataset_train = SunRGBDFusenetDataset()
dataset_train.load_sun_rgbd_fusenet(data_dir, "train13")
dataset_train.prepare()
dataset_val = SunRGBDFusenetDataset()
dataset_val.load_sun_rgbd_fusenet(data_dir, "split/val13")
dataset_val.prepare()
# Create model in training mode
if hparams['HP_NUM_FILTERS'] == NUM_FILTERS_L:
config.NUM_FILTERS = [128, 128, 256, 512, 1024]
elif hparams['HP_NUM_FILTERS'] == NUM_FILTERS_M:
config.NUM_FILTERS = [64, 64, 128, 256, 512]
else:
config.NUM_FILTERS = [32, 32, 64, 128, 256]
config.BATCH_SIZE = 1
config.IMAGES_PER_GPU = 1
config.OPTIMIZER = hparams['HP_OPTIMIZER']
if config.OPTIMIZER == "ADAM":
config.LEARNING_RATE = config.LEARNING_RATE / 10
model = modellib.MaskRCNN(mode="training",
config=config,
model_dir=log_dir,
unique_log_name=False)
augmentation = iaa.Sequential([iaa.Fliplr(0.5)])
custom_callbacks = [tbhp.KerasCallback(log_dir, hparams)]
print("start training")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=epochs,
layers='all',
augmentation=augmentation,
custom_callbacks=custom_callbacks)
print("save model")
model_path = log_dir + run_name + ".h5"
model.keras_model.save_weights(model_path)
# inference calculation
print("calculate inference")
config.BATCH_SIZE = 1
config.IMAGES_PER_GPU = 1
m_ap, f1s = inference_calculation(config=config,
model_path=model_path,
model_dir=log_dir,
dataset_val=dataset_val)
print("train_test_model finished")
return m_ap, f1s
def train_model(model, train, validate, initial_epoch):
# Metrics / loss / optimizer
if FLAGS.mode == 'regression':
metrics = ['mean_absolute_error', 'mean_squared_error']
loss = 'mean_squared_error'
else:
metrics = [
tf.keras.metrics.SparseCategoricalAccuracy(),
tf.keras.metrics.SparseTopKCategoricalAccuracy(k=2),
]
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam(
learning_rate=hparams[HP_LR],
epsilon=0.1
)
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
if FLAGS.speedrun:
steps_per_epoch = 110
validation_steps = 15
# Disabled output printing, slows things down
model_callbacks = []
# model_callbacks = [ tf.keras.callbacks.LambdaCallback(
# on_epoch_end=lambda x, y: quick_eval(model, train, FLAGS.mode)
# )]
else:
validation_steps=FLAGS.validation_size // hparams[HP_BATCH_SIZE]
model_callbacks = callbacks + [hp.KerasCallback(hparam_dir, hparams)]
steps_per_epoch=FLAGS.steps_per_epoch
if FLAGS.weighted:
weights = {i: float(x) for i, x in enumerate(FLAGS.weighted)}
logging.debug("Using class weights", weights)
else:
weights = None
fit_args = {
'x': train,
'epochs': FLAGS.epochs,
'steps_per_epoch': steps_per_epoch,
'validation_data': validate,
'validation_steps': validation_steps,
'class_weight': weights,
'callbacks': model_callbacks,
'initial_epoch': initial_epoch
}
pretty_args = json.dumps({k: str(v) for k, v in fit_args.items()}, indent=2)
logging.info("Fitting model with args: \n%s", pretty_args)
history = model.fit(**fit_args)
def train_test_model(model_name,
hparams,
logdir,
X_train=X_train,
y_train=y_train,
with_weigths=True):
model = Sequential()
model.add(Dense(hparams[HP_NUM_UNITS_L1], activation='relu'))
model.add(Dropout(hparams[HP_DROPOUT]))
model.add(Dense(hparams[HP_NUM_UNITS_L2], activation='relu'))
model.add(Dropout(hparams[HP_DROPOUT]))
model.add(Dense(hparams[HP_NUM_UNITS_L3], activation='relu'))
model.add(Dropout(hparams[HP_DROPOUT]))
model.add(Dense(units=1, activation='sigmoid'))
model.compile(loss=hparams[HP_LOSS],
optimizer=hparams[HP_OPTIMIZER],
metrics=METRICS)
class_weight = {0: 1, 1: 1}
if with_weigths:
neg, pos = np.bincount(y_train)
total = neg + pos
print('Examples: Total: {} Positive: {} ({:.2f}% of total)'.format(
total, pos, 100 * pos / total))
weight_for_0 = (1 / neg) * (total) / 2.0
weight_for_1 = (1 / pos) * (total) / 2.0
class_weight = {0: weight_for_0, 1: weight_for_1}
print('Weight for class 0: {:.2f}'.format(weight_for_0))
print('Weight for class 1: {:.2f}'.format(weight_for_1))
model.fit(
x=X_train,
y=y_train,
epochs=500,
class_weight=class_weight,
batch_size=hparams[HP_BATCH_SIZE],
validation_data=(X_test, y_test),
verbose=0,
callbacks=[
EarlyStopping(monitor='loss', mode='min', verbose=1, patience=10),
tf.keras.callbacks.TensorBoard(
log_dir=logdir,
histogram_freq=1,
write_graph=False,
write_images=False,
update_freq='epoch',
profile_batch=100000000), # log metrics
hp.KerasCallback(logdir, hparams)
])
results = model.evaluate(X_test, y_test)
print(results)
return results
def train_test_model(logdir, hparams):
filter_kernel_2 = json.loads(hparams['filter_kernel_2'])
units = json.loads(hparams['units'])
kernel_1 = json.loads(hparams['kernel_1'])
# C3 Convolution.
fft_input = keras.Input(shape=(x_train[0].shape[0], x_train[0].shape[1],
1))
model = layers.Conv2D(filters=int(hparams['filter_1']),
kernel_size=(int(kernel_1[0]), int(kernel_1[1])),
activation='relu')(fft_input)
model = layers.MaxPooling2D(pool_size=2)(model)
model = layers.Dropout(hparams['dropout'])(model)
if int(filter_kernel_2[0]) > 0:
model = layers.Conv2D(filters=int(filter_kernel_2[0]),
kernel_size=(1, int(filter_kernel_2[1])),
activation='relu')(model)
model = layers.MaxPooling2D(pool_size=2)(model)
model = layers.Dropout(hparams['dropout'])(model)
model = layers.Flatten()(model)
# Dense concatenation.
for unit in units:
model = layers.Dense(unit, activation='relu')(model)
model = layers.Dropout(hparams['dropout'])(model)
model = layers.Dense(1, activation='sigmoid')(model)
model = tf.keras.models.Model(inputs=fft_input, outputs=model)
model.summary()
if not os.path.exists(logdir):
os.makedirs(logdir)
plot_model(model,
logdir + '/model.png',
show_shapes=True,
show_layer_names=False)
model.compile(optimizer=optimizers.Adam(learning_rate=hparams['lr'],
decay=0.001),
loss='binary_crossentropy',
metrics=['accuracy'])
cb = [
callbacks.TensorBoard(log_dir=logdir),
hp.KerasCallback(logdir, hparams)
]
history = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=16,
epochs=2000,
callbacks=cb,
verbose=0)
return model, history
def hparamCallback(self):
hparams = {
'learningRate': self.config.learningRate,
'hiddenSize': self.config.hiddenSize,
'numberOfLayers': self.config.numLayers,
'batchSize': self.config.batchSize,
'numberParams': self.model.count_params()
}
boardPath = os.path.join(os.path.join(self.config.saveDir, 'logs'),
self.config.name)
return hp.KerasCallback(boardPath, hparams)
def _initialize_model(self, writer):
HP_DENSE_NEURONS = hp.HParam("dense_neurons", hp.IntInterval(4, 16))
self.hparams = {
"optimizer": "adam",
HP_DENSE_NEURONS: 8,
}
self.model = tf.keras.models.Sequential([
tf.keras.layers.Dense(self.hparams[HP_DENSE_NEURONS], input_shape=(1,)),
tf.keras.layers.Dense(1, activation="sigmoid"),
])
self.model.compile(loss="mse", optimizer=self.hparams["optimizer"])
self.callback = hp.KerasCallback(writer, self.hparams, group_name="psl27")
def _configure_tensorboard_dir(self, callbacks, trial):
for callback in callbacks:
if callback.__class__.__name__ == 'TensorBoard':
# Patch TensorBoard log_dir and add HParams KerasCallback
logdir = _get_tensorboard_dir(callback.log_dir, trial.trial_id)
callback.log_dir = logdir
hparams = tuner_utils.convert_hyperparams_to_hparams(
trial.hyperparameters)
callbacks.append(
hparams_api.KerasCallback(
writer=logdir,
hparams=hparams,
trial_id=trial.trial_id))
def create_hparams_callback(log_dir, opt_metric, hparams, args):
"""
Set up Hprams plugin config and callback for Tensorboard
"""
hparams_dir = os.path.join(log_dir, 'validation')
opt_metric = 'epoch_' + opt_metric
# Hparams callback to log the hyperparameter values
with tf.summary.create_file_writer(hparams_dir).as_default():
hp.hparams_config(hparams=[hp.HParam(hparam) for hparam in hparams],
metrics=[hp.Metric(opt_metric)])
hparams_cb = hp.KerasCallback(
writer=hparams_dir,
hparams={hparam: args[hparam]
for hparam in hparams})
return hparams_cb
def train(self, logdir, hparams):
self._model = self.get_model(hparams)
print(self._model.summary())
self._model.fit(
x=self._datasource.train.x,
y=self._datasource.train.y,
batch_size=self._options['batch'],
epochs=self._options['epoch'],
validation_data=(self._datasource.validation.x, self._datasource.validation.y),
shuffle=True,
callbacks=[
ModelCheckpoint('{}/model_weights.h5'.format(self.folder), save_weights_only=True),
YOLOMetrics.HistoryCheckpointCallback(folder=self.folder),
YOLOMetrics.TensorboardCallback(logdir),
hp.KerasCallback(logdir, hparams)])
def model_run(hparams, log_seq):
logdir= r'logs\t_{}'.format(log_seq)
model = Sequential([Input((4,)),
Dense(hparams['num_units'], name='layer1_dense1'),
BatchNormalization(name='layer2_batch1'),
Dropout(hparams['dropout'], name='layer3_drop1'),
Dense(5, name='layer4_dense2'),
Dense(3, activation='softmax', name='layer5_sof1')])
model.compile(hparams['optimizer'], loss='sparse_categorical_crossentropy', metrics=['acc'])
model.fit(x, y, epochs=500, validation_split=0.2, shuffle=False,
callbacks=[tf.keras.callbacks.TensorBoard(logdir),
hp.KerasCallback(logdir, hparams, trial_id=str(log_seq)),
lrs])
def model_fit(
model: EmbeddingModel,
training_set: tf.data.Dataset,
validation_set: tf.data.Dataset,
export_path: str,
log_dir: str,
hparams: Dict[hp.HParam, Any],
epochs: int = 20,
verbose: int = 1,
worker: int = 4,
) -> None:
# tensorboard logging for standard metrics
tensorboard_callback = tf.keras.callbacks.TensorBoard(
log_dir=log_dir,
profile_batch=(300, 320)
)
# tensorboard logging for hyperparameters
keras_callback = hp.KerasCallback(
writer=log_dir,
hparams=hparams,
trial_id=log_dir
)
metrics = [
tf.keras.metrics.AUC(name='auc'),
]
model.compile(
loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer='adam',
metrics=metrics)
_ = model.fit(
training_set,
validation_data=validation_set,
epochs=epochs,
verbose=verbose,
callbacks=[tensorboard_callback, keras_callback],
workers=worker)
model.summary()
tf.saved_model.save(
obj=model,
export_dir=os.path.join(export_path, '1')
)
def train_test_model(logdir, hparams):
classifier = tf.keras.Sequential()
classifier.add(
tf.keras.layers.Conv2D(filters=hparams[HP_CNN_FILTER_1],
kernel_size=(hparams[HP_CNN_KERNEL_X_1],
hparams[HP_CNN_KERNEL_Y_1]),
padding='same',
activation='relu',
input_shape=(x_train[0].shape[0],
x_train[0].shape[1], 1)))
if hparams[HP_BATCH_NORM]:
classifier.add(tf.keras.layers.BatchNormalization())
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(hparams[HP_DROPOUT]))
classifier.add(
tf.keras.layers.Conv2D(filters=hparams[HP_CNN_FILTER_2],
kernel_size=(hparams[HP_CNN_KERNEL_X_2],
hparams[HP_CNN_KERNEL_Y_2]),
padding='same',
activation='relu'))
classifier.add(tf.keras.layers.MaxPooling2D(pool_size=2))
classifier.add(tf.keras.layers.Dropout(hparams[HP_DROPOUT]))
classifier.add(tf.keras.layers.Flatten())
classifier.add(
tf.keras.layers.Dense(hparams[HP_NUM_UNITS], activation='relu'))
classifier.add(tf.keras.layers.Dropout(hparams[HP_DROPOUT]))
classifier.add(tf.keras.layers.Dense(1, activation='sigmoid'))
classifier.compile(optimizer=tf.keras.optimizers.Adam(
learning_rate=hparams[HP_LEARNING_RATE], decay=0.001),
loss='binary_crossentropy',
metrics=['accuracy'])
cb = [
tf.keras.callbacks.TensorBoard(log_dir=logdir),
hp.KerasCallback(logdir, hparams)
]
classifier.fit(x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=64,
epochs=100,
callbacks=cb,
verbose=0)
_, accuracy = classifier.evaluate(x_test, y_test)
return accuracy
def _train_test(model): # pragma: no cover
extra_callback = [hp.KerasCallback(logdir, options_dict)]
training((train_data, val_data), options, model, logdir,
extra_callback)
K.clear_session()
predictions = dgpred.predict_complete(step_size,
options,
logdir,
val_data,
use_mss=True)
K.clear_session()
is_not_na = np.logical_not(np.isnan(predictions[:, 0]))
predictions_class = predictions[is_not_na].argmax(axis=1)
dgpred.filter_segments(predictions_class, options.min_mss_len)
_, metrics = dgpred.calculate_metrics(
predictions_class, val_data.truelbl[:, is_not_na].argmax(axis=0))
return metrics
