def main():
config = get_args()
if config.load_model is not None:
model, features, target_feature = load_model(config)
data_loader = DataLoader(config, split=False, pretrained=True)
data_loader.setup(features, target_feature)
evaluator = Evaluator(config)
evaluator.evaluate_pretrianed(model, data_loader, target_feature)
exit(0)
if config.load_checkpoint:
auc, acc, pred, classes, completed = load_checkpoint(config)
data_loader = DataLoader(config, split=not config.active_features)
evaluator = Evaluator(config)
trainer = Trainer(config, data_loader, evaluator)
if config.load_checkpoint:
evaluator.set_checkpoint(auc, acc, pred, classes)
trainer.set_completed(completed)
trainer.train()
if not config.active_features:
print(f"AUC ({config.evaluation_mode}): {evaluator.get_auc()}")
print(f"Accuracy ({config.evaluation_mode}): {evaluator.get_accuracy()}")
evaluator.save(data_loader.getFeatures())
display_runtime(config)
shuffle=True,
num_workers=cpu_count())
criterion = EvaluatorLoss().cuda()
optimizer = optim.Adam(evaluator.parameters(), lr=4e-4, weight_decay=1e-5)
epochs = 5
print(f"number of batches = {len(dataset) // batch_size}")
print("Begin Training")
for epoch in range(epochs):
start = time.time()
for i, (images, captions, other_captions) in enumerate(dataloader, 0):
print(f"Batch = {i + 1}")
images, captions, other_captions = Variable(images).cuda(
), Variable(captions).cuda(), Variable(other_captions).cuda()
temp = images.shape[0]
captions = pack_padded_sequence(captions, [18] * temp, True)
other_captions = pack_padded_sequence(other_captions, [18] * temp,
True)
generator_outputs = generator.sample_with_embedding(images)
evaluator_outputs = evaluator(images, captions)
generator_outputs = evaluator(images, generator_outputs)
other_outputs = evaluator(images, other_captions)
loss = criterion(evaluator_outputs, generator_outputs,
other_outputs)
loss.backward()
optimizer.step()
end = time.time()
print(f"Batch Time {end - start}")
start = end
print(f"Epoch = {epoch + 1}")
evaluator.save()
