https://github.com/Jiaqi-zhang/HoughLaneNet
Tip revision: 9d9effb1befbcf2c71cc1a0b44664cb3cecc223a authored by Jiaqi-Zhang on 06 October 2023, 08:01:31 UTC
Update README.md
Update README.md
Tip revision: 9d9effb
metrics_test_culane.py
import argparse
import os
import os.path as osp
import pickle
import time
import warnings
import mmcv
import torch
from mmcv import Config, DictAction
from mmcv.cnn import fuse_conv_bn
from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
from mmcv.runner import (get_dist_info, init_dist, load_checkpoint,
wrap_fp16_model)
# from mmdet.apis import multi_gpu_test, single_gpu_test
from mmdet.datasets import (build_dataloader, build_dataset,
replace_ImageToTensor)
from mmdet.models import build_detector
import tqdm
from functools import partial
import torch.distributed as dist
import torch.multiprocessing as mp
from tools.lane_tools.culane.culane_metric import eval_predictions
def parse_args():
parser = argparse.ArgumentParser(
description='MMDet test (and eval) a model')
parser.add_argument('config', help='test config file path')
parser.add_argument('checkpoint', help='checkpoint file')
parser.add_argument(
'--work-dir',
help='the directory to save the file containing evaluation metrics')
parser.add_argument('--out', help='output result file in pickle format')
parser.add_argument(
'--fuse-conv-bn',
action='store_true',
help='Whether to fuse conv and bn, this will slightly increase'
'the inference speed')
parser.add_argument(
'--format-only',
action='store_true',
help='Format the output results without perform evaluation. It is'
'useful when you want to format the result to a specific format and '
'submit it to the test server')
parser.add_argument(
'--eval',
action='store_true',
help='evaluation metrics, which depends on the dataset, e.g.'
' "Acc" for TuSimple, "F1" for CULane')
parser.add_argument('--show', action='store_true', help='show results')
parser.add_argument(
'--show-dir', help='directory where painted images will be saved')
parser.add_argument(
'--show-score-thr',
type=float,
default=0.3,
help='score threshold (default: 0.3)')
parser.add_argument(
'--gpu-collect',
action='store_true',
help='whether to use gpu to collect results.')
parser.add_argument(
'--tmpdir',
help='tmp directory used for collecting results from multiple '
'workers, available when gpu-collect is not specified')
parser.add_argument(
'--cfg-options',
nargs='+',
action=DictAction,
help='override some settings in the used config, the key-value pair '
'in xxx=yyy format will be merged into config file. If the value to '
'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
'Note that the quotation marks are necessary and that no white space '
'is allowed.')
parser.add_argument(
'--options',
nargs='+',
action=DictAction,
help='custom options for evaluation, the key-value pair in xxx=yyy '
'format will be kwargs for dataset.evaluate() function (deprecate), '
'change to --eval-options instead.')
parser.add_argument(
'--eval-options',
nargs='+',
action=DictAction,
help='custom options for evaluation, the key-value pair in xxx=yyy '
'format will be kwargs for dataset.evaluate() function')
parser.add_argument(
'--launcher',
choices=['none', 'pytorch', 'slurm', 'mpi'],
default='none',
help='job launcher')
parser.add_argument('--local_rank', type=int, default=0)
args = parser.parse_args()
if 'LOCAL_RANK' not in os.environ:
os.environ['LOCAL_RANK'] = str(args.local_rank)
if args.options and args.eval_options:
raise ValueError(
'--options and --eval-options cannot be both '
'specified, --options is deprecated in favor of --eval-options')
if args.options:
warnings.warn('--options is deprecated in favor of --eval-options')
args.eval_options = args.options
return args
def generate_culane_lines(out):
out = out * (1640 / 640) # B, 4, 360
THRESHOLD = 60
# THRESHOLD = 10
# out shape: 4, 360
# (590, 1640, 3)
lanes = [] # B, k, ny, 2
for i in range(out.shape[0]):
x = out[i, :]
mask = x != 1640
# Discard if no line
if torch.count_nonzero(mask) >= THRESHOLD:
y = torch.arange(0, len(x)) * (590 / 360)
lane = torch.stack([x, y], dim=1)
lane = lane[mask.nonzero(as_tuple=True)]
lanes.append(lane)
return lanes
def write_culane_data(test_data, save_predict_path):
names, pre_lanes = test_data
for i, name in enumerate(names):
lanes = generate_culane_lines(pre_lanes[i])
spred_file_path = os.path.join(save_predict_path, os.path.split(name)[0])
os.makedirs(spred_file_path, exist_ok=True)
with open(os.path.join(spred_file_path, f"{os.path.split(name)[-1][0:-4]}.lines.txt"), 'w') as fp:
for lane in lanes:
lane_str = " ".join([f"{x:.4f} {y:.4f}" for [x, y] in lane])
fp.write(lane_str + '\n')
def single_gpu_test(model, data_loader, anno_dir, out_dir=None, training_test=False):
model.eval()
results = []
total_num, total_run_time = 0, 0
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
torch.cuda.empty_cache()
with torch.no_grad():
tic = time.time()
result = model(return_loss=False, rescale=True, training_test=training_test, **data)
toc = time.time()
lane_map, idx_lanes = result[0], result[1]
pre_lanes = torch.argmax(lane_map, dim=3) # B, 5, 360, 640
pre_index = torch.argmax(idx_lanes, dim=3).to(lane_map.device) # B, 5, 360, 2
pre_lanes[pre_index == 0] = 640 # B, 5, 360
# get lanes
img_metas = data['img_metas'].data
names = [img_meta['sub_img_name'] for img_meta in img_metas[0]]
total_run_time += (toc - tic) * 1000
total_num += len(names)
results.append([names, pre_lanes.cpu()])
batch_size = len(result[0]) if isinstance(result, list) else len(result)
for _ in range(batch_size):
prog_bar.update()
# get metrics
save_predict_path = os.path.join(out_dir, PRED_SAVE_DIR)
os.makedirs(save_predict_path, exist_ok=True)
with mp.Pool(processes=4) as pool:
f = partial(write_culane_data, save_predict_path=save_predict_path)
for _ in pool.imap_unordered(f, results): pass
eval_result = eval_predictions(pred_dir=save_predict_path,
anno_dir=anno_dir,
list_path=os.path.join(anno_dir, ANNO_TXT_PATH),
official=True,
sequential=False)
eval_result['FPS'] = 1000. / (total_run_time / total_num)
header = '=' * 40
print(header)
for metric, value in eval_result.items():
if isinstance(value, float):
print('{}: {:.4f}'.format(metric, value))
else:
print('{}: {}'.format(metric, value))
print(header)
return
def multi_gpu_test(model, data_loader, anno_dir, out_dir, training_test=False):
model.eval()
results = []
total_num, total_run_time = 0, 0
dataset = data_loader.dataset
rank, world_size = get_dist_info()
if rank == 0:
prog_bar = mmcv.ProgressBar(len(dataset))
time.sleep(2) # This line can prevent deadlock problem in some cases.
for i, data in enumerate(data_loader):
torch.cuda.empty_cache()
with torch.no_grad():
tic = time.perf_counter()
result = model(return_loss=False, rescale=True, training_test=training_test, **data)
toc = time.perf_counter()
lane_map, idx_lanes = result[0], result[1]
pre_lanes = torch.argmax(lane_map, dim=3) # B, 5, 360, 640
pre_index = torch.argmax(idx_lanes, dim=3).to(lane_map.device) # B, 5, 360, 2
pre_lanes[pre_index == 0] = 640 # B, 5, 360
# get lanes
img_metas = data['img_metas'].data
names = [img_meta['sub_img_name'] for img_meta in img_metas[0]]
total_run_time += (toc - tic) * 1000
total_num += len(names)
results.append([names, pre_lanes.cpu()])
if rank == 0:
batch_size = len(result[0]) if isinstance(result, list) else len(result)
for _ in range(batch_size * world_size):
prog_bar.update()
save_predict_path = os.path.join(out_dir, PRED_SAVE_DIR)
os.makedirs(save_predict_path, exist_ok=True)
with mp.Pool(processes=4) as pool:
f = partial(write_culane_data, save_predict_path=save_predict_path)
jobs = pool.imap_unordered(f, results)
if rank == 0:
jobs = tqdm.tqdm(jobs, total=len(results))
for _ in jobs: pass
if rank == 0:
eval_result = eval_predictions(pred_dir=save_predict_path,
anno_dir=anno_dir,
list_path=os.path.join(anno_dir, ANNO_TXT_PATH),
official=True,
sequential=False)
eval_result['FPS'] = 1000. / (total_run_time / total_num)
header = '=' * 40
print(header)
for metric, value in eval_result.items():
if isinstance(value, float):
print('{}: {:.4f}'.format(metric, value))
else:
print('{}: {}'.format(metric, value))
print(header)
return
def main():
args = parse_args()
# assert args.out or args.eval or args.format_only or args.show \
# or args.show_dir, \
# ('Please specify at least one operation (save/eval/format/show the '
# 'results / save the results) with the argument "--out", "--eval"'
# ', "--format-only", "--show" or "--show-dir"')
if args.eval and args.format_only:
raise ValueError('--eval and --format_only cannot be both specified')
if args.out is not None and not args.out.endswith(('.pkl', '.pickle')):
raise ValueError('The output file must be a pkl file.')
cfg = Config.fromfile(args.config)
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
if cfg.model.get('neck'):
if isinstance(cfg.model.neck, list):
for neck_cfg in cfg.model.neck:
if neck_cfg.get('rfp_backbone'):
if neck_cfg.rfp_backbone.get('pretrained'):
neck_cfg.rfp_backbone.pretrained = None
elif cfg.model.neck.get('rfp_backbone'):
if cfg.model.neck.rfp_backbone.get('pretrained'):
cfg.model.neck.rfp_backbone.pretrained = None
# in case the test dataset is concatenated
samples_per_gpu = 1
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
if samples_per_gpu > 1:
# Replace 'ImageToTensor' to 'DefaultFormatBundle'
cfg.data.test.pipeline = replace_ImageToTensor(
cfg.data.test.pipeline)
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
samples_per_gpu = max(
[ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
if samples_per_gpu > 1:
for ds_cfg in cfg.data.test:
ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
rank, _ = get_dist_info()
# allows not to create
if args.work_dir is not None and rank == 0:
mmcv.mkdir_or_exist(osp.abspath(args.work_dir))
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint.get('meta', {}):
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
single_gpu_test(model, data_loader, cfg.data.test.data_root, cfg.work_dir, training_test=False)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
multi_gpu_test(model, data_loader, cfg.data.test.data_root, cfg.work_dir, training_test=False)
if __name__ == '__main__':
ANNO_TXT_PATH = './list/test.txt'
# ANNO_TXT_PATH = './list/test_split/test7_cross.txt'
PRED_SAVE_DIR = 'lane_text'
main()