def train():
from src.sequence.SignRecognitionSequence import SignRecognitionSequence
seq = SignRecognitionSequence(
'./data/train/ppm/signrecognition_data_train.csv',
'./data/train/ppm/',
im_size=IMAGE_SIZE,
batch_size=32)
X_valid = np.array([load_image(im) for im in seq.X_valid])
y_valid = seq.y_valid
tensor_board = TensorBoard(log_dir='logs',
histogram_freq=0,
write_graph=True,
write_images=True)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=5,
min_lr=0.00001)
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0.001,
patience=10,
verbose=1,
mode='auto',
baseline=None,
restore_best_weights=True)
callbacks = [
#tf.keras.callbacks.ModelCheckpoint('models/my_model.h5', verbose=1,save_best_only=True),
tensor_board,
reduce_lr,
early_stopping
]
print('--------------------------')
print("Performing training...")
model = createModel()
model.fit_generator(generator=seq,
epochs=40,
use_multiprocessing=False,
workers=1,
callbacks=callbacks,
validation_data=(X_valid, y_valid))
return model
def finetune(train_path, test_path):
train_datagen = ImageDataGenerator()
test_datagen = ImageDataGenerator()
print("获取测试数据... ...")
test_generator = test_datagen.flow_from_directory(test_path,
target_size=(224, 224),
batch_size=4)
print("获取训练数据... ...")
train_generator = train_datagen.flow_from_directory(train_path,
target_size=(224, 224),
batch_size=4)
print("开始训练... ...")
logging = TensorBoard(log_dir='/home/app/program/micro_emotion/log')
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=5,
verbose=1)
model_check = ModelCheckpoint(filepath=model_path,
monitor='val_loss',
save_best_only=True)
lr_decay = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=3,
min_delta=0.001)
model = RN.resnet10(include_top=False,
pooling='avg',
input_shape=(224, 224, 3),
classes=5)
x = model.output
x = Dense(5, activation='softmax', name='fc8_micro')(x)
model = Model(inputs=model.input, outputs=x)
model.load_weights(pre_model, by_name=True)
#model = frozen(model)
model.compile(loss="categorical_crossentropy",
optimizer=SGD(lr=0.01, momentum=0.9, decay=0.1 / 10),
metrics=['accuracy'])
history = model.fit_generator(
train_generator,
steps_per_epoch=62,
epochs=30,
validation_data=test_generator,
validation_steps=30,
callbacks=[logging, early_stopping, model_check, lr_decay])
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='min')
# stop training if the validation error stops improving.
early_stop = EarlyStopping(monitor='val_loss',
min_delta=min_delta,
patience=patience,
verbose=verbose,
mode='auto')
callbacks_list = [save_best]
if use_early_stop:
callbacks_list.append(early_stop)
hist = self.model.fit_generator(train_gen,
steps_per_epoch=steps,
epochs=epochs,
verbose=1,
validation_data=val_gen,
callbacks=callbacks_list,
validation_steps=steps *
(1.0 - train_split) / train_split)
return hist
def train(data, label, score, opts, vars):
n_input = data[0].dim
n_output = 1
print('load network architecture from ' + opts['network'] + '.py')
print('#input: {} \n#output: {}'.format(n_input, n_output))
module = __import__(opts['network'])
model = module.getModel(n_input, n_output)
train_x = np.empty((len(data), n_input))
train_y = np.empty((len(data), n_output))
print('Data length {}'.format(len(data)))
for sample in range(len(data)):
train_x[sample] = np.reshape(data[sample], (n_input))
train_y[sample] = score[sample]
train_x = train_x.astype('float32')
model.compile(loss=correlation_coefficient_loss,
optimizer=Adam(lr=0.00001))
#checkpoint
#filepath="weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5"
#checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=False, mode='max')
early_stoppping = EarlyStopping(monitor='loss',
min_delta=0.0001,
patience=3)
callbacks_list = [early_stoppping]
model.fit(train_x,
train_y,
epochs=opts['n_epoch'],
batch_size=opts['batch_size'],
shuffle=True,
callbacks=callbacks_list)
vars['n_input'] = n_input
vars['n_output'] = n_output
vars['model'] = model
def get_callbacks(
model_name: str
) -> List[Union[TensorBoard, EarlyStopping, ModelCheckpoint]]:
"""Accepts the model name as a string and returns multiple callbacks for training the keras model.
Parameters
----------
model_name : str
The name of the model as a string.
Returns
-------
List[Union[TensorBoard, EarlyStopping, ModelCheckpoint]]
A list of multiple keras callbacks.
"""
logdir = ("logs/scalars/" + model_name + "_" +
datetime.now().strftime("%Y%m%d-%H%M%S")
) # create a folder for each model.
tensorboard_callback = TensorBoard(log_dir=logdir)
# use tensorboard --logdir logs/scalars in your command line to startup tensorboard with the correct logs
early_stopping_callback = EarlyStopping(
monitor="val_mean_absolute_percentage_error",
min_delta=1, # model should improve by at least 1%
patience=
10, # amount of epochs with improvements worse than 1% until the model stops
verbose=2,
mode="min",
restore_best_weights=
True, # restore the best model with the lowest validation error
)
model_checkpoint_callback = ModelCheckpoint(
"./data/models/" + model_name,
monitor="val_mean_absolute_percentage_error",
verbose=0,
save_best_only=True, # save the best model
mode="min",
save_freq="epoch", # save every epoch
) # saving eff_net takes quite a bit of time
return [
tensorboard_callback, early_stopping_callback,
model_checkpoint_callback
]
def callback_func(self, B1_dir):
# Seek a mininum for validation loss and display the stopped epochs using verbose and adding delays
es = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=100)
# Save best model using checkpoint
model_path = os.path.join(B1_dir, 'VGGNet.h5')
mcp = ModelCheckpoint(os.path.normcase(model_path),
monitor='val_loss',
mode='min',
verbose=1,
save_best_only=True)
# Define callback function in a list
callback_list = [es, mcp]
return callback_list, model_path
def get_callbacks(WEIGHTS_FPATH, LOG_FPATH, monitor):
callbacks = [
ModelCheckpoint(WEIGHTS_FPATH,
monitor=monitor,
save_best_only=True,
save_weights_only=True,
mode='auto'),
EarlyStopping(monitor=monitor, patience=3),
#LearningRateScheduler(anneal_lr),
#LearningRateTracker(),
ReduceLROnPlateau(monitor=monitor,
factor=0.2,
patience=2,
min_lr=1e-7,
mode='auto'),
CSVLogger(LOG_FPATH, separator=' ', append=True),
]
return callbacks
def train(self, train_part_df, validate_part_df, num_fold = 0):
"""
Keras Training
"""
print("-----DNN training-----")
DNN_Train_Data = self.DNN_DataSet(train_part_df, neg_aug = self.neg_aug)
DNN_validate_Data = self.DNN_DataSet(validate_part_df)
scores_list = []
callbacks = [
EarlyStopping(monitor='val_loss', patience=self.patience, verbose=0),
AccuracyEvaluation(validation_data=DNN_validate_Data, interval=1,
cand_class_id_emb_attr = self.cand_class_id_emb_attr,
eval_df = validate_part_df,
model_type = self.model_type,
class_id_dict = self.class_id_dict,
class_to_id = self.class_to_id,
scores = scores_list,
TTA = self.TTA,
img_model = self.img_flat_model,
flags = self.flags,
only_emb = self.only_emb)
]
if self.model_type == 'DEM_BC_AUG':
datagen = MixedImageDataGenerator(
rotation_range=self.rotation_range,
shear_range = self.shear_range,
zoom_range=self.zoom_range,
horizontal_flip=self.horizontal_flip)
datagen.fit(DNN_Train_Data[0])
h = self.model.fit_generator(
datagen.flow((DNN_Train_Data[0], DNN_Train_Data[1:]), None, batch_size=self.batch_size),
validation_data=(DNN_validate_Data, None), steps_per_epoch = DNN_Train_Data[0].shape[0]//self.batch_size,
epochs=self.epochs, shuffle=True, verbose = self.verbose, workers=2, use_multiprocessing=False,
callbacks=callbacks)
else:
h = self.model.fit(DNN_Train_Data, validation_data = (DNN_validate_Data, None),
epochs=self.epochs, batch_size = self.batch_size, shuffle=True, verbose = self.verbose, callbacks=callbacks)
score_df = pd.DataFrame(scores_list, columns = self.class_id_dict.keys())
score_df.index.name = 'Epoch'
score_df['Fold'] = num_fold
self.scores.append(score_df)
return self.model
def train_save_by_early_stop(recommend_model, model, train_data, test_data):
"""
训练时按照验证集的loss，early stopping得到最优的模型；最后基于该模型测试
:return:
"""
if_Train = True if new_Para.param.pairwise else False
train_labels = train_data[-1]
train_instances_tuple = recommend_model.get_instances(
*train_data[:-1], test_phase_flag=if_Train)
train_model = recommend_model.get_pairwise_model(
) if new_Para.param.pairwise else model
if new_Para.param.pairwise:
train_model.compile(optimizer=recommend_model.optimizer,
loss=lambda y_true, y_pred: y_pred,
metrics=['accuracy'])
else:
train_model.compile(optimizer=recommend_model.optimizer,
loss='binary_crossentropy',
metrics=['accuracy'])
early_stopping = EarlyStopping(monitor='val_loss',
patience=10,
verbose=2,
mode='min')
hist = train_model.fit([*train_instances_tuple],
train_labels,
epochs=new_Para.param.num_epochs,
batch_size=new_Para.param.small_batch_size,
callbacks=[early_stopping],
validation_split=new_Para.param.validation_split,
shuffle=True) #
model.save_weights(
dataset.crt_ds.new_model_para_path.format(recommend_model.model_dir,
'min_loss')) # !!! 改正
model_name = recommend_model.get_simple_name() + recommend_model.get_name(
) + '_min_loss'
save_loss_acc(hist, model_name, if_multi_epoch=True)
epoch_evaluate_result = evalute_by_epoch(recommend_model, model,
model_name, test_data)
return model
def train_model_gen(self,
model,
train_images,
train_labels,
val_images,
val_labels):
es = EarlyStopping(monitor='loss',
mode='min',
verbose=1,
patience=cfg.patience)
# modelcheckpoint
mc = ModelCheckpoint(super().get_path_to_save(),
monitor='acc',
mode='max',
save_best_only=True,
verbose=1)
# tensorborad
logdir = os.path.join(cfg.pfad_zu_logs, cfg.keras_model_name)
tb = TensorBoard(log_dir=logdir,
histogram_freq=0,
write_graph=True,
write_images=False)
callbak = [es, mc, tb]
self.compile_model(model)
# generate images for training
train_datagen, val_datagen = keras_data_gen()
train_generator = train_datagen.flow(train_images,
train_labels,
batch_size=self.__batch_size)
# rescale image validation
val_generator = val_datagen.flow(val_images,
val_labels,
batch_size=self.__batch_size)
history = model.fit_generator(train_generator,
epochs=self.__Num_epochs,
steps_per_epoch=len(train_images)//self.__batch_size,
validation_data=val_generator,
validation_steps=len(val_images)//self.__batch_size,
callbacks=callbak)
return history
def train_baseline_cnn(emb_layer, x_train, y_train, x_val, y_val, opt):
model = CNN(embedding_layer=emb_layer,
num_words=opt.transfer_n_words,
embedding_dim=opt.baseline_embed_dim,
filter_sizes=opt.cnn_filter_shapes,
feature_maps=opt.filter_sizes,
max_seq_length=opt.baseline_sent_len,
dropout_rate=opt.baseline_drop_out_ratio,
hidden_units=200,
nb_classes=2).build_model()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(),
metrics=['accuracy'])
# y_train = y_train.reshape(-1, 1)
# model = build_model(emb_layer, opt)
print(model.summary())
tb_call_back = TensorBoard(log_dir=f'{opt.tbpath}/baseline_cnn_{time()}',
histogram_freq=1,
write_graph=True,
write_images=True)
checkpoint = ModelCheckpoint("baseline_cnn.h5",
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
early_stopping = EarlyStopping(monitor='val_loss', patience=2)
history = model.fit(x_train,
y_train,
epochs=opt.baseline_epochs,
batch_size=opt.baseline_batchsize,
verbose=1,
validation_data=(x_val, y_val),
callbacks=[early_stopping, tb_call_back, checkpoint])
with open("CNN_train_baseline_history.txt", "w") as f:
print(history.history, file=f)
return model
def train(model: Sequential, epochs, train_x, train_y, test_x, test_y):
model.compile(optimizer=RMSProp(),
loss=losses.mean_squared_error,
metrics=['accuracy'])
print('running for %d epoches.' % epochs)
save_model = ModelCheckpoint(MODEL_NAME)
stop_model = EarlyStopping(min_delta=0.0002, patience=10)
print("start training")
model.fit(x=train_x,
y=train_y,
shuffle=True,
batch_size=32,
epochs=epochs,
validation_data=(test_x, test_y),
callbacks=[save_model, stop_model])
print("Done training, Now evaluating.")
loss, acc = model.evaluate(x=test_x, y=test_y)
print("Final loss: %3.2f Final accuracy: %3.2f" % (loss, acc))
def train(model: Sequential, train_x, train_y, epoches, test_x, test_y,
model_file):
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
print('running for %d epoches.' % epoches)
save_model = ModelCheckpoint(model_file)
stop_model = EarlyStopping(min_delta=0.001, patience=10)
model.fit(x=train_x,
y=train_y,
shuffle=True,
batch_size=60,
epochs=epoches,
validation_data=(test_x, test_y),
callbacks=[save_model, stop_model])
print("Done training, Now evaluating.")
loss, acc = model.evaluate(x=test_x, y=test_y)
print("Final loss: %3.2f Final accuracy: %3.2f" % (loss, acc))
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='min')
# 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_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2,
patience=2, min_lr=0.001)
callbacks_list = [save_best]
callbacks_list.append(reduce_lr)
if use_early_stop:
callbacks_list.append(early_stop)
start = datetime.datetime.now()
hist = self.model.fit_generator(
train_gen,
steps_per_epoch=steps,
epochs=epochs,
verbose=1,
validation_data=val_gen,
callbacks=callbacks_list,
validation_steps=int(steps * (1.0 - train_split) / train_split))
end = datetime.datetime.now()
print('TRAIN TIME:',end-start)
return hist
def train(self):
#下面使用高阶语句构建模型
model = self.build_model()
model.compile(loss='categorical_crossentropy',
# optimizer=RMSprop(lr=0.001),
optimizer = Adam(lr=self.learn_rate),
# optimizer=tf.train.AdamOptimizer(learning_rate=self.learn_rate),
metrics=['accuracy'])
callbacks = [EarlyStopping(
monitor='val_loss', patience=2)]
# All images will be rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)
# Flow training images in batches of 20 using train_datagen generator
train_generator = train_datagen.flow_from_directory(
self.train_path, # This is the source directory for training images
target_size=(DIVIDE_IMAGE_HEIGHT,DIVIDE_IMAGE_WEIGHT),
color_mode='grayscale',
batch_size=BATCH_SIZE,
# Since we use binary_crossentropy loss, we need binary labels
class_mode='categorical')
# Flow validation images in batches of 20 using test_datagen generator
validation_generator = test_datagen.flow_from_directory(
self.valid_path,
target_size=(DIVIDE_IMAGE_HEIGHT,DIVIDE_IMAGE_WEIGHT),
color_mode='grayscale',
batch_size=BATCH_SIZE,
class_mode='categorical')
history = model.fit_generator(
train_generator,
epochs=1000,
callbacks=callbacks,
validation_data=validation_generator,
verbose=2)
self.model = model
model.save(self.model_path)
def get_call_back(lr, batch_size):
"""
定义call back
:return:
"""
text = '{}-{}-{}'.format(cfg.base_model_name, batch_size, lr)
checkpoint = ModelCheckpoint(filepath='/tmp/ssd-' + text + '.{epoch:03d}.h5',
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True,
save_freq='epoch'
)
reduce = ReduceLROnPlateau(monitor='val_loss', factor=0.2, min_delta=2e-3,
patience=10, min_lr=1e-5)
stop = EarlyStopping(monitor='val_loss', patience=20)
# scheduler = LearningRateScheduler(lr_schedule(epochs, lr))
log = TensorBoard(log_dir='log-{}-{}'.format(text,
time.strftime("%Y%m%d", time.localtime())))
return [checkpoint, reduce, stop, log]
def partial_training(model, train_data, val_data, epochs):
for i in range(len(model.layers)):
model.layers[i].trainable = True
l_r = 0.00005
model.compile(optimizer=Adam(lr=l_r),
loss=dual_loss_weighted,
metrics=[BinaryAccuracy()])
hist_1 = model.fit(x=train_data,
validation_data=val_data,
epochs=epochs,
callbacks=[
EarlyStopping(monitor='val_loss',
patience=10,
restore_best_weights=True),
ReduceLROnPlateau(patience=4)
])
return model
def train_autoencoder(self, epochs):
"""Function to train autoencoder
:param epochs: Number of epochs
:type epochs: int
"""
self.logger.info("Training autoencoder")
callbacks = [
EarlyStopping(monitor='loss', patience=10),
ModelCheckpoint('autoencoder_weights.hdf5',
monitor='loss',
save_best_only=True,
verbose=1)
]
generator = self._get_generator(self.dataset_dir,
self.batch_size,
data_type=1)
self.autoencoder.fit(
generator, epochs=epochs,
callbacks=callbacks) # TODO: Add callback to save logs
def retrainModel():
loadDataset()
shuffleAndSplitDataset()
dataAugmentation()
convert2NPArray()
cb = EarlyStopping(monitor='acc', min_delta=0.005, patience=0)
model = load_model('classifier/model.keras')
# model.fit(images_train, labels_train, batch_size=5, epochs=15, verbose=1, validation_split=0.1, callbacks=[cb])
model.fit(images_train,
labels_train,
batch_size=5,
epochs=15,
verbose=1,
validation_split=0.1)
model.save('classifier/model.keras')
# Evaluación del modelo
result = model.evaluate(images_test, labels_test, verbose=0)
print('Testing set accuracy:', result[1])
testModel()
def train(self):
start = time.time()
early_stop = EarlyStopping(monitor='val_loss', patience=self.early_stop_patience, restore_best_weights=True)
tensorboard = TensorBoard(log_dir=f"{os.environ['WORKSPACE']}/logs/{self.seq_info}__{self.get_model_info_str()}__{datetime.now().timestamp()}")
# Train model
self.training_history = self.model.fit(
self.train_x, self.train_y,
batch_size=self.batch_size,
epochs=self.max_epochs,
validation_data=(self.validation_x, self.validation_y),
callbacks=[tensorboard, early_stop],
shuffle=True
)
# Score model
self.score = self.model.evaluate(self.validation_x, self.validation_y, verbose=0)
self.score = {out: self.score[i] for i, out in enumerate(self.model.metrics_names)}
print('Scores:', self.score)
end = time.time()
self.train_time = end - start
def train(self,
x_train,
y_train,
learning_rate,
epochs,
batch_size,
tb_logs_dir=None,
verbose=False):
early_stopping_callback = EarlyStopping(monitor="val_loss",
patience=25)
callbacks = [early_stopping_callback]
if bool(tb_logs_dir):
date_time = datetime.now().strftime('%Y-%m-%d-%H%M%S')
log_name = os.path.join(tb_logs_dir,
"{}_{}".format("transfer_net", date_time))
# defining callbacks for training
tensorboard_callback = TensorBoard(log_dir=log_name,
write_graph=True,
write_images=True)
callbacks += [tensorboard_callback]
x_train, x_val, y_train, y_val = train_test_split(x_train,
y_train,
train_size=0.8,
random_state=1)
y_train = tf.keras.utils.to_categorical(y_train,
self.num_output_classes)
y_val = tf.keras.utils.to_categorical(y_val, self.num_output_classes)
self.model.compile(loss="categorical_crossentropy",
optimizer=keras.optimizers.Adam(lr=learning_rate),
metrics=['accuracy', f1_score])
self.hist = self.model.fit(x_train,
y_train,
epochs=epochs,
batch_size=batch_size,
verbose=verbose,
callbacks=callbacks,
validation_data=(x_val, y_val))
def fit(self, train_data, train_label, validation_data, validation_label,
batch_size, nb_epochs):
# TODO exploit 'sample_weight'
# TODO implement resumed training with 'initial_epoch'
# TODO add documentation
callbacks = []
# define checkpoints
if self.logdir is not None:
# create checkpoint callback
checkpoint_path = os.path.join(self.logdir, "cp-{epoch}.ckpt")
cp_callback = ModelCheckpoint(filepath=checkpoint_path, verbose=1)
callbacks.append(cp_callback)
# TODO debug early stopping
# define early stopping
early_stop = EarlyStopping(monitor="val_categorical_accuracy",
min_delta=0,
patience=5,
verbose=2)
callbacks.append(early_stop)
# fit model
self.history = self.model.fit(x=train_data,
y=train_label,
batch_size=batch_size,
epochs=nb_epochs,
verbose=2,
callbacks=callbacks,
validation_data=(validation_data,
validation_label),
shuffle=True,
sample_weight=None,
initial_epoch=0)
# update model attribute
self.trained = True
return
def __init__(self,
epochs=5,
batch_size=16,
lr=1e-5,
optimizer='sgd',
callbacks=EarlyStopping(patience=3),
metrics=['accuracy'],
input_shape=(128, 128, 3),
n_output=3,
loss='mean_squared_error'):
self.epochs = epochs
self.batch_size = batch_size
self.lr = lr
self.callbacks = callbacks
self.metrics = metrics
self.input_shape = input_shape
self.n_output = n_output
self.otpimizer = optimizer
self.loss = loss
self.instantiate_model()
def train(self,
model_path: str,
train_data: 'BatchSequence',
train_steps: int,
batch_size: int,
validation_data: 'BatchSequence',
validation_steps: int,
epochs: int,
verbose: int = 1,
min_delta: float = .0005,
patience: int = 5) -> tf.keras.callbacks.History:
"""
trains the model
"""
model = self._get_train_model()
self.compile()
callbacks = [
EarlyStopping(monitor='val_loss',
patience=patience,
min_delta=min_delta),
ModelCheckpoint(monitor='val_loss',
filepath=model_path,
save_best_only=True,
verbose=verbose)]
history: Dict[str, Any] = model.fit(
x=train_data,
steps_per_epoch=train_steps,
batch_size=batch_size,
callbacks=callbacks,
validation_data=validation_data,
validation_steps=validation_steps,
epochs=epochs,
verbose=verbose,
workers=1,
use_multiprocessing=False
)
return history
def train(model, train_x, train_y, epochs, test_x, test_y, model_file):
model.compile(loss='categorical_crossentropy',
optimizer='Adadelta',
metrics=['accuracy'])
print("Running for {0} epochs.".format(epochs))
savemodel = ModelCheckpoint(model_file)
stopmodel = EarlyStopping(min_delta=0.001, patience=10)
model.fit(x=train_x,
y=train_y,
shuffle=True,
batch_size=256,
epochs=epochs,
validation_data=(test_x, test_y),
callbacks=[savemodel, stopmodel])
print("Done training. Now evaluating.")
loss, acc = model.evaluate(x=test_x, y=test_y)
print("Final loss:{0} Final accuracy:{1}".format(loss, acc))
def __setup_callbacks(self) -> List:
"""
Sets up the callbacks for training
:return: the early stopping schedule, tensorboard data and the checkpointer
"""
# Create a folder for the model log of the current experiment
weights_log_path = os.path.join(self.__current_experiment_path,
'weights')
# Set up the callback to save the best weights after each epoch
checkpointer = ModelCheckpoint(filepath=os.path.join(
weights_log_path, 'weights.{epoch:02d}-{val_loss:.2f}.hdf5'),
verbose=0,
save_best_only=True,
save_weights_only=True,
monitor='val_loss',
mode='min')
# Set up Tensorboard
tensorboard = TensorBoard(log_dir=os.path.join(
self.__current_experiment_path, 'tensorboard'),
write_graph=True,
histogram_freq=0,
write_grads=True,
write_images=False,
batch_size=self._params.batch_size,
update_freq=self._params.batch_size)
# Set up early stopping to interrupt the training if val_loss is not increasing after n epochs
early_stopping = EarlyStopping(monitor='val_loss',
patience=25,
mode='min')
csv_logger = CSVLogger(os.path.join(self.__current_experiment_path,
"training.csv"),
append=True)
return [early_stopping, tensorboard, checkpointer, csv_logger]
def usingCnnModel(training_data, training_labels, val_data, val_labels):
"""
This is using the CNN model and setting it up.
Args:
training_data(numpy arrays): This is the numpy array of the training data.
training_labels(numpy arrays): This is the numpy array of the training labels.
val_data(numpy arrays): This is the numpy array of the validation data.
val_labels(numpy arrays): This is the numpy array of the validation labels.
Returns:
history(history): This is the history of the classifier.
classifier(sequential): This is the cnn model classifier fitted to the training data and labels.
"""
model_checkpoint = ModelCheckpoint(
filepath=os.path.abspath('best_weights.h5'),
monitor=monitor_model_checkpoint,
save_best_only=True)
early_stopping = EarlyStopping(
monitor=monitor_early_stopping,
patience=patience_num) # original patience =3
classifier = buildClassifier()
callbacks_array = []
if use_early_stopping:
callbacks_array.append(early_stopping)
if use_model_checkpoint:
callbacks_array.append(model_checkpoint)
print(len(training_data))
history = classifier.fit(
training_data,
training_labels,
epochs=epochs,
validation_data=(val_data, val_labels),
callbacks=callbacks_array,
batch_size=batch_size
# steps_per_epoch=int(len(training_data) / batch_size),
)
return history, classifier
def run_loss(args):
data = args['data']
# For each run we want to get a new random balance
data.process()
# split, train, test
dense_out = len(data.labels[0])
# split for all models
X_train_, X_test_, Y_train, Y_test = train_test_split(data.text, data.labels,
test_size=0.20, random_state=42)
print(args)
# Prep data for the LSTM model
# This currently will train the tokenizer on all text (unbalanced and train/test)
# It would be nice to replace this with a pretrained embedding on larger text
tokenizer = Tokenizer(num_words=int(args['max_features']), split=' ')
tokenizer.fit_on_texts(data.all_text)
X_train = tokenizer.texts_to_sequences(X_train_)
X_train = pad_sequences(X_train, maxlen=max_len)
X_test = tokenizer.texts_to_sequences(X_test_)
X_test = pad_sequences(X_test, maxlen=max_len)
# Train the LSTM model
lstm_model = simple_lstm(int(args['max_features']), dense_out, X_train.shape[1],
int(args['embed_dim']), int(args['lstm_out']), args['dropout'])
if args['epochs'] == 0:
args['epochs'] = 1
es = EarlyStopping(monitor='val_acc', min_delta=0, patience=6, verbose=0, mode='max')
model_hist = lstm_model.fit(X_train, Y_train, epochs=args['epochs'], batch_size=batch_size,
verbose=1, validation_data=(X_test, Y_test), callbacks=[es])
lstm_acc = model_hist.history['val_acc'][-1]
print("LSTM model accuracy ", lstm_acc)
# This minimizes, so the maximize we have to take the inverse :)
return 1 - lstm_acc
def train_keras_model(model, input_data, labels, dev_input_data, dev_labels,
batch_size, epochs, steps_per_epochs, validation_steps,
weights_filename):
'''
Method used to train the singletask model implemented and compiled.
:param model: the singletask model implemented and compiled
:param input_data: arrays of arrays of id tokens
:param labels: array of arrays of id tokens
:param dev_input_data: array of array of id tokens containing data from dev set
:param dev_labels: array of array of id tokens containing data from dev set
:param batch_size: integer that indicates the size of batch
:param epochs: integer that indicates how much epochs to use to train the model
:param steps_per_epochs: integer that indicates how much step per epochs to use to train the model
:param validation_steps: integer that indicates how much validation steps per epoch to yse to validate the model
:param weights_filename: filepath where save the weights of the model
:return: the statistics of the model after that the training is completed.
'''
early_stopping = EarlyStopping(monitor="val_loss", patience=2)
checkpointer = ModelCheckpoint(filepath="drive/My Drive/" +
weights_filename + ".hdf5",
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
cbk = [early_stopping, checkpointer]
print("\nStarting training...")
stats = model.fit_generator(batch_generator(input_data, labels,
batch_size),
steps_per_epoch=steps_per_epochs,
epochs=epochs,
callbacks=cbk,
verbose=1,
validation_data=batch_generator(
dev_input_data, dev_labels, batch_size),
validation_steps=validation_steps)
print("Training complete.\n")
return stats
def get_agent(name_of_model="model-3_200-50-3"):
if False: # is exist
return keras.models.load_model('./saved_model.pb')
else:
x_train = np.asarray(pickle.load(open("X.p", "rb")))
print(x_train.shape)
y_train = np.asarray(pickle.load(open("Y.p", "rb")))
nb_class = 3
y_train = keras.utils.to_categorical(y_train, nb_class)
model = keras.Sequential()
model.add(layers.Dense(200, input_dim=68 * 40, activation='sigmoid'))
model.add(layers.Dense(50, activation='sigmoid'))
model.add(layers.Dense(3, activation='softmax'))
model.summary()
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
from tensorflow.python.keras.callbacks import EarlyStopping
# need to understand the f**k
ourCallback = EarlyStopping(monitor='val_accuracy',
min_delta=0.0001,
patience=20,
verbose=0,
mode='auto',
baseline=None,
restore_best_weights=False)
model.fit(x_train,
y_train,
epochs=100,
batch_size=128,
validation_split=0.2,
callbacks=[ourCallback])
# model.fit(x_train, y_train, epochs=100, validation_split=0.33)
#model.fit(x_train, y_train, epochs=100)
model.save(".")
return model
