def train(model, train_loader, test_loader, opt): opt.printer.info('===> Init the optimizer ...') criterion = nn.NLLLoss().to(opt.device) # criterion = torch.nn.CrossEntropyLoss().to(opt.device) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, opt.lr_adjust_freq, opt.lr_decay_rate) optimizer, scheduler, opt.lr = load_pretrained_optimizer( opt.pretrained_model, optimizer, scheduler, opt.lr, opt.use_ckpt_lr) opt.printer.info('===> Init Metric ...') opt.losses = AverageMeter() opt.test_value = 0. opt.printer.info('===> start training ...') for _ in range(opt.epoch, opt.total_epochs): opt.epoch += 1 train_step(model, train_loader, optimizer, scheduler, criterion, opt) if opt.epoch % opt.test_freq: test(model, test_loader, opt) save_ckpt(model, optimizer, scheduler, opt) scheduler.step() opt.printer.info( 'Saving the final model.Finish! Category {}-{}. Best part mIou is {}. Best shape mIOU is {}.' .format(opt.category_no, opt.category, opt.best_value, opt.best_shapeMiou))
def train(model, train_loader, val_loader, test_loader, opt): logging.info('===> Init the optimizer ...') criterion = nn.NLLLoss().to(opt.device) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) # weight_decay=1e-4 scheduler = torch.optim.lr_scheduler.StepLR(optimizer, opt.lr_adjust_freq, opt.lr_decay_rate) optimizer, scheduler, opt.lr = load_pretrained_optimizer(opt.pretrained_model, optimizer, scheduler, opt.lr) logging.info('===> Init Metric ...') opt.losses = AverageMeter() best_val_part_miou = 0. best_test_part_miou = 0. test_part_miou_val_best = 0. logging.info('===> start training ...') for _ in range(opt.epoch, opt.total_epochs): opt.epoch += 1 # reset tracker opt.losses.reset() train_epoch(model, train_loader, optimizer, criterion, opt) val_part_iou, val_shape_mIoU = test(model, val_loader, opt) test_part_iou, test_shape_mIoU = test(model, test_loader, opt) scheduler.step() # ------------------ save ckpt if val_part_iou > best_val_part_miou: best_val_part_miou = val_part_iou test_part_miou_val_best = test_part_iou logging.info("Got a new best model on Validation with Part iou {:.4f}".format(best_val_part_miou)) save_ckpt(model, optimizer, scheduler, opt, 'val_best') if test_part_iou > best_test_part_miou: best_test_part_miou = test_part_iou logging.info("Got a new best model on Test with Part iou {:.4f}".format(best_test_part_miou)) save_ckpt(model, optimizer, scheduler, opt, 'test_best') # ------------------ show information logging.info( "===> Epoch {} Category {}-{}, Train Loss {:.4f}, mIoU on val {:.4f}, mIoU on test {:4f}, " "Best val mIoU {:.4f} Its test mIoU {:.4f}. Best test mIoU {:.4f}".format( opt.epoch, opt.category_no, opt.category, opt.losses.avg, val_part_iou, test_part_iou, best_val_part_miou, test_part_miou_val_best, best_test_part_miou)) info = { 'loss': opt.losses.avg, 'val_part_miou': val_part_iou, 'test_part_miou': test_part_iou, 'lr': scheduler.get_lr()[0] } for tag, value in info.items(): opt.logger.scalar_summary(tag, value, opt.step) save_ckpt(model, optimizer, scheduler, opt, 'last') logging.info( 'Saving the final model.Finish! Category {}-{}. Best val part mIoU is {:.4f}. Its test mIoU is {:.4f}. ' 'Best test part mIoU is {:.4f}. Last test mIoU {:.4f} \n\n\n'. format(opt.category_no, opt.category, best_val_part_miou, test_part_miou_val_best, best_test_part_miou, test_part_iou))
def main(): opt = OptInit().initialize() print('===> Creating dataloader ...') train_dataset = GeoData.S3DIS(opt.train_path, 5, True, pre_transform=T.NormalizeScale()) if opt.multi_gpus: train_loader = DataListLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) else: train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) opt.n_classes = train_loader.dataset.num_classes print('===> Loading the network ...') opt.model = getattr(models, opt.model_name)(opt).to(opt.device) if opt.multi_gpus: opt.model = DataParallel(getattr(models, opt.model_name)(opt)).to(opt.device) print('===> loading pre-trained ...') load_pretrained_models(opt) print('===> Init the optimizer ...') opt.criterion = torch.nn.CrossEntropyLoss().to(opt.device) opt.valid_metric = miou opt.optimizer = torch.optim.Adam(opt.model.parameters(), lr=opt.lr) opt.scheduler = torch.optim.lr_scheduler.StepLR(opt.optimizer, opt.lr_adjust_freq, 0.5) load_pretrained_optimizer(opt) print('===> start training ...') for _ in range(opt.total_epochs): opt.epoch += 1 train(train_loader, opt) # valid(train_loader, opt) opt.scheduler.step() print('Saving the final model.Finish!')
def main(): opt = OptInit().initialize() opt.printer.info('===> Creating dataloader ...') train_dataset = GeoData.S3DIS(opt.train_path, 5, True, pre_transform=T.NormalizeScale()) if opt.multi_gpus: train_loader = DataListLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) else: train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) opt.n_classes = train_loader.dataset.num_classes opt.printer.info('===> Loading the network ...') model = SparseDeepGCN(opt).to(opt.device) if opt.multi_gpus: model = DataParallel(SparseDeepGCN(opt)).to(opt.device) opt.printer.info('===> loading pre-trained ...') model, opt.best_value, opt.epoch = load_pretrained_models( model, opt.pretrained_model, opt.phase) opt.printer.info('===> Init the optimizer ...') criterion = torch.nn.CrossEntropyLoss().to(opt.device) if opt.optim.lower() == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) elif opt.optim.lower() == 'radam': optimizer = optim.RAdam(model.parameters(), lr=opt.lr) else: raise NotImplementedError('opt.optim is not supported') scheduler = torch.optim.lr_scheduler.StepLR(optimizer, opt.lr_adjust_freq, opt.lr_decay_rate) optimizer, scheduler, opt.lr = load_pretrained_optimizer( opt.pretrained_model, optimizer, scheduler, opt.lr) opt.printer.info('===> Init Metric ...') opt.losses = AverageMeter() # opt.test_metric = miou # opt.test_values = AverageMeter() opt.test_value = 0. opt.printer.info('===> start training ...') for _ in range(opt.total_epochs): opt.epoch += 1 train(model, train_loader, optimizer, scheduler, criterion, opt) # test_value = test(model, test_loader, test_metric, opt) scheduler.step() opt.printer.info('Saving the final model.Finish!')
def main(): opt = OptInit().get_args() logging.info('===> Creating dataloader ...') train_dataset = GeoData.S3DIS(opt.data_dir, opt.area, True, pre_transform=T.NormalizeScale()) train_loader = DenseDataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) test_dataset = GeoData.S3DIS(opt.data_dir, opt.area, train=False, pre_transform=T.NormalizeScale()) test_loader = DenseDataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=0) opt.n_classes = train_loader.dataset.num_classes logging.info('===> Loading the network ...') model = DenseDeepGCN(opt).to(opt.device) if opt.multi_gpus: model = DataParallel(DenseDeepGCN(opt)).to(opt.device) logging.info('===> loading pre-trained ...') model, opt.best_value, opt.epoch = load_pretrained_models( model, opt.pretrained_model, opt.phase) logging.info(model) logging.info('===> Init the optimizer ...') criterion = torch.nn.CrossEntropyLoss().to(opt.device) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, opt.lr_adjust_freq, opt.lr_decay_rate) optimizer, scheduler, opt.lr = load_pretrained_optimizer( opt.pretrained_model, optimizer, scheduler, opt.lr) logging.info('===> Init Metric ...') opt.losses = AverageMeter() opt.test_value = 0. logging.info('===> start training ...') for _ in range(opt.epoch, opt.total_epochs): opt.epoch += 1 logging.info('Epoch:{}'.format(opt.epoch)) train(model, train_loader, optimizer, scheduler, criterion, opt) if opt.epoch % opt.eval_freq == 0 and opt.eval_freq != -1: test(model, test_loader, opt) scheduler.step() logging.info('Saving the final model.Finish!')
def train(): info_format = 'Epoch: [{}]\t loss: {: .6f} train mF1: {: .6f} \t val mF1: {: .6f}\t test mF1: {:.6f} \t ' \ 'best val mF1: {: .6f}\t best test mF1: {:.6f}' opt.printer.info('===> Init the optimizer ...') criterion = torch.nn.BCEWithLogitsLoss().to(opt.device) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) scheduler = ReduceLROnPlateau(optimizer, "min", patience=opt.lr_patience, verbose=True, factor=0.5, cooldown=30, min_lr=opt.lr/100) opt.scheduler = 'ReduceLROnPlateau' optimizer, scheduler, opt.lr = load_pretrained_optimizer(opt.pretrained_model, optimizer, scheduler, opt.lr) opt.printer.info('===> Init Metric ...') opt.losses = AverageMeter() best_val_value = 0. best_test_value = 0. opt.printer.info('===> Start training ...') for _ in range(opt.epoch, opt.total_epochs): opt.epoch += 1 loss, train_value = train_step(model, train_loader, optimizer, criterion, opt) val_value = test(model, valid_loader, opt) test_value = test(model, test_loader, opt) if val_value > best_val_value: best_val_value = val_value save_ckpt(model, optimizer, scheduler, opt.epoch, opt.save_path, opt.post, name_post='val_best') if test_value > best_test_value: best_test_value = test_value save_ckpt(model, optimizer, scheduler, opt.epoch, opt.save_path, opt.post, name_post='test_best') opt.printer.info(info_format.format(opt.epoch, loss, train_value, val_value, test_value, best_val_value, best_test_value)) if opt.scheduler == 'ReduceLROnPlateau': scheduler.step(opt.losses.avg) else: scheduler.step() opt.printer.info('Saving the final model.Finish!')
def main(): opt = OptInit().get_args() logging.info('===> Creating dataloader ...') train_dataset = GeoData.S3DIS(opt.data_dir, opt.area, True, pre_transform=T.NormalizeScale()) train_loader = DenseDataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=4) test_dataset = GeoData.S3DIS(opt.data_dir, opt.area, train=False, pre_transform=T.NormalizeScale()) test_loader = DenseDataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=0) opt.n_classes = train_loader.dataset.num_classes logging.info('===> Loading the network ...') model = DenseDeepGCN(opt).to(opt.device) if opt.multi_gpus: model = DataParallel(DenseDeepGCN(opt)).to(opt.device) logging.info('===> loading pre-trained ...') model, opt.best_value, opt.epoch = load_pretrained_models( model, opt.pretrained_model, opt.phase) logging.info(model) logging.info('===> Init the optimizer ...') criterion = torch.nn.CrossEntropyLoss().to(opt.device) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, opt.lr_adjust_freq, opt.lr_decay_rate) optimizer, scheduler, opt.lr = load_pretrained_optimizer( opt.pretrained_model, optimizer, scheduler, opt.lr) logging.info('===> Init Metric ...') opt.losses = AverageMeter() opt.test_value = 0. logging.info('===> start training ...') for _ in range(opt.epoch, opt.total_epochs): opt.epoch += 1 logging.info('Epoch:{}'.format(opt.epoch)) train(model, train_loader, optimizer, criterion, opt) if opt.epoch % opt.eval_freq == 0 and opt.eval_freq != -1: test(model, test_loader, opt) scheduler.step() # ------------------ save checkpoints # min or max. based on the metrics is_best = (opt.test_value < opt.best_value) opt.best_value = max(opt.test_value, opt.best_value) model_cpu = {k: v.cpu() for k, v in model.state_dict().items()} save_checkpoint( { 'epoch': opt.epoch, 'state_dict': model_cpu, 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'best_value': opt.best_value, }, is_best, opt.ckpt_dir, opt.exp_name) # ------------------ tensorboard log info = { 'loss': opt.losses.avg, 'test_value': opt.test_value, 'lr': scheduler.get_lr()[0] } opt.writer.add_scalars('epoch', info, opt.iter) logging.info('Saving the final model.Finish!')
def train(model, train_loader, test_loader, opt): logging.info('===> Init the optimizer ...') criterion = SmoothCrossEntropy() if opt.use_sgd: logging.info("===> Use SGD") optimizer = torch.optim.SGD(model.parameters(), lr=opt.lr * 100, momentum=0.9, weight_decay=opt.weight_decay) else: logging.info("===> Use Adam") optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, weight_decay=opt.weight_decay) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, opt.epochs, eta_min=opt.lr) optimizer, scheduler, opt.lr = load_pretrained_optimizer( opt.pretrained_model, optimizer, scheduler, opt.lr) logging.info('===> Init Metric ...') opt.train_losses = AverageMeter() opt.test_losses = AverageMeter() best_test_overall_acc = 0. avg_acc_when_best = 0. logging.info('===> start training ...') for _ in range(opt.epoch, opt.epochs): opt.epoch += 1 # reset tracker opt.train_losses.reset() opt.test_losses.reset() train_overall_acc, train_class_acc, opt = train_step( model, train_loader, optimizer, criterion, opt) test_overall_acc, test_class_acc, opt = infer(model, test_loader, criterion, opt) scheduler.step() # ------------------ save ckpt if test_overall_acc > best_test_overall_acc: best_test_overall_acc = test_overall_acc avg_acc_when_best = test_class_acc logging.info( "Got a new best model on Test with Overall ACC {:.4f}. " "Its avg acc is {:.4f}".format(best_test_overall_acc, avg_acc_when_best)) save_ckpt(model, optimizer, scheduler, opt, 'best') # ------------------ show information logging.info( "===> Epoch {}/{}, Train Loss {:.4f}, Test Overall Acc {:.4f}, Test Avg Acc {:4f}, " "Best Test Overall Acc {:.4f}, Its test avg acc {:.4f}.".format( opt.epoch, opt.epochs, opt.train_losses.avg, test_overall_acc, test_class_acc, best_test_overall_acc, avg_acc_when_best)) info = { 'train_loss': opt.train_losses.avg, 'train_OA': train_overall_acc, 'train_avg_acc': train_class_acc, 'test_loss': opt.test_losses.avg, 'test_OA': test_overall_acc, 'test_avg_acc': test_class_acc, 'lr': scheduler.get_lr()[0] } for tag, value in info.items(): opt.writer.scalar_summary(tag, value, opt.step) save_ckpt(model, optimizer, scheduler, opt, 'last') logging.info( 'Saving the final model.Finish! Best Test Overall Acc {:.4f}, Its test avg acc {:.4f}. ' 'Last Test Overall Acc {:.4f}, Its test avg acc {:.4f}.'.format( best_test_overall_acc, avg_acc_when_best, test_overall_acc, test_class_acc))