def train(args, model, optimizer, scheduler=None, model_name='model'):
# TODO: Q1.5 Initialize your visualizer here!
# TODO: Q1.2 complete your dataloader in voc_dataset.py
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval')
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
# Ensure model is in correct mode and on right device
model.train()
model = model.to(args.device)
# TODO: Q1.4 Implement model training code!
cnt = 0
for epoch in range(args.epochs):
for batch_idx, (data, target, wgt) in enumerate(train_loader):
# Get a batch of data
data, target, wgt = data.to(args.device), target.to(
args.device), wgt.to(args.device)
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculate the loss
# TODO: your loss for multi-label clf?
loss = 0
# Calculate gradient w.r.t the loss
loss.backward()
# Optimizer takes one step
optimizer.step()
# Log info
if cnt % args.log_every == 0:
# todo: add your visualization code
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
# Validation iteration
if cnt % args.val_every == 0:
model.eval()
ap, map = utils.eval_dataset_map(model, args.device,
test_loader)
model.train()
cnt += 1
if scheduler is not None:
scheduler.step()
# Validation iteration
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
ap, map = utils.eval_dataset_map(model, args.device, test_loader)
return ap, map
def main():
# TODO: Initialize your visualizer here!
timestr = time.strftime("%Y%m%d-%H%M%S")
save_path = "runs/" + timestr + '/'
writer = SummaryWriter(save_path)
# TODO: complete your dataloader in voc_dataset.py
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval',
model_to_use=int(args.model_to_use))
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test',
model_to_use=int(args.model_to_use))
# 2. define the model, and optimizer.
# TODO: modify your model here!
# bad idea of use simple CNN, but let's give it a shot!
# In task 2, 3, 4, you might want to modify this line to be configurable to other models.
# Remember: always reuse your code wisely.
if (int(args.model_to_use) == 1):
model = SimpleCNN(num_classes=len(VOCDataset.CLASS_NAMES),
inp_size=64,
c_dim=3).to(device)
MODEL_SAVE_PATH = "../Saved_Models/trained_simpleCNNmodel"
print("Using SimpleCNN")
elif (int(args.model_to_use) == 2):
model = CaffeNet(num_classes=len(VOCDataset.CLASS_NAMES),
inp_size=64,
c_dim=3,
dropout_prob=0.5).to(device)
MODEL_SAVE_PATH = "../Saved_Models/trained_CaffeNet"
'''Uncomment for T-SNE'''
# model.fc2.register_forward_hook(hook)
print("Using CaffeNet")
elif (int(args.model_to_use) == 3):
model = models.resnet18(pretrained=False)
final_layer_in_features = model.fc.in_features
model.fc = nn.Linear(final_layer_in_features,
len(VOCDataset.CLASS_NAMES))
model = model.to(device)
MODEL_SAVE_PATH = "../Saved_Models/trained_Resnet_no_pretrain"
print("Using ResNet")
elif (int(args.model_to_use) == 4):
model = models.resnet18(pretrained=True)
final_layer_in_features = model.fc.in_features
model.fc = nn.Linear(final_layer_in_features,
len(VOCDataset.CLASS_NAMES))
model.fc.weight = nn.Parameter(
2 * torch.rand(model.fc.weight.shape) - 1
) #This ensures that the last layer gets randomly allotted weights in the range [-1,1]
model = model.to(device)
MODEL_SAVE_PATH = "../Saved_Models/trained_Resnet_pretrained"
print("Using ResNet")
else:
print("Select Correct model_to_use")
raise NotImplementedError
model.train()
model = model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=1,
gamma=args.gamma)
cnt = 0
#Model Save Code #Get 5 checkpoints
model_save_epochs = np.linspace(0,
args.epochs - 1,
num=5,
endpoint=True,
dtype=int)
index_model_save_epochs = 0
#Visualize Filter Code #Visualize at 3 different epochs
filter_visualization_epochs = np.linspace(0,
args.epochs - 1,
num=3,
endpoint=True,
dtype=int)
index_filter_visualization_epochs = 0
for epoch in range(args.epochs):
print("---------------EPOCH: ", epoch, " ------------------------")
for batch_idx, (data, target, wgt) in enumerate(train_loader):
# Get a batch of data
data, target, wgt = data.to(device), target.to(device), wgt.to(
device)
# visualize_data_sample(data[0])
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculate the loss
# TODO: your loss for multi-label clf?
loss = F.multilabel_soft_margin_loss(output, wgt * target)
# Calculate gradient w.r.t the loss
loss.backward()
# Optimizer takes one step
optimizer.step()
# Log info
if cnt % args.log_every == 0:
# todo: add your visualization code
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
writer.add_scalar('Train/Loss', loss, cnt)
current_lr = get_lr(copy.deepcopy(optimizer))
writer.add_scalar('lr', current_lr, cnt)
if (args.model_to_use == 3 or args.model_to_use == 4):
writer.add_histogram('Resnet_Conv1',
model.conv1.weight.grad, cnt)
# Validation iteration
if cnt % args.val_every == 0:
model.eval()
ap, map, avg_test_loss = utils.eval_dataset_map(
model, device, test_loader)
writer.add_scalar('MAP', map, cnt)
writer.add_scalar('Average_Test_Loss', avg_test_loss, cnt)
model.train()
cnt += 1
scheduler.step()
if (model_save_epochs[index_model_save_epochs] == epoch):
print("Saving Model ", epoch)
torch.save(
{
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
}, MODEL_SAVE_PATH)
index_model_save_epochs += 1
if (
filter_visualization_epochs[index_filter_visualization_epochs]
== epoch
): #Filters are only needed for CaffeNet so can be commented for Resnet and SimpleCNN
print("Extracting Filter", epoch)
index_filter_visualization_epochs += 1
kernels = model.conv1.weight.detach().clone()
visualize_filter(kernels, epoch, MODEL_SAVE_PATH)
writer.add_image('Train_Images_' + str(epoch) + '_1',
data[0]) #Uncomment for ResNet Question
if (int(args.model_to_use) == 2):
model.fc2.register_forward_hook(hook)
print("Registered hook to model.fc2 for Caffe_Net"
) #Change this hook appropriately based on the question
# Validation iteration
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test',
model_to_use=int(args.model_to_use))
ap, map, avg_test_loss = utils.eval_dataset_map(model, device, test_loader)
'''TODO: For T-SNE part'''
# if(int(args.model_to_use)==2):
# tsne = manifold.TSNE(n_components=2, init='random', perplexity=10)
# trans_data = tsne.fit_transform(fc7_output[-1])
# plt.figure()
# ax = plt.subplot(111)
# plt.scatter(trans_data[0], trans_data[1], cmap=plt.cm.rainbow)
# plt.show()
num_images = 3
num_neighbors = 3
ipdb.set_trace()
if (int(args.model_to_use) == 2):
assert (
len(fc7_output) == 1
) #This might throw an error: make sure output is a single tensor
dicto = get_nearest_neighbors(num_images, num_neighbors, fc7_output[0])
#See how to convert these indices into images now!
print('----test-----')
print(ap)
print('mAP: ', map)
print('Average_Test_Loss: ', avg_test_loss)
writer.close()
def train(args, model, optimizer, scheduler=None, model_name='model'):
# TODO Q1.5: Initialize your tensorboard writer here!
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval',
inp_size=args.inp_size)
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test',
inp_size=args.inp_size)
# Ensure model is in correct mode and on right device
model.train()
model = model.to(args.device)
cnt = 0
for epoch in range(args.epochs):
for batch_idx, (data, target, wgt) in enumerate(train_loader):
# Get a batch of data
data, target, wgt = data.to(args.device), target.to(
args.device), wgt.to(args.device)
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculate the loss
# TODO Q1.4: your loss for multi-label classification
loss = 0
# Calculate gradient w.r.t the loss
loss.backward()
# Optimizer takes one step
optimizer.step()
# Log info
if cnt % args.log_every == 0:
# TODO Q1.5: Log training loss to tensorboard
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
# TODO Q3.2: Log histogram of gradients
# Validation iteration
if cnt % args.val_every == 0:
model.eval()
ap, map = utils.eval_dataset_map(model, args.device,
test_loader)
# TODO Q1.5: Log MAP to tensorboard
model.train()
cnt += 1
# TODO Q3.2: Log Learning rate
if scheduler is not None:
scheduler.step()
# save model
if save_this_epoch(args, epoch):
save_model(epoch, model_name, model)
# Validation iteration
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test',
inp_size=args.inp_size)
ap, map = utils.eval_dataset_map(model, args.device, test_loader)
return ap, map
def main():
# TODO: Initialize your visualizer here!
writer = SummaryWriter(
'../runs/q4_resnet18_gam=0.9_changedTransform_images')
# TODO: complete your dataloader in voc_dataset.py
# import ipdb; ipdb.set_trace()
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval')
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
# 2. define the model, and optimizer.
# TODO: modify your model here!
# bad idea of use simple CNN, but let's give it a shot!
# In task 2, 3, 4, you might want to modify this line to be configurable to other models.
# Remember: always reuse your code wisely.
# model = CaffeNet(num_classes=len(VOCDataset.CLASS_NAMES), inp_size=227, c_dim=3).to(device)
model = models.resnet18(pretrained=True)
model.fc = nn.Linear(512, 20)
model.train()
model = model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=1,
gamma=args.gamma)
cnt = 0
loss_obj = nn.MultiLabelSoftMarginLoss()
for epoch in range(args.epochs):
for batch_idx, (data, target, wgt) in enumerate(train_loader):
# Get a batch of data
data, target, wgt = data.to(device), target.to(device), wgt.to(
device)
# import ipdb; ipdb.set_trace()
img_grid = torchvision.utils.make_grid(data[:4])
writer.add_image('training_images', img_grid)
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculate the loss
# TODO: your loss for multi-label clf?
# loss = nn.BCELoss()
# import ipdb; ipdb.set_trace()
# output = torch.sigmoid(output)
loss = loss_obj(output * wgt, wgt * target)
# Calculate gradient w.r.t the loss
loss.backward()
# Optimizer takes one step
optimizer.step()
# Log info
if cnt % args.log_every == 0:
# todo: add your visualization code
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
writer.add_scalar('Loss/train: ', loss.item(), cnt)
if epoch % 1 == 0:
torch.save(
model.state_dict(),
"../q4_resnet18_models_v1_img/model_at_epoch_" +
str(epoch) + ".pth")
# print('Batch idx: {} \r'.format(batch_idx), end='')
# Validation iteration
if cnt % args.val_every == 0:
model.eval()
# print("\n")
ap, map = utils.eval_dataset_map(model, device, test_loader)
writer.add_scalar('Validation mAP: ', map, cnt)
model.train()
cnt += 1
scheduler.step()
# Validation iteration
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
ap, map = utils.eval_dataset_map(model, device, test_loader)
print('----test-----')
print(ap)
print('mAP: ', map)
writer.add_scalar('Testing mAP: ', map, cnt)
writer.close()
def train(args, model, optimizer, scheduler=None, model_name='model'):
# TODO: Q1.5 Initialize your visualizer here!
# TODO: Q1.2 complete your dataloader in voc_dataset.py
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval',
args=args)
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test',
args=args)
writer = SummaryWriter(model_name)
# Ensure model is in correct mode and on right device
model.train()
model = model.to(args.device)
# TODO: Q1.4 Implement model training code!
cnt = 0
criterion = torch.nn.BCELoss()
for epoch in range(args.epochs):
for batch_idx, (data, target, wgt) in enumerate(train_loader):
# Get a batch of data
data, target, wgt = data.to(args.device), target.to(
args.device), wgt.to(args.device)
optimizer.zero_grad()
# Forward pass
output = model(data)
output = torch.sigmoid(output)
target = target * wgt
# TODO: your loss for multi-label clf?
#criterion = torch.nn.BCEWithLogitsLoss(wgt)
loss = criterion(output, target)
# Calculate gradient w.r.t the loss
loss.backward()
# Optimizer takes one step
optimizer.step()
# Log info
if cnt % args.log_every == 0:
# todo: add your visualization code
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
make_gradient_histograms(cnt, model, writer)
# Validation iteration
writer.add_scalar('training loss', loss.item(), cnt)
if cnt % args.val_every == 0:
ap, map = utils.eval_dataset_map(model, args.device,
test_loader)
writer.add_scalar('mean average precision', map.item(), cnt)
cnt += 1
lr = optimizer.param_groups[0]['lr']
writer.add_scalar('learning rate', lr, cnt)
if save_this_epoch(args, epoch):
save_model(epoch, model_name, model)
if scheduler is not None:
#print('Epoch-{0} lr: {1}'.format(epoch, optimizer.param_groups[0]['lr']))
scheduler.step()
# Validation iteration
#test_loader = utils.get_data_loader('voc', train=False, batch_size=args.test_batch_size, split='test')
ap, map = utils.eval_dataset_map(model, args.device, test_loader)
if args.save_at_end:
save_model(epoch, model_name, model)
return ap, map
def main():
writer = SummaryWriter()
train_loader = utils.get_data_loader('voc',
train=True,
batch_size=args.batch_size,
split='trainval')
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
# model = SimpleCNN(num_classes=len(VOCDataset.CLASS_NAMES), inp_size=227, c_dim=3).to(device)
model = CaffeNet(num_classes=len(VOCDataset.CLASS_NAMES),
inp_size=227,
c_dim=3).to(device)
# model = models.resnet18(pretrained=True)
model_resnet = False
if (model_resnet):
model.fc = nn.Linear(in_features=512,
out_features=len(VOCDataset.CLASS_NAMES),
bias=True)
model.train()
model = model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=1,
gamma=args.gamma)
cnt = 0
for epoch in range(args.epochs):
for batch_idx, (data, target, wgt) in enumerate(train_loader):
data, target, wgt = data.to(device), target.to(device), wgt.to(
device)
optimizer.zero_grad()
output = model(data)
criterion = torch.nn.BCEWithLogitsLoss(weight=wgt)
loss = criterion(output, target)
loss.backward()
optimizer.step()
# Log info
if cnt % args.log_every == 0:
writer.add_scalar('Loss/train', loss.item(), cnt)
print('Train Epoch: {} [{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, cnt, 100. * batch_idx / len(train_loader),
loss.item()))
# Validation iteration
if cnt % args.val_every == 0:
model.eval()
ap, eval_mAP = utils.eval_dataset_map(model, device,
test_loader)
model.train()
writer.add_scalar('mAP/test', eval_mAP, cnt)
cnt += 1
scheduler.step()
if not model.conv1.weight.grad is None:
writer.add_histogram('conv1_histogram_of_grad',
model.conv1.weight.grad.flatten().detach(),
cnt)
current_lr = scheduler.optimizer.param_groups[0]['lr']
writer.add_scalar('learning_rate', current_lr, cnt)
writer.add_image('train_images' + str(epoch), data[0])
if epoch % 10 == 0:
torch.save(
model.state_dict(), "./checkpoints/model_epoch_" + str(epoch) +
"_" + date_str + ".pth")
torch.save(
model.state_dict(),
"./checkpoints/model_epoch_" + str(epoch) + "_" + date_str + ".pth")
# Validation iteration
test_loader = utils.get_data_loader('voc',
train=False,
batch_size=args.test_batch_size,
split='test')
AP, mAP = utils.eval_dataset_map(model, device, test_loader)
print('----test-----')
print(AP)
print('mAP: ', mAP)