num_workers=1) val_dataset = Dataset(os.path.join(args.valdir, 'Image/'), os.path.join(args.valdir, 'LabeledImage/'), mytransforms) val_loader = DataLoader(val_dataset, batch_size=1, shuffle=True, num_workers=1) model = FCDenseNet103(args.classes) #model=model.cuda() model = nn.DataParallel(model).cuda() optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=1e-5) #optimizer = torch.optim.RMSprop(model.parameters(), lr=args.lr, weight_decay=1e-4) criterion = nn.NLLLoss2d() train_utils.load_weights(model, 'weights/weights-0-0.178-0.000.pth') for epoch in range(args.epochs): print('\n _______________________________________________') trn_loss, trn_err = train_utils.train(model, train_loader, optimizer, criterion, epoch) print('Epoch {:d}\nTrain - Loss: {:.4f}'.format(epoch, trn_loss)) train_utils.save_weights(model, epoch, float(trn_loss), 0) ### Adjust Lr ### train_utils.adjust_learning_rate(args.lr, args.decay, optimizer, epoch, DECAY_EVERY_N_EPOCHS) ### Validate ###
def main(): parser = argparse.ArgumentParser() parser.add_argument('--nClasses', type=int, default=10) #CIFAR parser.add_argument('--reduction', type=float, default=1.0) #no reduction parser.add_argument('--bottleneck', type=bool, default=False) parser.add_argument('--growthRate', type=int, default=12) parser.add_argument('--modelDepth', type=int, default=40) parser.add_argument('--batchSize', type=int, default=64) parser.add_argument('--nEpochs', type=int, default=2) parser.add_argument('--no-cuda', action='store_true') parser.add_argument('--save', type=str, default=RESULTS_PATH) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--existingWeights', type=str, default=None) parser.add_argument('--sessionName', type=str, default=train_utils.get_rand_str(5)) parser.add_argument('--opt', type=str, default='sgd', choices=('sgd', 'adam', 'rmsprop')) args = parser.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() setproctitle.setproctitle(args.save) #The process name torch.manual_seed(args.seed) if args.cuda: print("Using CUDA") torch.cuda.manual_seed(args.seed) # if os.path.exists(args.save): # shutil.rmtree(args.save) # os.makedirs(args.save, exist_ok=True) normMean = [0.49139968, 0.48215827, 0.44653124] normStd = [0.24703233, 0.24348505, 0.26158768] normTransform = transforms.Normalize(normMean, normStd) trainTransform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normTransform ]) testTransform = transforms.Compose([transforms.ToTensor(), normTransform]) kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {} print("Kwargs: " + str(kwargs)) trainLoader = DataLoader(dset.CIFAR10(root=CIFAR10_PATH, train=True, download=True, transform=trainTransform), batch_size=args.batchSize, shuffle=True, **kwargs) testLoader = DataLoader(dset.CIFAR10(root=CIFAR10_PATH, train=False, download=True, transform=testTransform), batch_size=args.batchSize, shuffle=False, **kwargs) net = DenseNet(growthRate=args.growthRate, depth=args.modelDepth, reduction=args.reduction, bottleneck=args.bottleneck, nClasses=args.nClasses) if args.existingWeights: print("Loading existing weights: %s" % args.existingWeights) startEpoch = train_utils.load_weights(net, args.existingWeights) endEpoch = startEpoch + args.nEpochs print('Resume training at epoch: {}'.format(startEpoch)) if os.path.exists(args.save + 'train.csv'): #assume test.csv exists print("Found existing train.csv") append_write = 'a' # append if already exists else: print("Creating new train.csv") append_write = 'w' # make a new file if not trainF = open(os.path.join(args.save, 'train.csv'), append_write) testF = open(os.path.join(args.save, 'test.csv'), append_write) else: print("Training new model from scratch") startEpoch = 1 endEpoch = args.nEpochs trainF = open(os.path.join(args.save, 'train.csv'), 'w') testF = open(os.path.join(args.save, 'test.csv'), 'w') print(' + Number of params: {}'.format( sum([p.data.nelement() for p in net.parameters()]))) if args.cuda: net = net.cuda() if args.opt == 'sgd': optimizer = optim.SGD(net.parameters(), lr=1e-1, momentum=0.9, weight_decay=1e-4) elif args.opt == 'adam': optimizer = optim.Adam(net.parameters(), weight_decay=1e-4) elif args.opt == 'rmsprop': optimizer = optim.RMSprop(net.parameters(), weight_decay=1e-4) print("Training....") for epoch in range(startEpoch, endEpoch + 1): since = time.time() train_utils.adjust_opt(args.opt, optimizer, epoch) train_utils.train(epoch, net, trainLoader, optimizer, trainF, sessionName=args.sessionName) train_utils.test(epoch, net, testLoader, optimizer, testF) time_elapsed = time.time() - since print('Time {:.0f}m {:.0f}s\n'.format(time_elapsed // 60, time_elapsed % 60)) if epoch != 1: os.system('./plot.py {} &'.format(args.save)) trainF.close() testF.close()
import torchvision import torchvision.transforms as transforms from datasets import camvid import utils.imgs import utils.training as train_utils from datasets import joint_transforms from pathlib import Path from models import tiramisu CAMVID_PATH = Path('/home/jingwenlai/data', 'CamVid/CamVid') batch_size = 2 normalize = transforms.Normalize(mean=camvid.mean, std=camvid.std) test_dset = camvid.CamVid(CAMVID_PATH, 'test', joint_transform=None, transform=transforms.Compose( [transforms.ToTensor(), normalize])) test_loader = torch.utils.data.DataLoader(test_dset, batch_size=batch_size, shuffle=False) print("Test: %d" % len(test_loader.dataset.imgs)) model = tiramisu.FCDenseNet67(n_classes=12).cuda() model_weights = ".weights/latest.th" startEpoch = train_utils.load_weights(model, model_weights) print("load_weights, return epoch: ", startEpoch) train_utils.view_sample_predictions(model, test_loader, n=10)
#print("Targets: ", targets.size()) # #utils.imgs.view_image(inputs[0]) #utils.imgs.view_annotated(targets[0]) #%% LR = 1e-4 LR_DECAY = 0.995 DECAY_EVERY_N_EPOCHS = 1 torch.cuda.manual_seed(0) model = tiramisu.FCDenseNet67(n_classes=n_classes).cuda() if weight_filename is not None: train_utils.load_weights(model, os.path.join(WEIGHTS_PATH, weight_filename)) print('pretrained weights loaded') start_epoch = int(weight_filename.split('-')[1]) + 1 else: model.apply(train_utils.weights_init) print('train from beginning') start_epoch = 0 optimizer = torch.optim.RMSprop(model.parameters(), lr=LR, weight_decay=1e-4) #criterion = train_utils.FocalLoss2d(gamma) # if FocalLoss2d: delete the last layer of the tiramisu # print('focal loss with gamma = ',gamma)
print("Val: %d" % len(val_loader.dataset.imgs)) print("Test: %d" % len(test_loader.dataset.imgs)) print("Classes: %d" % len(train_loader.dataset.classes)) inputs, targets = next(iter(train_loader)) print("Inputs: ", inputs.size()) print("Targets: ", targets.size()) # hyperparameters LR = hyper["learning_rate"] LR_DECAY = hyper["lr_decay"] DECAY_EVERY_N_EPOCHS = hyper["decay_per_n_epoch"] N_EPOCHS = hyper["n_epoch"] # load combined model model_path = "./.weights/weights-combined-11-27987.752-0.343.pth" model = tiramisu.FCDenseNet57_aleatoric(n_classes=12, dropout=dropout).cuda() load_weights(model, model_path) if __name__ == "__main__": print("Visualizing ...") # Make visualization i = 0 for inputs, targets in train_dset: print("{} - th".format(i)) train_utils.view_sample_predictions_with_uncertainty( model, inputs, targets, i) i += 1 if i > 100: break
def test(): train_utils.test(model, test_loader, criterion, epoch=1) train_utils.view_sample_predictions(model, test_loader, n=1) if __name__ == '__main__': parser = argparse.ArgumentParser(description="Pytorch Tiramisu Training") parser.add_argument('--lr', default=1e-4, type=float, help="learning rate") parser.add_argument('--resume', '-r', action="store_true", help="resume from checkpoint") args = parser.parse_args() startEpoch = 0 if args.resume: startEpoch = train_utils.load_weights(model, '.weights/latest.th') print("load weights for model , start from startEpoch") train(startEpoch) epoch_logger = open('train_val_log.csv', 'w') for epoch in range(startEpoch, N_EPOCHS + 1): train_loss, train_acc = train(epoch) val_loss, val_acc = val(epoch) epoch_logger.write("%d, %.3f, %.3f, %.3f, %3f" % (epoch, train_loss, train_acc, val_loss, val_acc)) epoch_logger.close()
mean = [0.41189489566336, 0.4251328133025, 0.4326707089857] std = [0.27413549931506, 0.28506257482912, 0.28284674400252] normalize = transforms.Normalize(mean=mean, std=std) test_joint_transformer = transforms.Compose([ joint_transforms.JointCenterCrop((512,224)) ]) test_dset = shirts.Shirts( CAMVID_PATH, 'test', joint_transform=test_joint_transformer, transform=transforms.Compose([ transforms.ToTensor(), normalize ])) test_loader = torch.utils.data.DataLoader( test_dset, batch_size=1, shuffle=False) print("Test: %d" %len(test_loader.dataset.imgs)) print("Classes: %d" % len(test_loader.dataset.classes)) fpath = os.path.join(WEIGHTS_PATH,"weights-20-0.217-0.000.pth") torch.cuda.manual_seed(0) model = tiramisu.FCDenseNet00(n_classes=2).cuda() train_utils.load_weights(model,fpath) model.eval() train_utils.test_set_predictions(model, test_loader)