def test_loss_handler_validation(self):
device = tu.get_gpu_device_if_available()
model = eu.get_basic_model(10, 10, 10).to(device)
loss_func = nn.BCEWithLogitsLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-4)
scheduler = KerasDecay(optimizer, 0.0001, last_step=-1)
metrics = BinaryAccuracyWithLogits(name='acc')
callbacks = [
StatsPrint()
]
data_loader = eu.examples_data_generator(10, 10, 10)
data_loader_steps = 100
num_epochs = 5
verbose = 0
trainer = Trainer(model=model,
device=device,
loss_func=loss_func,
optimizer=optimizer,
scheduler=scheduler,
metrics=metrics,
train_data_loader=data_loader,
val_data_loader=data_loader,
train_steps=data_loader_steps,
val_steps=data_loader_steps,
callbacks=callbacks,
name='Trainer-Test')
self.assertRaises(ValueError, trainer.train, num_epochs, verbose)
trainer.callbacks.append(LossOptimizerHandler())
trainer.train(num_epochs, verbose=0)
def test_save_and_load(self):
gu.seed_all(42)
save_to_dir = os.path.dirname(__file__) + '/trainer_checkpoint/'
trainer_file_name = 'trainer'
device = tu.get_gpu_device_if_available()
model = eu.get_basic_model(10, 10, 10).to(device)
loss_func = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-4)
scheduler = KerasDecay(optimizer, 0.0001, last_step=-1)
metrics = CategoricalAccuracyWithLogits(name='acc')
callbacks = [
LossOptimizerHandler(),
ModelCheckPoint(checkpoint_dir=save_to_dir,
checkpoint_file_name=trainer_file_name,
callback_monitor=CallbackMonitor(monitor_type=MonitorType.LOSS,
stats_type=StatsType.VAL,
monitor_mode=MonitorMode.MIN),
save_best_only=False,
save_full_trainer=True,
verbose=0),
SchedulerStep(apply_on_phase=Phase.BATCH_END, apply_on_states=State.TRAIN),
StatsPrint()
]
data_loader = eu.examples_data_generator(10, 10, 10, category_out=True)
data_loader_steps = 100
num_epochs = 5
trainer = Trainer(model=model,
device=device,
loss_func=loss_func,
optimizer=optimizer,
scheduler=scheduler,
metrics=metrics,
train_data_loader=data_loader,
val_data_loader=data_loader,
train_steps=data_loader_steps,
val_steps=data_loader_steps,
callbacks=callbacks,
name='Trainer-Test')
trainer.train(num_epochs, verbose=0)
loaded_trainer = Trainer.load_trainer(dir_path=save_to_dir,
file_name=trainer_file_name + f'_epoch_{num_epochs}',
model=model,
device=device,
loss_func=loss_func,
optimizer=optimizer,
scheduler=scheduler,
train_data_loader=data_loader,
val_data_loader=data_loader,
train_steps=data_loader_steps,
val_steps=data_loader_steps)
self.assertEqual(loaded_trainer.epoch, trainer.epoch)
self.assertListEqual(tu.get_lrs_from_optimizer(loaded_trainer.optimizer), tu.get_lrs_from_optimizer(trainer.optimizer))
self.assertEqual(loaded_trainer.callbacks[1].monitor._get_best(), trainer.callbacks[1].monitor._get_best())
def test_save_and_predict(self):
save_to_dir = os.path.dirname(__file__) + '/trainer_checkpoint/'
checkpoint_file_name = 'checkpoint'
trainer_file_name = 'trainer'
device = tu.get_gpu_device_if_available()
model = TestModel().to(device)
loss_func = nn.BCEWithLogitsLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-4)
scheduler = None
metrics = BinaryAccuracyWithLogits(name='acc')
callbacks = [
LossOptimizerHandler(),
ModelCheckPoint(checkpoint_dir=save_to_dir,
checkpoint_file_name=checkpoint_file_name,
callback_monitor=CallbackMonitor(
monitor_type=MonitorType.LOSS,
stats_type=StatsType.VAL,
monitor_mode=MonitorMode.MIN),
save_best_only=True,
save_full_trainer=False),
]
data_loader = data_generator()
data_loader_steps = 100
num_epochs = 5
trainer = Trainer(model=model,
device=device,
loss_func=loss_func,
optimizer=optimizer,
scheduler=scheduler,
metrics=metrics,
train_data_loader=data_loader,
val_data_loader=data_loader,
train_steps=data_loader_steps,
val_steps=data_loader_steps,
callbacks=callbacks,
name='Predictor-Trainer-Test')
x1_x2, y = next(data_loader)
_ = trainer.predict_batch(x1_x2) # JUST TO CHECK THAT IT FUNCTIONS
sample = [x1_x2[0][0], x1_x2[1][0]]
# PREDICT BEFORE TRAIN
sample_prediction_before_train = trainer.predict_sample(sample)
trainer.train(num_epochs, verbose=0)
# PREDICT AFTER TRAIN
sample_prediction_from_trainer = trainer.predict_sample(sample)
# SAVE THE TRAINER
trainer.save_trainer(save_to_dir, trainer_file_name)
#-----------------------------------------------#
# CREATE PREDICTOR FROM CURRENT TRAINER
#-----------------------------------------------#
predictor_from_trainer = Predictor.from_trainer(trainer)
# PREDICT FROM PREDICTOR
sample_prediction_from_predictor = predictor_from_trainer.predict_sample(
sample)
self.assertFalse(
(sample_prediction_before_train == sample_prediction_from_trainer
).all())
self.assertTrue(
(sample_prediction_from_predictor == sample_prediction_from_trainer
).all())
#-----------------------------------------------#
# LOAD MODEL CHECKPOINT AS NEW PREDICTOR
#-----------------------------------------------#
fresh_device = tu.get_gpu_device_if_available()
fresh_model = TestModel().to(fresh_device)
loaded_predictor = Predictor.from_checkpoint(
save_to_dir, checkpoint_file_name + '_best_only', fresh_model,
fresh_device)
# PREDICT AFTER LOAD
sample_prediction_from_loaded_predictor = loaded_predictor.predict_sample(
sample)
self.assertFalse(
(sample_prediction_before_train == sample_prediction_from_trainer
).all())
self.assertTrue((sample_prediction_from_loaded_predictor ==
sample_prediction_from_trainer).all())
#-----------------------------------------------#
# LOAD TRAINER CHECKPOINT AS NEW PREDICTOR
#-----------------------------------------------#
fresh_device = tu.get_gpu_device_if_available()
fresh_model = TestModel().to(fresh_device)
loaded_predictor = Predictor.from_checkpoint(save_to_dir,
trainer_file_name,
fresh_model, fresh_device)
# PREDICT AFTER LOAD
sample_prediction_from_loaded_predictor = loaded_predictor.predict_sample(
sample)
self.assertFalse(
(sample_prediction_before_train == sample_prediction_from_trainer
).all())
self.assertTrue((sample_prediction_from_loaded_predictor ==
sample_prediction_from_trainer).all())