def fit_model(self, X_train, X_val, y_train, y_val, class_weights, is_frozen_layers: bool) -> None:
"""
Fit the CNN model and plot the training evolution.
Originally written as a group for the common pipeline. Later amended by Adam Jaamour.
:param X_train: training input
:param X_val: training outputs
:param y_train: validation inputs
:param y_val: validation outputs
:param class_weights: dict containing class weights
:param is_frozen_layers: boolean specifying whether layers are frozen or not
:return: None
"""
if is_frozen_layers:
max_epochs = config.max_epoch_frozen
patience = int(config.max_epoch_frozen / 10)
else:
max_epochs = config.max_epoch_unfrozen
patience = int(config.max_epoch_unfrozen / 10)
if config.dataset == "mini-MIAS":
self.history = self._model.fit(
x=X_train,
y=y_train,
# class_weight=class_weights,
batch_size=config.batch_size,
steps_per_epoch=len(X_train) // config.batch_size,
validation_data=(X_val, y_val),
validation_steps=len(X_val) // config.batch_size,
epochs=max_epochs,
callbacks=[
EarlyStopping(monitor='val_loss', patience=patience, restore_best_weights=True),
ReduceLROnPlateau(patience=int(patience / 2))
]
)
elif config.dataset == "mini-MIAS-binary":
self.history = self._model.fit(
x=X_train,
y=y_train,
batch_size=config.batch_size,
steps_per_epoch=len(X_train) // config.batch_size,
validation_data=(X_val, y_val),
validation_steps=len(X_val) // config.batch_size,
epochs=max_epochs,
callbacks=[
EarlyStopping(monitor='val_loss', patience=patience, restore_best_weights=True),
ReduceLROnPlateau(patience=int(patience / 2))
]
)
elif config.dataset == "CBIS-DDSM":
self.history = self._model.fit(
x=X_train,
validation_data=X_val,
class_weight=class_weights,
epochs=max_epochs,
callbacks=[
EarlyStopping(monitor='val_loss', patience=patience, restore_best_weights=True),
ReduceLROnPlateau(patience=int(patience / 2))
]
)
def get_callbacks(file_name=''):
if file_name != '':
path_checkpoint = 'checkpoint_keras_' + file_name
log_dir = 'logs_' + file_name
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint,
monitor='val_loss',
verbose=1,
save_weights_only=False,
save_best_only=True,
mode='auto',
period=1)
callback_early_stopping = EarlyStopping(monitor='val_loss',
patience=5,
verbose=1)
callback_tensorboard = TensorBoard(log_dir=log_dir,
histogram_freq=0,
write_graph=False)
callback_reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
min_lr=1e-4,
patience=3,
verbose=1)
callbacks = [callback_checkpoint, callback_tensorboard, callback_reduce_lr]
return callbacks
def fit(self, model: GlowModel, dp: DataProcessor):
tc = self.config.training
model.dump_model_internal()
self.compile(model)
steps_per_epoch = tc.steps_per_epoch or dp.image_count // tc.batch_size
callbacks = [
SamplingCallback(self.config, model),
TensorBoard(
str(self.config.resource.tensorboard_dir),
batch_size=tc.batch_size,
write_graph=True,
# histogram_freq=5, write_grads=True
),
ReduceLROnPlateau(monitor='loss',
factor=tc.lr_decay,
patience=tc.lr_patience,
verbose=1,
min_lr=tc.lr_patience),
]
try:
model.encoder.fit_generator(self.generator_for_fit(dp),
epochs=tc.epochs,
steps_per_epoch=steps_per_epoch,
callbacks=callbacks,
verbose=1)
except InvalidArgumentError as e:
model.dump_model_internal()
raise e
def train(self, x, y, batch_size, epochs, verbose):
def exp_decay(epoch):
initial_lrate = self.learning_rate
k = 0.1
lrate = initial_lrate * np.exp(-k * epoch)
return lrate
callbacks = [
EarlyStopping(patience=20,
monitor='val_loss',
restore_best_weights=True),
LearningRateScheduler(exp_decay, verbose=0),
ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=10,
verbose=0),
TensorBoard(log_dir=self.model_dir),
TerminateOnNaN()
]
history = self.ed_model.fit(x=x,
y=y,
batch_size=batch_size,
epochs=epochs,
callbacks=callbacks,
shuffle=False,
validation_split=0.2,
verbose=verbose)
return history.history
def execute(self):
result_file = os.path.join(self.result_dir, "train_result_{}.txt".format(self.task_index))
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session(self.server.target, config=config) as sess:
K.set_session(sess)
if self.go_on:
self.restore_model()
tb_callback = TensorBoard(log_dir=self.log_dir, write_grads=True, write_images=True)
ckpt_callback = ModelCheckpoint(self.checkpoint_path,
monitor='loss',
save_weights_only=True)
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.1, patience=3, verbose=1)
early_stopping = EarlyStopping(monitor='loss', min_delta=0, patience=10, verbose=1)
# add callbacks to save model checkpoint and tensorboard events (on worker:0 only)
callbacks = [tb_callback, ckpt_callback] if self.task_index == 0 else []
callbacks += [reduce_lr, early_stopping]
# try:
his = self.model.fit_generator(self.generate_rdd_data(),
steps_per_epoch=self.steps_per_epoch,
# validation_data=self.val_generate_data(val_data),
# validation_steps=max(1, self.val_num // self.batch_size),
epochs=self.epochs + self.initial_epoch,
initial_epoch=self.initial_epoch,
workers=0,
callbacks=callbacks)
logger.debug("{}-{}".format(self.task_index, his.history))
ModelDir.write_result(result_file, self.get_results(his), self.go_on)
# except Exception as e:
# logger.debug(str(e))
self.save_model()
self.tf_feed.terminate()
def train(self):
state_model = StateModel(self.config)
if self.config.train.new_model:
state_model.build()
else:
state_model.load_model()
self.config.train.vae.lr *= 0.01
state_model.compile()
self.memory = FileMemory(self.config)
self.memory.forget_past()
all_episode_list = list(self.memory.episodes())
generator = self.episode_generator(all_episode_list)
vae = self.config.train.vae
callbacks = [
ReduceLROnPlateau(factor=vae.lr_decay_factor,
patience=vae.lr_patience,
min_lr=vae.lr_min,
monitor='loss',
verbose=1),
EarlyStopping(monitor="loss",
patience=vae.early_stopping_patience),
]
state_model.model.training_model.fit_generator(
generator,
steps_per_epoch=vae.steps_per_epoch,
epochs=vae.epochs,
callbacks=callbacks)
state_model.save_model()
def gen_model(param_object):
x_train, y_train = load_data(flag=0)
_G = generator(param_object.gen_type,
param_object.filter_kernal[param_object.filter_kernal_no],
param_object.input_shape, 'Adam', mean_squared_error,
tf.zeros(shape=param_object.inflow_shape,
dtype=tf.float32)).generator_model()
opti_trick = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=100,
verbose=1)
ckpt = ModelCheckpoint(ckpt_path,
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True,
period=1)
_G.fit(x_train,
y_train,
epochs=param_object.epochs,
batch_size=param_object.batch_size,
callbacks=[opti_trick, ckpt],
validation_split=0.2,
shuffle=True)
return _
def try_train_model_nn(model_name, fold):
with utils.timeit_context('load data'):
X, y, video_ids = load_train_data(model_name, fold)
print(X.shape, y.shape)
model = model_nn(input_size=X.shape[1])
model.compile(optimizer=Adam(lr=1e-3),
loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.25,
random_state=42)
batch_size = 64
model.fit(
X_train,
y_train,
batch_size=batch_size,
epochs=128,
verbose=1,
validation_data=[X_test, y_test],
callbacks=[ReduceLROnPlateau(factor=0.2, verbose=True, min_lr=1e-6)])
prediction = model.predict(X_test)
print(y_test.shape, prediction.shape)
print(metrics.pri_matrix_loss(y_test, prediction))
print(metrics.pri_matrix_loss(y_test, np.clip(prediction, 0.001, 0.999)))
delta = prediction - y_test
print(np.min(delta), np.max(delta), np.mean(np.abs(delta)),
np.sum(np.abs(delta) > 0.5))
def set_callbacks(self) -> list:
"""
Returns
-------
"""
monitor = 'val_loss'
es = EarlyStopping(monitor=monitor,
patience=3,
verbose=1,
restore_best_weights=True)
rop = ReduceLROnPlateau(monitor=monitor, patience=5, verbose=1)
checkpoint = ModelCheckpoint(filepath=self.default_path,
monitor=monitor,
verbose=1,
save_best_only=True,
save_weights_only=False,
load_weights_on_restart=False)
logs_dir = os.path.join(DirConf.LOG_DIR, 'experiment')
if not os.path.exists(logs_dir):
os.mkdir(logs_dir)
tb = TensorBoard(log_dir=logs_dir, write_graph=True)
return [es, rop, checkpoint, tb]
def main(net, epochs, batch_size):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
set_session(sess)
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train.astype('float32') / 255, x_test.astype(
'float32') / 255
mean = np.mean(x_train, axis=0)
x_train -= mean
x_test -= mean
datagen = ImageDataGenerator(
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
)
datagen.fit(x_train)
model = make_resnet(net)
model.summary()
model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
validation_data=(x_test, y_test),
epochs=epochs,
callbacks=[
ReduceLROnPlateau(verbose=1, patience=20),
TensorBoard(observer.dir)
])
def main():
feature, label = load_data(train_data_path)
# Split the dataset into train and validation set
# Keep 10% for the validation and 90% for the training
# Stratify is argument to keep training set evenly balanced over the labels
feature_train, feature_test_set, label_train, label_val = train_test_split(
feature, label, test_size=0.1, stratify=label)
## DNN
dnn_model = get_dnn_model()
history = dnn_model.fit(feature_train,
label_train,
batch_size=100,
epochs=8,
validation_data=(feature_test_set, label_val),
verbose=1)
evaluate_model(dnn_model, feature_train, feature_test_set, label_train,
label_val, history)
## CNN
feature = feature.values.reshape(-1, 28, 28, 1)
feature_train, feature_test_set, label_train, label_val = train_test_split(
feature, label, test_size=0.1, stratify=label)
cnn_model = get_cnn_model()
history = cnn_model.fit(feature_train,
label_train,
batch_size=100,
epochs=8,
validation_data=(feature_test_set, label_val),
verbose=1)
evaluate_model(cnn_model, feature_train, feature_test_set, label_train,
label_val, history)
# Hyperparameters optimization (tuning)
hpt_model = get_hyperparam_model()
learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
feature_train, feature_test_set, label_train, label_val = train_test_split(
feature, label, test_size=0.1, stratify=label)
data_generator = get_images(feature_train)
history = hpt_model.fit(data_generator.flow(feature_train,
label_train,
batch_size=100),
epochs=3,
validation_data=(feature_test_set, label_val),
verbose=2,
callbacks=[learning_rate_reduction])
evaluate_model(hpt_model, feature_train, feature_test_set, label_train,
label_val, history)
def train(self, train_gen, val_gen,
saved_model_path, epochs=100, steps=100, train_split=0.8,
verbose=1, min_delta=.0005, patience=5, use_early_stop=True):
"""
train_gen: generator that yields an array of images an array of
"""
# checkpoint to save model after each epoch
save_best = ModelCheckpoint(saved_model_path,
monitor='val_loss',
verbose=verbose,
save_best_only=True,
mode='auto')
# stop training if the validation error stops improving.
early_stop = EarlyStopping(monitor='val_loss',
min_delta=min_delta,
patience=patience,
verbose=verbose,
mode='auto')
# reduce the learning rate if validation error not longer improved
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=patience-2,
min_lr=0.001,
verbose=verbose,
mode='auto')
tensorboard = TensorBoard(log_dir='/home/wangbin/mycar/logs',
histogram_freq=0,
batch_size=32,
write_graph=True,
write_grads=False,
write_images=True)
# embeddings_freq=0,
# embeddings_layer_names=None,
# embeddings_metadata=None,
# embeddings_data=None,
# update_freq='epoch')
callbacks_list = [save_best]
if use_early_stop:
callbacks_list.append(early_stop)
callbacks_list.append(reduce_lr)
callbacks_list.append(tensorboard)
hist = self.model.fit_generator(
train_gen,
steps_per_epoch=steps,
epochs=epochs,
verbose=verbose,
validation_data=val_gen,
callbacks=callbacks_list,
validation_steps=steps * (1.0 - train_split) / train_split)
return hist
def run_train_test(test_name, gray, augmentation, pic_shape, if_transfer,
epoch, batch_size, model_type, optimizer, data):
data_string = f"pic_shape{pic_shape}_aug={augmentation}_gray={gray}"
info_str = f"{test_name}/optimizer={optimizer}_data={data[1]}_epoch={epoch}_batch={batch_size}_model={model_type}_data_string={data_string}"
logdir = "../../logs/" + info_str
tensorboard_callback = callbacks.TensorBoard(log_dir=logdir)
train_gen, test_gen, class_weights = data[0]
train_gen = DataGenerator(train_gen.x_data, train_gen.y_data,
train_gen.class_number)
test_gen = DataGenerator(test_gen.x_data, test_gen.y_data,
test_gen.class_number)
train_gen.set_parameters(batch_size, augmentation)
test_gen.set_parameters(batch_size, False)
print("class weights ", class_weights)
if if_transfer:
model = transfer_model(model_type, pic_shape, train_gen.class_number)
else:
model = my_model(model_type, pic_shape)
model.add(layers.Dense(train_gen.class_number, activation="softmax"))
if data[1] == "two":
metrics = MetricsTwo(test_gen, class_weights)
else:
metrics = MetricsAll(test_gen, class_weights)
model.compile(optimizer=optimizer,
loss=losses.CategoricalCrossentropy(from_logits=True),
metrics=["accuracy"])
learning_rate_reduction = ReduceLROnPlateau(monitor='loss',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
if augmentation:
class_weights = None
model.fit(
train_gen,
epochs=epoch,
batch_size=batch_size,
validation_data=test_gen,
class_weight=class_weights,
callbacks=[tensorboard_callback, metrics, learning_rate_reduction])
pred = model.predict(test_gen.x_data)
pred_classes = np.argmax(pred, axis=1)
true_classes = test_gen.y_data
plot_confusion_matrix(true_classes, pred_classes, data[1],
"../../diagrams/conf/" + info_str + ".png")
add_tb_info(metrics, epoch, data[1], logdir)
if data[1] == "two":
plot_roc(test_gen.y_data, pred[:, 1],
"../../diagrams/roc/" + info_str + ".png")
def get_callbacks(weight_path: str, history_path: str) -> List[Callback]:
"""
Retorna a lista callbacks do modelo
Args:
-----
weight_path: Caminho para salvar os checkpoints
Returns:
--------
(list of keras.callbacks): lista dos callbacks
"""
# Salva os pesos dos modelo para serem carregados
# caso o monitor não diminua
check_params = {
"monitor": "val_loss",
"verbose": 1,
"mode": "min",
"save_best_only": True,
"save_weights_only": True,
}
checkpoint = ModelCheckpoint(weight_path, **check_params)
# Reduz o valor de LR caso o monitor nao diminuia
reduce_params = {
"factor": 0.5,
"patience": 3,
"verbose": 1,
"mode": "max",
"min_delta": 1e-3,
"cooldown": 2,
"min_lr": 1e-8,
}
reduce_lr = ReduceLROnPlateau(monitor="val_f1", **reduce_params)
# Parada do treino caso o monitor nao diminua
stop_params = {"mode": "max", "restore_best_weights": True, "patience": 40}
early_stop = EarlyStopping(monitor="val_f1", **stop_params)
# Termina se um peso for NaN (not a number)
terminate = TerminateOnNaN()
# Habilita a visualizacao no TersorBoard
# tensorboard = TensorBoard(log_dir="./logs")
# Armazena os dados gerados no treinamento em um CSV
if history_path is not None:
csv_logger = CSVLogger(history_path, append=True)
# Vetor a ser passado na função fit
callbacks = [checkpoint, early_stop, reduce_lr, terminate, csv_logger]
else:
# Vetor a ser passado na função fit
# callbacks = [
# checkpoint,
# early_stop,
# reduce_lr,
# terminate
# ]
callbacks = [checkpoint, reduce_lr, terminate]
# callbacks = [checkpoint, early_stop, reduce_lr, terminate]
return callbacks
def learning_rate_setting():
if MODEL_WIDTH > 800:
reduce_lr = ReduceLROnPlateau(monitor=MONITOR,
patience=5,
factor=0.5,
verbose=1,
mode='auto',
cooldown=5,
min_lr=0.00001)
else:
reduce_lr = ReduceLROnPlateau(monitor=MONITOR,
patience=5,
factor=0.7,
verbose=1,
mode='auto',
cooldown=10,
min_lr=0.00001)
return reduce_lr
def train_vUnet(dataset, lr, epochs, trial_num, model_path=None):
# get the data
data_getter = DataPreparer(im_path, mask_path, batch_size=batch_size)
train_generator, val_generator = data_getter.main()
num_train = data_getter.num_train
num_val = data_getter.num_val
# get model
if not model_path:
model_flag = 'vUnet'
model = new_Unet(model_flag)
for i in range(18): # first 18 layers of pre-trained model
model.layers[i].trainable = False
model.summary()
print('dataset: ', dataset)
print('num of training data: ', num_train)
print('num of validation data: ', num_val)
# compile
model.compile(
optimizer=Adam(lr),
loss=['binary_crossentropy', 'binary_crossentropy'], # mask, edge
metrics=[dice_coef],
loss_weights=[0.998, 0.002])
else:
model = load_model(model_path, custom_objects={'dice_coef': dice_coef})
# callbacks
reduce_lr = ReduceLROnPlateau(monitor='loss',
factor=0.5,
patience=5,
verbose=1,
min_lr=1e-6)
model_name = "results/model/human_muscle/vUnet_{0}_{1}.hdf5".format(
dataset, trial_num)
model_checkpoint = ModelCheckpoint(model_name,
monitor='val_loss',
save_best_only=True,
verbose=1)
tensorboard = TensorBoard(log_dir='./log/' + dataset + '/' + trial_num,
write_graph=False,
write_grads=False,
histogram_freq=15,
batch_size=batch_size)
# train
hist = model.fit_generator(
train_generator,
epochs=epochs,
steps_per_epoch=num_train // batch_size,
verbose=2,
callbacks=[reduce_lr, tensorboard, model_checkpoint],
validation_data=val_generator,
validation_steps=num_val // batch_size)
return
def full_training(model, train_data, val_data, epochs1, epochs2):
if config.pretrained == "imagenet":
for i in range(140):
model.layers[i].trainable = False
else:
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=Adam(lr=0.0001),
loss=dual_loss_weighted,
metrics=[BinaryAccuracy()])
hist_1 = model.fit(x=train_data,
validation_data=val_data,
epochs=epochs1,
callbacks=[
EarlyStopping(monitor='val_loss',
patience=10,
restore_best_weights=True),
ReduceLROnPlateau(patience=4)
])
# Train a second time with a smaller learning rate and with all layers unfrozen
# (train over fewer epochs to prevent over-fitting).
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=Adam(lr=0.00001),
loss=dual_loss_weighted,
metrics=[BinaryAccuracy()])
hist_2 = model.fit(x=train_data,
validation_data=val_data,
epochs=epochs2,
callbacks=[
EarlyStopping(monitor='val_loss',
patience=10,
restore_best_weights=True),
ReduceLROnPlateau(patience=6)
])
return model
def train(self, save_dir, result_dir, checkpoint_dir, log_dir):
result_file = os.path.join(result_dir, "train_result.txt")
train_set = self.train_set
config = tf.compat.v1.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.compat.v1.Session(config=config) as sess:
# K.set_session(sess)
if self.go_on:
self.restore_model(checkpoint_dir)
tb_callback = TensorBoard(log_dir=log_dir, write_images=True)
checkpoint_file = os.path.join(checkpoint_dir,
self.name + '_checkpoint_{epoch}')
ckpt_callback = ModelCheckpoint(
checkpoint_file,
# monitor='loss',
save_weights_only=True)
reduce_lr = ReduceLROnPlateau(monitor='loss',
factor=0.1,
patience=3,
verbose=1)
early_stopping = EarlyStopping(monitor='loss',
min_delta=0,
patience=10,
verbose=1)
# add callbacks to save model checkpoint and tensorboard events (on worker:0 only)
callbacks = [tb_callback, ckpt_callback]
# callbacks = []
self.model.compile(optimizer=Adam(lr=1e-4),
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
})
# print('Unfreeze all of the layers.')
callbacks.extend([reduce_lr, early_stopping])
steps_per_epoch = len(train_set) // self.batch_size
# note that more GPU memory is required after unfreezing the body
# try:
his = self.model.fit_generator(
self.train_generate_data(train_set),
steps_per_epoch=steps_per_epoch,
# validation_data=self.val_generate_data(val_data),
# validation_steps=max(1, self.val_num // self.batch_size),
epochs=self.initial_epoch + 1,
initial_epoch=self.initial_epoch,
workers=1,
callbacks=callbacks)
logger.debug(str(his.history))
# except Exception as e:
# logger.debug(str(e))
# logger.debug('end')
save_model_path = os.path.join(save_dir, 'model.h5')
self.model.save(save_model_path)
ModelDir.write_result(result_file, self.get_results(his))
def get_callbacks():
earlystop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=10)
lr_reduction = ReduceLROnPlateau(monitor='val_loss',
patience=3,
verbose=1,
factor=0.5,
min_lr=1e-5)
csv_log = CSVLogger(base_path + 'log.csv')
# tensorboard = TensorBoard(log_dir='log(logs)')
callbacks = [earlystop, lr_reduction, csv_log]
return callbacks
def train_temporal(batch_size=6, epoch=1000):
raw_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM/'
flowimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticflow_image/'
strainimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticalstrain_image/'
best_model_file = "./models/VGG_16_5_channels_temporal.h5"
train_data_list_path = './train_list.txt'
f1 = open(train_data_list_path, 'r')
train_data_list = f1.readlines()
steps_per_epoch = int(ceil(len(train_data_list) * 1.0 / batch_size))
test_data_list_path = './test_list.txt'
f2 = open(test_data_list_path, 'r')
test_data_list = f2.readlines()
validation_steps = int(ceil(len(test_data_list) * 1.0 / batch_size))
vgg_model = load_model('./models/VGG_16_5_channels.h5')
model = Model(inputs=vgg_model.input, outputs=vgg_model.layers[35].output)
model.predict_on_batch(np.zeros(
(10, 224, 224, 5))) #https://www.jianshu.com/p/c84ae0527a3f
best_model = ModelCheckpoint(best_model_file,
monitor='val_acc',
verbose=1,
save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor='val_acc',
factor=0.5,
patience=3,
verbose=1,
min_lr=0.00001)
temporal_model = temporal_module(data_dim=4096)
temporal_model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.00001, decay=0.000001),
metrics=["accuracy"])
temporal_model.fit_generator(
generator_batch_feature(model,
raw_path,
flowimg_path,
strainimg_path,
train_data_list,
batch_size=batch_size),
steps_per_epoch=steps_per_epoch,
epochs=epoch,
verbose=1,
validation_data=generator_batch_feature(model,
raw_path,
flowimg_path,
strainimg_path,
test_data_list,
batch_size=batch_size),
validation_steps=validation_steps,
class_weight=None,
callbacks=[best_model, reduce_lr])
f1.close()
f2.close()
def get_callbacks(model_filename, patience_stopping=5, patience_lr=10):
early_stopping = EarlyStopping(monitor="val_loss", patience=patience_stopping, verbose=1)
mcp_save = ModelCheckpoint(model_filename, save_best_only=True, monitor="val_loss", mode="min")
reduce_lr_loss = ReduceLROnPlateau(
monitor="loss",
factor=0.1,
patience=patience_lr,
verbose=1,
epsilon=1e-4,
mode="min",
)
return [early_stopping, mcp_save, reduce_lr_loss]
def trainModel(data, model_path):
X = data['X']
y = data['y']
(X_train, X_val, y_train, y_val) = train_test_split(X, y, test_size = 0.3, random_state=SEED)
print('Building model using C-RNN architecture...')
n_features = numFeatures
input_shape = (None, n_features)
model_input = Input(input_shape, name='input')
layer = model_input
for i in range(N_LAYERS):
layer = Conv1D(
filters=CONV_FILTER_COUNT,
kernel_size=FILTER_LENGTH,
name='convolution_' + str(i + 1)
)(layer)
layer = BatchNormalization(momentum=0.9)(layer)
layer = Activation('relu')(layer)
layer = MaxPooling1D(2)(layer)
# layer = Dropout(0.5)(layer)
layer = TimeDistributed(Dense(len(GENRES)))(layer)
time_distributed_merge_layer = Lambda(
function=lambda x: K.mean(x, axis=1),
output_shape=lambda shape: (shape[0],) + shape[2:],
name='output_merged'
)
layer = time_distributed_merge_layer(layer)
layer = Activation('softmax', name='output_realtime')(layer)
model_output = layer
model = Model(model_input, model_output)
opt = Adam(lr=0.001)
model.compile(
loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy']
)
print('Starting training...')
model.fit(
X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS,
validation_data=(X_val, y_val), verbose=1, callbacks=[
ModelCheckpoint(
model_path, save_best_only=True, monitor='val_acc', verbose=1
),
ReduceLROnPlateau(
monitor='val_acc', factor=0.5, patience=10, min_delta=0.01,
verbose=1
)
]
)
return model
def train_spatial(batch_size=32, epoch=1000):
raw_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM/'
flowimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticflow_image/'
strainimg_path = '/media/zxl/other/pjh/datasetsss/CASME_II_TIM_opticalstrain_image/'
best_model_file = "./models/VGG_16_5_channels.h5"
train_data_list_path = './train_list.txt'
f1 = open(train_data_list_path, 'r')
train_data_list = f1.readlines()
steps_per_epoch = int(ceil(len(train_data_list) * 1.0 / batch_size))
test_data_list_path = './test_list.txt'
f2 = open(test_data_list_path, 'r')
test_data_list = f2.readlines()
validation_steps = int(ceil(len(test_data_list) * 1.0 / batch_size))
# X = generator_batch_5c(raw_path, flowimg_path, strainimg_path, data_list)
vgg_model = VGG_16_5_channels()
vgg_model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.00001, decay=0.000001),
metrics=["accuracy"])
best_model = ModelCheckpoint(best_model_file,
monitor='val_acc',
verbose=1,
save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor='val_acc',
factor=0.5,
patience=3,
verbose=1,
min_lr=0.00001)
vgg_model.fit_generator(generator_batch_5c(raw_path,
flowimg_path,
strainimg_path,
train_data_list,
batch_size=batch_size),
steps_per_epoch=steps_per_epoch,
epochs=epoch,
verbose=1,
validation_data=generator_batch_5c(
raw_path,
flowimg_path,
strainimg_path,
test_data_list,
batch_size=batch_size),
validation_steps=validation_steps,
class_weight=None,
callbacks=[best_model, reduce_lr],
max_queue_size=80,
workers=8,
use_multiprocessing=False)
f1.close()
f2.close()
def get_callbacks() -> List[Callback]:
"""
Retorna a lista callbacks do modelo
Args:
-----
weight_path: Caminho para salvar os checkpoints
Returns:
--------
(list of keras.callbacks): lista dos callbacks
"""
# Salva os pesos dos modelo para serem carregados
# caso o monitor não diminua
check_params = {
'monitor': 'val_loss',
'verbose': 1,
'mode': 'min',
'save_best_only': True,
'save_weights_only': True
}
checkpoint = ModelCheckpoint('./checkpoints/', **check_params)
# Reduz o valor de LR caso o monitor nao diminuia
reduce_params = {
'factor': 0.5,
'patience': 3,
'verbose': 1,
'mode': 'min',
'min_delta': 1e-3,
'cooldown': 2,
'min_lr': 1e-8
}
reduce_lr = ReduceLROnPlateau(monitor='val_loss', **reduce_params)
# Parada do treino caso o monitor nao diminua
stop_params = {'mode': 'min', 'restore_best_weights': True, 'patience': 40}
early_stop = EarlyStopping(monitor='val_f1', **stop_params)
# Termina se um peso for NaN (not a number)
terminate = TerminateOnNaN()
# Habilita a visualizacao no TersorBoard
# tensorboard = TensorBoard(log_dir="./logs")
# Armazena os dados gerados no treinamento em um CSV
# csv_logger = CSVLogger('./logs/trainig.log', append=True)
# Vetor a ser passado na função fit
# callbacks = [checkpoint, early_stop, reduce_lr, terminate, tensorboard, csv_logger]
callbacks = [checkpoint, early_stop, reduce_lr, terminate]
return callbacks
def __init__(self):
"""
Set callbacks on init
"""
tensorboard = tf.keras.callbacks.TensorBoard(
log_dir=self.tensorboard_log)
early_stopping = EarlyStopping(patience=15, verbose=1)
reduce_lr_on_plateau = ReduceLROnPlateau(factor=.4,
patience=7,
verbose=1)
timing = TimingCallback()
self.callbacks = [
tensorboard, early_stopping, reduce_lr_on_plateau, timing
]
def resnet_attention_train_predict(
row,
PCA_num,
model_number,
modelfile,
m,
x_train,
y_train,
x_test,
y_test,
Epochs,
Batch_size,
):
y_train, y_train, x_test, y_test = x_train, y_train, x_test, y_test
model = resnet_v1(input_shape=(row, PCA_num + 1, m),
depth=20,
num_classes=2)
model.compile(optimizer="Adam",
loss=keras.losses.binary_crossentropy,
metrics=['accuracy'])
lr_scheduler = LearningRateScheduler(lr_schedule)
lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1),
cooldown=0,
patience=5,
min_lr=0.5e-6)
checkpoint = ModelCheckpoint(
filepath=modelfile, monitor='val_loss', verbose=0,
save_best_only=True) #,save_weights_only=True)
cbs = [checkpoint, lr_reducer, lr_scheduler]
history = model.fit(
x_train,
y_train,
batch_size=Batch_size,
epochs=Epochs,
verbose=0,
#validation_split=0.1,
validation_data=[x_test, y_test],
shuffle=False,
callbacks=cbs) #callbacks=cbs
return history
del model
def __init__(self,
alpha=0.031157,
delta=0.13907,
epsilon_decay=0.99997,
eta=0.044575,
gamma=0.013082,
learning_rate=0.050023):
super().__init__("DQN")
self.action_size = State.ACTION_SIZE
self.state_size = State.STATE_SIZE
self.memory_rl = PrioritizedReplayBuffer(2000000)
self.memory_sl = SupervisedMemory(2000000)
self.batch_size = 512
self.model_update_frequency = 10
self.model_save_frequency = 100
self.alpha = alpha # Pred opt: 0.7
self.delta = delta # Pred opt: 0.5
self.epsilon = 1
self.epsilon_min = 0.001
self.epsilon_decay = epsilon_decay # Pred opt: 0.99999
self.gamma = gamma # 0 # 0.029559 # Pred opt: 0.01
self.learning_rate = learning_rate # Pred opt: 0.1
self.learning_rate_sl = 0.005
self.eta = eta # Pred opt: 0.1
self.number_of_episodes = 1000
self.reduce_lr = ReduceLROnPlateau(monitor='loss',
factor=0.1,
patience=5,
min_lr=0)
self.policy_network = self.build_model(
self.learning_rate, 'linear',
Huber(reduction=Reduction.SUM, delta=self.delta))
self.target_network = self.build_model(
self.learning_rate, 'linear',
Huber(reduction=Reduction.SUM, delta=self.delta))
self.target_network.set_weights(self.policy_network.get_weights())
self.supervised_learning_network = self.build_model(
self.learning_rate_sl, 'softmax',
tf.keras.losses.sparse_categorical_crossentropy)
self.total_rewards_p1 = []
self.total_rewards_p2 = []
self.losses = []
self.steps = 0
self.p2 = AgentPlaceholder()
self.rounds = 0
self.n_batches = 0
self.save_model = True
self.env = UnoEnvironment(False)
def create_model(x_train, y_train, x_val, y_val, n_step, n_features):
callbacks_list = [
EarlyStopping(
monitor='val_loss',
patience=5,
),
ReduceLROnPlateau(
monitor='val_loss',
factor=0.3,
patience=2,
)
]
a = x_train.shape[0]
b = x_val.shape[0]
bigger = a if a > b else b
gcd = 1
for i in range(1, int(bigger**0.5) + 1):
if (a % i == 0) and (b % i == 0) and (gcd < i):
gcd = i
model = Sequential()
model.add(
LSTM({{choice([64, 128, 256])}},
return_sequences=True,
batch_input_shape=(gcd, n_step, n_features),
stateful=True))
#if {{choice(['add', 'no'])}} == 'add':
# model.add(LSTM({{choice([64, 128, 256])}}, stateful=True, return_sequences=True))
model.add(Dense(n_features))
model.compile(optimizer='adam', loss='mae', metrics=['acc'])
for epoch_idx in range(200):
hist = model.fit(x_train,
y_train,
epochs=1,
validation_data=(x_val, y_val),
callbacks=callbacks_list,
shuffle=False,
verbose=0,
batch_size=gcd)
model.reset_states()
return {
'loss': np.amin(hist.history['val_loss']),
'status': STATUS_OK,
'model': model
}
def get_callbacks():
es = EarlyStopping(monitor='val_auc',
min_delta=0.001,
patience=2,
verbose=1,
mode='max',
baseline=None,
restore_best_weights=True)
rlr = ReduceLROnPlateau(monitor='val_auc',
factor=0.5,
patience=3,
min_lr=1e-6,
mode='max',
verbose=1)
return [es, rlr]
def init_callbacks(monitor: str, lr_patience: int, lr_decay: float,
lr_min: float, early_stopping_patience: int, verbosity: int,
weights_path: str, selective_learning: bool) -> []:
"""
Initializes callbacks for the training procedure.
:param monitor: the metric to monitor.
:param lr_patience: the number of epochs to wait before decaying the learning rate. Set it to 0 to ignore decaying.
:param lr_decay: the decay of the learning rate.
:param lr_min: the minimum learning rate to be reached.
:param early_stopping_patience: the number of epochs to wait before early stopping.
:param verbosity: the verbosity of the callbacks.
:param weights_path: path to the weights to be saved. Pass None, in order to not save the best model.
:param selective_learning: whether the selective_learning framework is being used.
:return: the callbacks list.
"""
callbacks = []
if not selective_learning and weights_path is not None:
callbacks.append(
ModelCheckpoint(weights_path,
monitor,
save_weights_only=True,
save_best_only=True))
if lr_decay > 0 or lr_patience == 0:
learning_rate_reduction = ReduceLROnPlateau(monitor=monitor,
patience=lr_patience,
verbose=verbosity,
factor=lr_decay,
min_lr=lr_min)
callbacks.append(learning_rate_reduction)
if early_stopping_patience > 0:
early_stopping = EarlyStopping(monitor=monitor,
patience=early_stopping_patience,
min_delta=.0002,
mode='max',
restore_best_weights=True,
verbose=verbosity)
callbacks.append(early_stopping)
if selective_learning:
callbacks.append(_SelectiveLearningCallback())
return callbacks
