def test_cluster_det(model, cfg, logger): if cfg.load_from: load_checkpoint(model, cfg.load_from) for k, v in cfg.model['kwargs'].items(): setattr(cfg.test_data, k, v) dataset = build_dataset(cfg.test_data) processor = build_processor(cfg.stage) losses = [] output_probs = [] if cfg.gpus == 1: data_loader = build_dataloader(dataset, processor, cfg.batch_size_per_gpu, cfg.workers_per_gpu, train=False) model = MMDataParallel(model, device_ids=range(cfg.gpus)) if cfg.cuda: model.cuda() model.eval() for i, data in enumerate(data_loader): with torch.no_grad(): output, loss = model(data, return_loss=True) losses += [loss.item()] if i % cfg.log_config.interval == 0: if dataset.ignore_meta: logger.info('[Test] Iter {}/{}'.format( i, len(data_loader))) else: logger.info('[Test] Iter {}/{}: Loss {:.4f}'.format( i, len(data_loader), loss)) if cfg.save_output: output = output.view(-1) prob = output.data.cpu().numpy() output_probs.append(prob) else: raise NotImplementedError if not dataset.ignore_meta: avg_loss = sum(losses) / len(losses) logger.info('[Test] Overall Loss {:.4f}'.format(avg_loss)) if cfg.save_output: fn = os.path.basename(cfg.load_from) opath = os.path.join(cfg.work_dir, fn[:fn.rfind('.pth')] + '.npz') meta = { 'tot_inst_num': dataset.inst_num, 'proposal_folders': cfg.test_data.proposal_folders, } print('dump output to {}'.format(opath)) output_probs = np.concatenate(output_probs).ravel() np.savez_compressed(opath, data=output_probs, meta=meta)
def get_data(model, output_path, cfg, is_test = False, num_runs = 1): if is_test: dataset = build_dataset(cfg.test_data) else: dataset = build_dataset(cfg.train_data) processor = build_processor(cfg.stage) data_loader = build_dataloader( dataset, processor, cfg.batch_size_per_gpu, cfg.workers_per_gpu, train=False) model = MMDataParallel(model, device_ids=range(cfg.gpus)) if cfg.cuda: model.cuda() all_feas = [] all_iops = [] for k in range(num_runs): for i, data in enumerate(data_loader): print('\t running ' + str(k) + 'th run, ' + str(i) + 'th batch') with torch.no_grad(): hist_std_fea, label, iop = model(data, return_loss = False, return_data = True) fea = hist_std_fea.cpu().numpy() bs, dim = fea.shape for j in range(bs): this_fea = fea[j].tolist() all_feas.append(this_fea) all_iops.append(float(iop.cpu()[j])) lines = [] print ('in total we have ' + str(len(all_iops)) + ' proposals') for fea, iop in zip(all_feas, all_iops): f_str = [str(f) for f in fea ] f_str.append(str(iop)) line = ' '.join(f_str) line += '\n' lines.append(line) f = open(output_path, 'w') f.writelines(lines) f.close()
def train_cluster_det(model, cfg, logger): # prepare data loaders for k, v in cfg.model['kwargs'].items(): setattr(cfg.train_data, k, v) dataset = build_dataset(cfg.train_data) processor = build_processor(cfg.stage) data_loaders = [ build_dataloader(dataset, processor, cfg.batch_size_per_gpu, cfg.workers_per_gpu, train=True, shuffle=True) ] # train if cfg.distributed: _dist_train(model, data_loaders, cfg) else: _single_train(model, data_loaders, cfg)
def train_cluster(model, cfg, logger, batch_processor): # prepare data loaders for k, v in cfg.model['kwargs'].items(): setattr(cfg.train_data, k, v) dataset = build_dataset(cfg.train_data) assert not dataset.ignore_label, 'Please specify label_path for training' processor = build_processor(cfg.stage) data_loaders = [ build_dataloader(dataset, processor, cfg.batch_size_per_gpu, cfg.workers_per_gpu, train=True, shuffle=True) ] # train if cfg.distributed: _dist_train(model, data_loaders, batch_processor, cfg) else: _single_train(model, data_loaders, batch_processor, cfg)
def test_cluster_seg(model, cfg, logger): assert osp.isfile(cfg.pred_iou_score) if cfg.load_from: logger.info('load pretrained model from: {}'.format(cfg.load_from)) load_checkpoint(model, cfg.load_from, strict=True, logger=logger) for k, v in cfg.model['kwargs'].items(): setattr(cfg.test_data, k, v) setattr(cfg.test_data, 'pred_iop_score', cfg.pred_iop_score) dataset = build_dataset(cfg.test_data) processor = build_processor(cfg.stage) inst_num = dataset.inst_num # read pred_scores from file and do sanity check d = np.load(cfg.pred_iou_score, allow_pickle=True) pred_scores = d['data'] meta = d['meta'].item() assert inst_num == meta['tot_inst_num'], '{} vs {}'.format( inst_num, meta['tot_inst_num']) proposals = [fn_node for fn_node, _ in dataset.tot_lst] _proposals = [] fn_node_pattern = '*_node.npz' for proposal_folder in meta['proposal_folders']: fn_clusters = sorted( glob.glob(osp.join(proposal_folder, fn_node_pattern))) _proposals.extend([fn_node for fn_node in fn_clusters]) assert proposals == _proposals, '{} vs {}'.format(len(proposals), len(_proposals)) losses = [] pred_outlier_scores = [] stats = {'mean': []} if cfg.gpus == 1: data_loader = build_dataloader(dataset, processor, cfg.test_batch_size_per_gpu, cfg.workers_per_gpu, train=False) model = MMDataParallel(model, device_ids=range(cfg.gpus)) if cfg.cuda: model.cuda() model.eval() for i, data in enumerate(data_loader): with torch.no_grad(): output, loss = model(data, return_loss=True) losses += [loss.item()] if i % cfg.log_config.interval == 0: if dataset.ignore_label: logger.info('[Test] Iter {}/{}'.format( i, len(data_loader))) else: logger.info('[Test] Iter {}/{}: Loss {:.4f}'.format( i, len(data_loader), loss)) if cfg.save_output: output = F.softmax(output, dim=1) output = output[:, 1, :] scores = output.data.cpu().numpy() pred_outlier_scores.extend(list(scores)) stats['mean'] += [scores.mean()] else: raise NotImplementedError if not dataset.ignore_label: avg_loss = sum(losses) / len(losses) logger.info('[Test] Overall Loss {:.4f}'.format(avg_loss)) scores_mean = 1. * sum(stats['mean']) / len(stats['mean']) logger.info('mean of pred_outlier_scores: {:.4f}'.format(scores_mean)) # save predicted scores if cfg.save_output: if cfg.load_from: fn = osp.basename(cfg.load_from) else: fn = 'random' opath = osp.join(cfg.work_dir, fn[:fn.rfind('.pth')] + '.npz') meta = { 'tot_inst_num': inst_num, 'proposal_folders': cfg.test_data.proposal_folders, } logger.info('dump pred_outlier_scores ({}) to {}'.format( len(pred_outlier_scores), opath)) np.savez_compressed(opath, data=pred_outlier_scores, meta=meta) # post-process outlier_scores = { fn_node: outlier_score for (fn_node, _), outlier_score in zip(dataset.lst, pred_outlier_scores) } # de-overlap (w gcn-s) pred_labels_w_seg = deoverlap(pred_scores, proposals, inst_num, cfg.th_pos, cfg.th_iou, outlier_scores=outlier_scores, th_outlier=cfg.th_outlier, keep_outlier=cfg.keep_outlier) # de-overlap (wo gcn-s) pred_labels_wo_seg = deoverlap(pred_scores, proposals, inst_num, cfg.th_pos, cfg.th_iou) # save predicted labels if cfg.save_output: ofn_meta_w_seg = osp.join(cfg.work_dir, 'pred_labels_w_seg.txt') ofn_meta_wo_seg = osp.join(cfg.work_dir, 'pred_labels_wo_seg.txt') print('save predicted labels to {} and {}'.format( ofn_meta_w_seg, ofn_meta_wo_seg)) pred_idx2lb_w_seg = list2dict(pred_labels_w_seg, ignore_value=-1) pred_idx2lb_wo_seg = list2dict(pred_labels_wo_seg, ignore_value=-1) write_meta(ofn_meta_w_seg, pred_idx2lb_w_seg, inst_num=inst_num) write_meta(ofn_meta_wo_seg, pred_idx2lb_wo_seg, inst_num=inst_num) # evaluation if not dataset.ignore_label: gt_labels = dataset.labels print('==> evaluation (with gcn-s)') for metric in cfg.metrics: evaluate(gt_labels, pred_labels_w_seg, metric) print('==> evaluation (without gcn-s)') for metric in cfg.metrics: evaluate(gt_labels, pred_labels_wo_seg, metric)
def test_cluster_det(model, cfg, logger): if cfg.load_from: logger.info('load pretrained model from: {}'.format(cfg.load_from)) load_checkpoint(model, cfg.load_from, strict=True, logger=logger) for k, v in cfg.model['kwargs'].items(): setattr(cfg.test_data, k, v) dataset = build_dataset(cfg.test_data) processor = build_processor(cfg.stage) losses = [] pred_scores = [] if cfg.gpus == 1: data_loader = build_dataloader(dataset, processor, cfg.test_batch_size_per_gpu, cfg.workers_per_gpu, train=False) model = MMDataParallel(model, device_ids=range(cfg.gpus)) if cfg.cuda: model.cuda() model.eval() for i, data in enumerate(data_loader): with torch.no_grad(): output, loss = model(data, return_loss=True) losses += [loss.item()] if i % cfg.log_config.interval == 0: if dataset.ignore_label: logger.info('[Test] Iter {}/{}'.format( i, len(data_loader))) else: logger.info('[Test] Iter {}/{}: Loss {:.4f}'.format( i, len(data_loader), loss)) if cfg.save_output: output = output.view(-1) prob = output.data.cpu().numpy() pred_scores.append(prob) else: raise NotImplementedError if not dataset.ignore_label: avg_loss = sum(losses) / len(losses) logger.info('[Test] Overall Loss {:.4f}'.format(avg_loss)) # save predicted scores if cfg.save_output: if cfg.load_from: fn = os.path.basename(cfg.load_from) else: fn = 'random' opath = os.path.join(cfg.work_dir, fn[:fn.rfind('.pth')] + '.npz') meta = { 'tot_inst_num': dataset.inst_num, 'proposal_folders': cfg.test_data.proposal_folders, } print('dump pred_score to {}'.format(opath)) pred_scores = np.concatenate(pred_scores).ravel() np.savez_compressed(opath, data=pred_scores, meta=meta) # de-overlap proposals = [fn_node for fn_node, _ in dataset.lst] pred_labels = deoverlap(pred_scores, proposals, dataset.inst_num, cfg.th_pos, cfg.th_iou) # save predicted labels if cfg.save_output: ofn_meta = os.path.join(cfg.work_dir, 'pred_labels.txt') print('save predicted labels to {}'.format(ofn_meta)) pred_idx2lb = list2dict(pred_labels, ignore_value=-1) write_meta(ofn_meta, pred_idx2lb, inst_num=dataset.inst_num) # evaluation if not dataset.ignore_label: print('==> evaluation') gt_labels = dataset.labels for metric in cfg.metrics: evaluate(gt_labels, pred_labels, metric)