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 main(): opt = OptInit().initialize() print('===> Creating dataloader...') test_dataset = GeoData.S3DIS(opt.test_path, 5, False, pre_transform=T.NormalizeScale()) test_loader = DataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=0) opt.n_classes = test_loader.dataset.num_classes if opt.no_clutter: opt.n_classes -= 1 print('===> Loading the network ...') opt.model = getattr(models, opt.model_name)(opt).to(opt.device) load_pretrained_models(opt) print('===> Start Evaluation ...') test(test_loader, opt.model, opt)
def main(): opt = OptInit().initialize() opt.batch_size = 1 os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpuNum print('===> Creating dataloader...') # def __init__(self, # root, # is_train=True, # is_validation=False, # is_test=False, # num_channel=5, # pre_transform=None, # pre_filter=None) test_dataset = BigredDataset(root=opt.test_path, is_train=False, is_validation=False, is_test=True, num_channel=5, pre_transform=T.NormalizeScale()) test_loader = DenseDataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=32) opt.n_classes = 2 print('len(test_loader):', len(test_loader)) print('phase: ', opt.phase) print('batch_size: ', opt.batch_size) print('use_cpu: ', opt.use_cpu) print('gpuNum: ', opt.gpuNum) print('multi_gpus: ', opt.multi_gpus) print('test_path: ', opt.test_path) print('in_channels: ', opt.in_channels) print('device: ', opt.device) print('===> Loading the network ...') model = DenseDeepGCN(opt).to(opt.device) load_package = torch.load(opt.pretrained_model) model, opt.best_value, opt.epoch = load_pretrained_models( model, opt.pretrained_model, opt.phase) pdb.set_trace() for item in load_package.keys(): if (item != 'optimizer_state_dict' and item != 'state_dict' and item != 'scheduler_state_dict'): print(str(item), load_package[item]) print('===> Start Evaluation ...') test(model, test_loader, opt)
def main(): opt = OptInit().get_args() logging.info('===> Creating dataloader...') 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 = test_loader.dataset.num_classes if opt.no_clutter: opt.n_classes -= 1 logging.info('===> Loading the network ...') model = DenseDeepGCN(opt).to(opt.device) model, opt.best_value, opt.epoch = load_pretrained_models( model, opt.pretrained_model, opt.phase) logging.info('===> Start Evaluation ...') test(model, test_loader, opt)
cur_shape_iou_tot += I/U cur_shape_iou_cnt += 1. if cur_shape_iou_cnt > 0: cur_shape_miou = cur_shape_iou_tot / cur_shape_iou_cnt shape_iou_tot += cur_shape_miou shape_iou_cnt += 1. shape_mIoU = shape_iou_tot / shape_iou_cnt part_iou = np.divide(part_intersect[1:], part_union[1:]) mean_part_iou = np.mean(part_iou) opt.printer.info("===> Category {}-{}, Part mIOU is{:.4f} \t ".format( opt.category_no, opt.category, mean_part_iou)) if __name__ == '__main__': opt = OptInit().initialize() opt.printer.info('===> Creating dataloader ...') test_dataset = PartNet(opt.data_dir, opt.dataset, opt.category, opt.level, 'val') test_loader = DenseDataLoader(test_dataset, batch_size=1, shuffle=True, num_workers=1) opt.n_classes = test_loader.dataset.num_classes opt.printer.info('===> Loading the network ...') model = DenseDeepGCN(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) test(model, test_loader, opt)
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!')