def main():
"""Print performance metrics for model at specified epoch."""
# Data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target",
batch_size=config("cnn.batch_size"),
)
# Model
model = Target()
# define loss function
criterion = torch.nn.CrossEntropyLoss()
# Attempts to restore the latest checkpoint if exists
print("Loading cnn...")
model, start_epoch, stats = restore_checkpoint(model,
config("cnn.checkpoint"))
axes = utils.make_training_plot()
# Evaluate the model
evaluate_epoch(
axes,
tr_loader,
va_loader,
te_loader,
model,
criterion,
start_epoch,
stats,
include_test=True,
update_plot=False,
)
def main():
# data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('autoencoder.classifier.num_classes'))
ae_classifier = AutoencoderClassifier(config('autoencoder.ae_repr_dim'),
config('autoencoder.classifier.num_classes'))
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(ae_classifier.parameters(),
lr=config('autoencoder.classifier.learning_rate'))
# freeze the weights of the encoder
for name, param in ae_classifier.named_parameters():
if 'fc1.' in name or 'fc2.' in name:
param.requires_grad = False
# Attempts to restore the latest checkpoint if exists
print('Loading autoencoder...')
ae_classifier, _, _ = restore_checkpoint(ae_classifier,
config('autoencoder.checkpoint'), force=True, pretrain=True)
print('Loading autoencoder classifier...')
ae_classifier, start_epoch, stats = restore_checkpoint(ae_classifier,
config('autoencoder.classifier.checkpoint'))
axes = utils.make_cnn_training_plot(name='Autoencoder Classifier')
# Evaluate the randomly initialized model
_evaluate_epoch(axes, tr_loader, va_loader, ae_classifier, criterion,
start_epoch, stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('autoencoder.classifier.num_epochs')):
# Train model
_train_epoch(tr_loader, ae_classifier, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, ae_classifier, criterion,
epoch + 1, stats)
# Save model parameters
save_checkpoint(ae_classifier, epoch + 1,
config('autoencoder.classifier.checkpoint'), stats)
print('Finished Training')
with torch.no_grad():
y_true, y_pred = [], []
correct, total = 0, 0
running_loss = []
for X, y in va_loader:
output = ae_classifier(X)
predicted = predictions(output.data)
y_true.extend(y)
y_pred.extend(predicted)
print("Validation data accuracies:")
print(confusion_matrix(y_true, y_pred))
# Keep plot open
utils.save_cnn_training_plot(name='ae_clf')
utils.hold_training_plot()
def main():
"""Train transfer learning model and display training plots.
Train four different models with {0, 1, 2, 3} layers frozen.
"""
# data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target",
batch_size=config("target.batch_size"),
)
freeze_none = Target()
print("Loading source...")
freeze_none, _, _ = restore_checkpoint(
freeze_none, config("source.checkpoint"), force=True, pretrain=True
)
freeze_one = copy.deepcopy(freeze_none)
freeze_two = copy.deepcopy(freeze_none)
freeze_three = copy.deepcopy(freeze_none)
freeze_layers(freeze_one, 1)
freeze_layers(freeze_two, 2)
freeze_layers(freeze_three, 3)
train(tr_loader, va_loader, te_loader, freeze_none, "./checkpoints/target0/", 0)
train(tr_loader, va_loader, te_loader, freeze_one, "./checkpoints/target1/", 1)
train(tr_loader, va_loader, te_loader, freeze_two, "./checkpoints/target2/", 2)
train(tr_loader, va_loader, te_loader, freeze_three, "./checkpoints/target3/", 3)
def main():
# Data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('cnn.num_classes'))
# Model
model = CNN()
# TODO: define loss function, and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-4)
#
print('Number of float-valued parameters:', count_parameters(model))
# Attempts to restore the latest checkpoint if exists
print('Loading cnn...')
model, start_epoch, stats = restore_checkpoint(model,
config('cnn.checkpoint'))
axes = utils.make_cnn_training_plot()
# Evaluate the randomly initialized model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion, start_epoch,
stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('cnn.num_epochs')):
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion,
epoch + 1, stats)
# Save model parameters
save_checkpoint(model, epoch + 1, config('cnn.checkpoint'), stats)
print('Finished Training')
y_true, y_pred = [], []
correct, total = 0, 0
running_loss = []
for X, y in va_loader:
with torch.no_grad():
output = model(X)
predicted = predictions(output.data)
y_true.extend(y)
y_pred.extend(predicted)
total += y.size(0)
correct += (predicted == y).sum().item()
running_loss.append(criterion(output, y).item())
print("Validation data accuracies:")
print(confusion_matrix(y_true, y_pred))
# Save figure and keep plot open
utils.save_cnn_training_plot()
utils.hold_training_plot()
def main():
# Data loaders
tr_loader, va_loader, te_loader, get_semantic_labels = get_train_val_test_loaders(
num_classes=config('cnn.num_classes'))
# Model
model = CNN()
# TODO: define loss function, and optimizer
params = list(model.conv1.parameters()) + list(
model.conv2.parameters()) + list(model.conv3.parameters())
params = params + list(model.fc1.parameters()) + list(
model.fc2.parameters()) + list(model.fc3.parameters())
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params, lr=0.0001)
#
print('Number of float-valued parameters:', count_parameters(model))
# Attempts to restore the latest checkpoint if exists
print('Loading cnn...')
model, start_epoch, stats = restore_checkpoint(model,
config('cnn.checkpoint'))
fig, axes = utils.make_cnn_training_plot()
# Evaluate the randomly initialized model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion, start_epoch,
stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('cnn.num_epochs')):
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion,
epoch + 1, stats)
# Save model parameters
save_checkpoint(model, epoch + 1, config('cnn.checkpoint'), stats)
print('Finished Training')
model, _, _ = restore_checkpoint(model, config('cnn.checkpoint'))
dataset = get_data_by_label(va_loader)
evaluate_cnn(dataset, model, criterion, get_semantic_labels)
# Save figure and keep plot open
utils.save_cnn_training_plot(fig)
utils.hold_training_plot()
def main():
"""Create confusion matrix and save to file."""
tr_loader, va_loader, te_loader, semantic_labels = get_train_val_test_loaders(
task="source", batch_size=config("source.batch_size"))
model = Source()
print("Loading source...")
model, epoch, stats = restore_checkpoint(model,
config("source.checkpoint"))
sem_labels = "0 - Samoyed\n1 - Miniature Poodle\n2 - Saint Bernard\n3 - Great Dane\n4 - Dalmatian\n5 - Chihuahua\n6 - Siberian Husky\n7 - Yorkshire Terrier"
# Evaluate model
plot_conf(va_loader, model, sem_labels, "conf_matrix.png")
def main(uniqname):
# data loaders
_, _, te_loader, get_semantic_label = get_train_val_test_loaders(
num_classes=config('challenge.num_classes'))
model = Challenge()
# Attempts to restore the latest checkpoint if exists
model, _, _ = restore_checkpoint(model, config('challenge.checkpoint'))
# Evaluate model
model_pred = predict_challenge(te_loader, model)
print('saving challenge predictions...\n')
model_pred = [get_semantic_label(p) for p in model_pred]
pd_writer = pd.DataFrame(model_pred, columns=['predictions'])
pd_writer.to_csv(uniqname + '.csv', index=False, header=False)
def main():
# data loaders
_, va_loader, _, get_semantic_label = get_train_val_test_loaders(
num_classes=config('autoencoder.num_classes'))
dataset = get_data_by_label(va_loader)
ae = Autoencoder(config('autoencoder.ae_repr_dim'))
naive = NaiveRecon(config('autoencoder.naive_scale'))
# Restore the latest checkpoint of autoencoder
print('Loading autoencoder...')
ae, _, _ = restore_checkpoint(ae,
config('autoencoder.checkpoint'),
force=True)
# Visualize
visualize_autoencoder(dataset, get_semantic_label, ae, naive)
def main():
# Data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('cnn.num_classes'))
# Model
model = CNN()
# TODO: define loss function, and optimizer
import torch.optim as op
import torch.nn as nn
criterion = nn.CrossEntropyLoss()
optimizer = op.Adam(model.parameters(), lr=config('cnn.learning_rate'))
#
print('Number of float-valued parameters:', count_parameters(model))
# Attempts to restore the latest checkpoint if exists
print('Loading cnn...')
model, start_epoch, stats = restore_checkpoint(model,
config('cnn.checkpoint'))
axes = utils.make_cnn_training_plot()
# Evaluate the randomly initialized model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion, start_epoch,
stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('cnn.num_epochs')):
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion, epoch+1,
stats)
# Save model parameters
save_checkpoint(model, epoch+1, config('cnn.checkpoint'), stats)
print('Finished Training')
# Save figure and keep plot open
utils.save_cnn_training_plot()
utils.hold_training_plot()
def main():
# data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('autoencoder.num_classes'))
# Model
model = Autoencoder(config('autoencoder.ae_repr_dim'))
# TODO: define loss function, and optimizer
criterion = torch.nn.MSELoss()
params = list(model.pool.parameters()) + list(
model.fc1.parameters()) + list(model.fc2.parameters())
params = params + list(model.fc3.parameters()) + list(
model.deconv.parameters())
optimizer = torch.optim.Adam(params, lr=0.0001)
#
# Attempts to restore the latest checkpoint if exists
print('Loading autoencoder...')
model, start_epoch, stats = restore_checkpoint(
model, config('autoencoder.checkpoint'))
fig, axes = utils.make_ae_training_plot()
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('autoencoder.num_epochs')):
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion,
epoch + 1, stats)
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
_train_epoch(te_loader, model, criterion, optimizer)
# Save model parameters
save_checkpoint(model, epoch + 1, config('autoencoder.checkpoint'),
stats)
print('Finished Training')
# Save figure and keep plot open
utils.save_ae_training_plot(fig)
utils.hold_training_plot()
def main():
# data loaders
_, va_loader, _, get_semantic_label = get_train_val_test_loaders(
num_classes=config('autoencoder.num_classes'))
dataset = get_data_by_label(va_loader)
model = Autoencoder(config('autoencoder.ae_repr_dim'))
criterion = torch.nn.MSELoss()
# Attempts to restore the latest checkpoint if exists
print('Loading autoencoder...')
#model, start_epoch, _ = restore_checkpoint(model,
#config('autoencoder.checkpoint'))
#evaluate_autoencoder(dataset, get_semantic_label, model, criterion)
# Evaluate model
model = CNN()
model, start_epoch, _ = restore_checkpoint(model, config('cnn.checkpoint'))
evaluate_autoencoder(dataset, get_semantic_label, model, criterion)
def main():
# data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('challenge.num_classes'))
# TODO: define model, loss function, and optimizer
model = Challenge_try()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-4)
#
# Attempts to restore the latest checkpoint if exists
print('Loading challenge...')
model, start_epoch, stats = restore_checkpoint(
model, config('challenge.checkpoint'))
fig, axes = utils.make_cnn_training_plot(name='Challenge')
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion, start_epoch,
stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('challenge.num_epochs')):
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, model, criterion,
epoch + 1, stats)
# Save model parameters
save_checkpoint(model, epoch + 1, config('challenge.checkpoint'),
stats)
print('Finished Training')
# Keep plot open
utils.save_cnn_training_plot(fig, name='challenge')
utils.hold_training_plot()
def main():
# data loaders
_, va_loader, _, get_semantic_label = get_train_val_test_loaders(
num_classes=config('autoencoder.num_classes'))
dataset = get_data_by_label(va_loader)
model = Autoencoder(config('autoencoder.ae_repr_dim'))
criterion = torch.nn.MSELoss()
# Attempts to restore the latest checkpoint if exists
print('Loading autoencoder...')
model, start_epoch, _ = restore_checkpoint(
model, config('autoencoder.checkpoint'))
# Evaluate model
evaluate_autoencoder(dataset, get_semantic_label, model, criterion)
criterion = metrics.accuracy_score()
evaluate_autoencoder(dataset, get_semantic_label, model, criterion)
# Report performance
report_validation_performance(dataset, get_semantic_label, model,
criterion)
def main():
"""Train CNN and show training plots."""
# Data loaders
if check_for_augmented_data("./data"):
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target", batch_size=config("cnn.batch_size"), augment=True)
else:
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target",
batch_size=config("cnn.batch_size"),
)
# Model
model = Target()
# TODO: define loss function, and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
#
print("Number of float-valued parameters:", count_parameters(model))
# Attempts to restore the latest checkpoint if exists
print("Loading cnn...")
model, start_epoch, stats = restore_checkpoint(model,
config("cnn.checkpoint"))
axes = utils.make_training_plot()
# Evaluate the randomly initialized model
evaluate_epoch(axes, tr_loader, va_loader, te_loader, model, criterion,
start_epoch, stats)
# initial val loss for early stopping
prev_val_loss = stats[0][1]
# TODO: define patience for early stopping
patience = 5
curr_patience = 0
#
# Loop over the entire dataset multiple times
# for epoch in range(start_epoch, config('cnn.num_epochs')):
epoch = start_epoch
while curr_patience < patience:
# Train model
train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
evaluate_epoch(axes, tr_loader, va_loader, te_loader, model, criterion,
epoch + 1, stats)
# Save model parameters
save_checkpoint(model, epoch + 1, config("cnn.checkpoint"), stats)
# update early stopping parameters
curr_patience, prev_val_loss = early_stopping(stats, curr_patience,
prev_val_loss)
epoch += 1
print("Finished Training")
# Save figure and keep plot open
utils.save_cnn_training_plot()
utils.hold_training_plot()
def main():
# Data loaders
if check_for_augmented_data("./data"):
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="augment",
batch_size=config("challenge.batch_size"),
)
else:
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target",
batch_size=config("challenge.batch_size"),
)
# Model
model = Challenge()
# TODO: define loss function, and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
#
# Attempts to restore the latest checkpoint if exists
print("Loading challenge...")
model, start_epoch, stats = restore_checkpoint(model, config("challenge.checkpoint"))
axes = utils.make_cnn_training_plot()
# Evaluate the randomly initialized model
_evaluate_epoch(
axes, tr_loader, va_loader, te_loader, model, criterion, start_epoch, stats
)
# initial val loss for early stopping
prev_val_loss = stats[0][1]
#TODO: define patience for early stopping
patience = 5
curr_patience = 0
#
# Loop over the entire dataset multiple times
epoch = start_epoch
while curr_patience < patience:
# Train model
_train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
_evaluate_epoch(
axes, tr_loader, va_loader, te_loader, model, criterion, epoch + 1, stats
)
# Save model parameters
save_checkpoint(model, epoch + 1, config("challenge.checkpoint"), stats)
#TODO: Implement early stopping
curr_patience, prev_val_loss = early_stopping(
stats, curr_patience, prev_val_loss
)
#
epoch += 1
print("Finished Training")
# Save figure and keep plot open
utils.save_challenge_training_plot()
utils.hold_training_plot()
_ = gcam.forward(xi)
gcam.backward(ids=torch.tensor([[target_class]]).to(device))
regions = gcam.generate(target_layer=target_layer)
activation = regions.detach()
save_gradcam(
np.squeeze(activation),
utils.denormalize_image(np.squeeze(xi.numpy()).transpose(1, 2, 0)),
axarr,
i,
)
if __name__ == "__main__":
# Attempts to restore from checkpoint
print("Loading cnn...")
model = Source()
model, start_epoch, _ = restore_checkpoint(model,
config("net.checkpoint"),
force=True)
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="target",
batch_size=config("net.batch_size"),
)
for i in range(40):
plt.clf()
f, axarr = plt.subplots(1, 2)
visualize_input(i, axarr)
visualize_layer1_activations(i, axarr)
plt.close()
zi = zi[sort_mask]
fig, axes = plt.subplots(4, 4, figsize=(10,10))
for i, ax in enumerate(axes.ravel()):
ax.axis('off')
im = ax.imshow(zi[i], cmap='gray')
fig.suptitle('Layer 1 activations, y={}'.format(yi))
fig.savefig('CNN_viz1_{}.png'.format(yi), dpi=200, bbox_inches='tight')
if __name__ == '__main__':
# Attempts to restore from checkpoint
print('Loading cnn...')
model = CNN()
model, start_epoch, _ = restore_checkpoint(model, config('cnn.checkpoint'),
force=True)
tr_loader, _, _, _ = get_train_val_test_loaders(
num_classes=config('cnn.num_classes'))
# Saving input images in original resolution
metadata = pd.read_csv(config('csv_file'))
for idx in [0, 4, 14, 15, 21]:
filename = os.path.join(
config('image_path'), metadata.loc[idx, 'filename'])
plt.imshow(imread(filename))
plt.axis('off')
plt.savefig('CNN_viz0_{}.png'.format(int(
metadata.loc[idx, 'numeric_label'])),
dpi=200, bbox_inches='tight')
# Saving layer activations
for i in [0, 2, 5, 6, 9]:
visualize_layer1_activations(i)
def main():
filename = config("savefilename")
lr = 0.0001
this_config = dict(csv_file=config("csv_file"),
img_path=config("image_path"),
learning_rate=lr,
num_classes=4,
batchsize=64)
wandb.init(project="prob_fix", name=filename, config=this_config)
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="default", batch_size=config("net.batch_size"))
print('successfully loading!')
model = Source()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
print("Number of float-valued parameters:", count_parameters(model))
model, start_epoch, stats = restore_checkpoint(model,
config("cnn.checkpoint"))
axes = utils.make_training_plot()
prolist = []
evaluate_epoch(axes,
tr_loader,
va_loader,
te_loader,
model,
criterion,
start_epoch,
stats,
prolist,
multiclass=True)
# initial val loss for early stopping
prev_val_loss = stats[0][1]
# TODO: define patience for early stopping
patience = 5
curr_patience = 0
#
# Loop over the entire dataset multiple times
# for epoch in range(start_epoch, config('cnn.num_epochs')):
epoch = start_epoch
lowest_val_loss = 1
train_auroc = 0
test_auroc = 0
lowest_round = epoch
while curr_patience < patience:
# Train model
train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
evaluate_epoch(axes,
tr_loader,
va_loader,
te_loader,
model,
criterion,
epoch + 1,
stats,
prolist,
multiclass=True)
# Save model parameters
save_checkpoint(model, epoch + 1, config("net.checkpoint"), stats)
# update early stopping parameters
curr_patience, prev_val_loss = early_stopping(stats, curr_patience,
prev_val_loss)
epoch += 1
if (prev_val_loss < lowest_val_loss):
lowest_val_loss = prev_val_loss
lowest_round = epoch
pickle.dump(prolist, open("base_pro.pck", "wb"))
print("Finished Training")
# Save figure and keep plot open
print("the lowest round: ", lowest_round)
# utils.save_cnn_training_plot()
# utils.save_cnn_other()
utils.hold_training_plot()
def main():
# data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
num_classes=config('autoencoder.classifier.num_classes'))
ae_classifier = AutoencoderClassifier(config('autoencoder.ae_repr_dim'),
config('autoencoder.classifier.num_classes'))
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(ae_classifier.parameters(),
lr=config('autoencoder.classifier.learning_rate'))
# freeze the weights of the encoder
for name, param in ae_classifier.named_parameters():
if 'fc1.' in name or 'fc2.' in name:
param.requires_grad = False
# Attempts to restore the latest checkpoint if exists
print('Loading autoencoder...')
ae_classifier, _, _ = restore_checkpoint(ae_classifier,
config('autoencoder.checkpoint'), force=True, pretrain=True)
print('Loading autoencoder classifier...')
ae_classifier, start_epoch, stats = restore_checkpoint(ae_classifier,
config('autoencoder.classifier.checkpoint'))
fig, axes = utils.make_cnn_training_plot(name='Autoencoder Classifier')
# Evaluate the randomly initialized model
_evaluate_epoch(axes, tr_loader, va_loader, ae_classifier, criterion,
start_epoch, stats)
# Loop over the entire dataset multiple times
for epoch in range(start_epoch, config('autoencoder.classifier.num_epochs')):
# Train model
_train_epoch(tr_loader, ae_classifier, criterion, optimizer)
# Evaluate model
_evaluate_epoch(axes, tr_loader, va_loader, ae_classifier, criterion,
epoch+1, stats)
#accuracy
if epoch == start_epoch:
r = [[], [], [], [], []]
for X, y in va_loader:
with torch.no_grad():
output = ae_classifier(X)
predict_res = predictions(output.data)
for y_sub, pred_out in zip(y, predict_res):
r[y_sub.item()].append(pred_out == y_sub)
for i in range(0,5):
print("Class ", i, "gives accuracy", np.sum(np.array(r[i]) / len(r[i])))
# Save model parameters
save_checkpoint(ae_classifier, epoch+1,
config('autoencoder.classifier.checkpoint'), stats)
print('Finished Training')
# Keep plot open
utils.save_cnn_training_plot(fig, name='ae_clf')
utils.hold_training_plot()
def main():
"""Train source model on multiclass data."""
# Data loaders
tr_loader, va_loader, te_loader, _ = get_train_val_test_loaders(
task="source",
batch_size=config("source.batch_size"),
)
# Model
model = Source()
# TODO: define loss function, and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=1e-3,
weight_decay=0.01)
#
print("Number of float-valued parameters:", count_parameters(model))
# Attempts to restore the latest checkpoint if exists
print("Loading source...")
model, start_epoch, stats = restore_checkpoint(model,
config("source.checkpoint"))
axes = utils.make_training_plot("Source Training")
# Evaluate the randomly initialized model
evaluate_epoch(
axes,
tr_loader,
va_loader,
te_loader,
model,
criterion,
start_epoch,
stats,
multiclass=True,
)
# initial val loss for early stopping
prev_val_loss = stats[0][1]
# TODO: patience for early stopping
patience = 10
curr_patience = 0
#
# Loop over the entire dataset multiple times
epoch = start_epoch
while curr_patience < patience:
# Train model
train_epoch(tr_loader, model, criterion, optimizer)
# Evaluate model
evaluate_epoch(
axes,
tr_loader,
va_loader,
te_loader,
model,
criterion,
epoch + 1,
stats,
multiclass=True,
)
# Save model parameters
save_checkpoint(model, epoch + 1, config("source.checkpoint"), stats)
curr_patience, prev_val_loss = early_stopping(stats, curr_patience,
prev_val_loss)
epoch += 1
# Save figure and keep plot open
print("Finished Training")
utils.save_source_training_plot()
utils.hold_training_plot()
