def run_test_tusimple(net,
data_root,
work_dir,
exp_name,
griding_num,
use_aux,
distributed,
batch_size=8):
output_path = os.path.join(work_dir, exp_name + '.%d.txt' % get_rank())
fp = open(output_path, 'w')
loader = get_test_loader(batch_size, data_root, 'Tusimple', distributed)
for i, data in enumerate(dist_tqdm(loader)):
imgs, names = data
imgs = imgs.cuda()
with torch.no_grad():
out = net(imgs)
if len(out) == 2 and use_aux:
out = out[0]
for i, name in enumerate(names):
tmp_dict = {}
tmp_dict['lanes'] = generate_tusimple_lines(
out[i], imgs[0, 0].shape, griding_num)
tmp_dict['h_samples'] = [
160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270,
280, 290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390,
400, 410, 420, 430, 440, 450, 460, 470, 480, 490, 500, 510,
520, 530, 540, 550, 560, 570, 580, 590, 600, 610, 620, 630,
640, 650, 660, 670, 680, 690, 700, 710
]
tmp_dict['raw_file'] = name
tmp_dict['run_time'] = 10
json_str = json.dumps(tmp_dict)
fp.write(json_str + '\n')
fp.close()
def run_test(net,
data_root,
exp_name,
work_dir,
griding_num,
use_aux,
distributed,
batch_size=8):
# torch.backends.cudnn.benchmark = True
output_path = os.path.join(work_dir, exp_name)
if not os.path.exists(output_path) and is_main_process():
os.mkdir(output_path)
synchronize()
loader = get_test_loader(batch_size, data_root, 'CULane', distributed)
# import pdb;pdb.set_trace()
for i, data in enumerate(dist_tqdm(loader)):
imgs, names = data
imgs = imgs.cuda()
with torch.no_grad():
out = net(imgs)
if len(out) == 2 and use_aux:
out, seg_out = out
generate_lines(out,
imgs[0, 0].shape,
names,
output_path,
griding_num,
localization_type='rel',
flip_updown=True)
def train(net, data_loader, loss_dict, optimizer, scheduler,logger, epoch, metric_dict, use_aux):
net.train()
progress_bar = dist_tqdm(train_loader)
t_data_0 = time.time()
for b_idx, data_label in enumerate(progress_bar):
t_data_1 = time.time()
reset_metrics(metric_dict)
global_step = epoch * len(data_loader) + b_idx
t_net_0 = time.time()
results = inference(net, data_label, use_aux)
loss = calc_loss(loss_dict, results, logger, global_step)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step(global_step)
t_net_1 = time.time()
results = resolve_val_data(results, use_aux)
update_metrics(metric_dict, results)
if global_step % 20 == 0:
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
logger.add_scalar('metric/' + me_name, me_op.get(), global_step=global_step)
logger.add_scalar('meta/lr', optimizer.param_groups[0]['lr'], global_step=global_step)
if hasattr(progress_bar,'set_postfix'):
kwargs = {me_name: '%.3f' % me_op.get() for me_name, me_op in zip(metric_dict['name'], metric_dict['op'])}
progress_bar.set_postfix(loss = '%.3f' % float(loss),
data_time = '%.3f' % float(t_data_1 - t_data_0),
net_time = '%.3f' % float(t_net_1 - t_net_0),
**kwargs)
t_data_0 = time.time()
def train(net, data_loader, loss_dict, optimizer, scheduler, logger, epoch,
metric_dict, use_aux, local_rank):
net.train()
if local_rank != -1:
data_loader.sampler.set_epoch(epoch)
progress_bar = dist_tqdm(data_loader)
t_data_0 = time.time()
for b_idx, data_label in enumerate(progress_bar):
t_data_1 = time.time()
reset_metrics(metric_dict)
global_step = epoch * len(data_loader) + b_idx
t_net_0 = time.time()
results = inference(net, data_label, use_aux)
loss = calc_loss(loss_dict, results, logger, global_step)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step(global_step)
t_net_1 = time.time()
results = resolve_val_data(results, use_aux)
update_metrics(metric_dict, results)
if global_step % 20 == 0:
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
logger.scalar_summary('metric/' + me_name, 'train',
me_op.get(), global_step)
logger.scalar_summary('meta/lr', 'train',
optimizer.param_groups[0]['lr'], global_step)
if hasattr(progress_bar, 'set_postfix'):
kwargs = {
me_name: '%.3f' % me_op.get()
for me_name, me_op in zip(metric_dict['name'],
metric_dict['op'])
}
log_msg = 'Epoch{}/{}|Iter{}'.format(epoch, scheduler.total_epoch,
b_idx)
# log_msg = 'Epoch{}/{}|Iter{} '.format(epoch, scheduler.total_epoch,
# global_step, b_idx, len(data_loader), optimizer.param_groups[0]['lr'])
progress_bar.set_description(log_msg)
progress_bar.set_postfix(loss='%.3f' % float(loss), **kwargs)
t_data_0 = time.time()
def train(net, train_loader, criterion, optimizer, scheduler, logger, epoch,
device):
net.train()
progress_bar = dist_tqdm(train_loader)
t_data_0 = time.time()
total_loss = 0
for b_idx, (images, labels) in enumerate(progress_bar):
t_data_1 = time.time()
t_net_0 = time.time()
preds = net(images.to(device))
t_net_1 = time.time()
loss = criterion(preds, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
t_data_1 = time.time()
if hasattr(progress_bar, 'set_postfix'):
progress_bar.set_postfix(
loss='%.3f' % float(loss),
data_time='%.3f' % float(t_data_1 - t_data_0),
net_time='%.3f' % float(t_net_1 - t_net_0))
total_loss += loss.item()
logger.add_scalar('metric/loss',
total_loss / len(train_loader),
global_step=epoch)
logger.add_scalar('meta/lr',
optimizer.param_groups[0]['lr'],
global_step=epoch)
def test(net, data_loader, dataset, work_dir, logger, use_aux=True):
output_path = os.path.join(work_dir, 'culane_eval_tmp')
if not os.path.exists(output_path):
os.mkdir(output_path)
net.eval()
if dataset['name'] == 'CULane':
for i, data in enumerate(dist_tqdm(data_loader)):
imgs, names = data
imgs = imgs.cuda()
with torch.no_grad():
out = net(imgs)
if len(out) == 2 and use_aux:
out, seg_out = out
generate_lines(out,
imgs[0, 0].shape,
names,
output_path,
dataset['griding_num'],
localization_type='rel',
flip_updown=True)
res = call_culane_eval(dataset['data_root'], 'culane_eval_tmp',
work_dir)
TP, FP, FN = 0, 0, 0
for k, v in res.items():
val = float(v['Fmeasure']) if 'nan' not in v['Fmeasure'] else 0
val_tp, val_fp, val_fn = int(v['tp']), int(v['fp']), int(v['fn'])
TP += val_tp
FP += val_fp
FN += val_fn
logger.log('k:{} val{}'.format(k, val))
P = TP * 1.0 / (TP + FP)
R = TP * 1.0 / (TP + FN)
F = 2 * P * R / (P + R)
logger.log('F:{}'.format(F))
return F
def train(net, data_loader, loss_dict, optimizer, scheduler, logger, epoch,
metric_dict, cfg):
net.train()
progress_bar = dist_tqdm(data_loader)
t_data_0 = time.time()
# Pyten-20201019-FixBug
reset_metrics(metric_dict)
total_loss = 0
for b_idx, data_label in enumerate(progress_bar):
t_data_1 = time.time()
global_step = epoch * len(data_loader) + b_idx
t_net_0 = time.time()
results = inference(net, data_label, cfg.use_aux)
loss = calc_loss(loss_dict, results, logger, global_step, "train")
optimizer.zero_grad()
loss.backward()
# Pyten-20210201-ClipGrad
clip_grad_norm_(net.parameters(), max_norm=10.0)
optimizer.step()
total_loss = total_loss + loss.detach()
scheduler.step(global_step)
t_net_1 = time.time()
results = resolve_val_data(results, cfg.use_aux)
update_metrics(metric_dict, results)
if global_step % 20 == 0:
# Pyten-20210201-TransformImg
img = img_detrans(data_label[0][0])
logger.add_image("train_image/org", img, global_step=global_step)
logger.add_image("train_image/std",
data_label[0][0],
global_step=global_step)
if cfg.use_aux:
seg_color_out = decode_seg_color_map(results["seg_out"][0])
seg_color_label = decode_seg_color_map(data_label[2][0])
logger.add_image("train_seg/predict",
seg_color_out,
global_step=global_step,
dataformats='HWC')
logger.add_image("train_seg/label",
seg_color_label,
global_step=global_step,
dataformats='HWC')
cls_color_out = decode_cls_color_map(data_label[0][0],
results["cls_out"][0], cfg)
cls_color_label = decode_cls_color_map(data_label[0][0],
data_label[1][0], cfg)
logger.add_image("train_cls/predict",
cls_color_out,
global_step=global_step,
dataformats='HWC')
logger.add_image("train_cls/label",
cls_color_label,
global_step=global_step,
dataformats='HWC')
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
logger.add_scalar('train_metric/' + me_name,
me_op.get(),
global_step=global_step)
logger.add_scalar('train/meta/lr',
optimizer.param_groups[0]['lr'],
global_step=global_step)
if hasattr(progress_bar, 'set_postfix'):
kwargs = {
me_name: '%.4f' % me_op.get()
for me_name, me_op in zip(metric_dict['name'],
metric_dict['op'])
}
progress_bar.set_postfix(
loss='%.3f' % float(loss),
avg_loss='%.3f' % float(total_loss / (b_idx + 1)),
#data_time = '%.3f' % float(t_data_1 - t_data_0),
net_time='%.3f' % float(t_net_1 - t_net_0),
**kwargs)
t_data_0 = time.time()
dist_print("avg_loss_over_epoch", total_loss / len(data_loader))
def val(net, data_loader, loss_dict, scheduler, logger, epoch, metric_dict,
cfg):
net.eval()
progress_bar = dist_tqdm(data_loader)
t_data_0 = time.time()
reset_metrics(metric_dict)
total_loss = 0
with torch.no_grad():
for b_idx, data_label in enumerate(progress_bar):
t_data_1 = time.time()
# reset_metrics(metric_dict)
global_step = epoch * len(data_loader) + b_idx
t_net_0 = time.time()
# pdb.set_trace()
results = inference(net, data_label, cfg.use_aux)
loss = calc_loss(loss_dict, results, logger, global_step, "val")
total_loss = total_loss + loss.detach()
t_net_1 = time.time()
results = resolve_val_data(results, cfg.use_aux)
update_metrics(metric_dict, results)
if global_step % 20 == 0:
# Pyten-20210201-TransformImg
img = img_detrans(data_label[0][0])
logger.add_image("val_image/org", img, global_step=global_step)
logger.add_image("val_image/std",
data_label[0][0],
global_step=global_step)
if cfg.use_aux:
# import pdb; pdb.set_trace()
seg_color_out = decode_seg_color_map(results["seg_out"][0])
seg_color_label = decode_seg_color_map(data_label[2][0])
logger.add_image("val_seg/predict",
seg_color_out,
global_step=global_step,
dataformats='HWC')
logger.add_image("val_seg/label",
seg_color_label,
global_step=global_step,
dataformats='HWC')
cls_color_out = decode_cls_color_map(data_label[0][0],
results["cls_out"][0],
cfg)
cls_color_label = decode_cls_color_map(data_label[0][0],
data_label[1][0], cfg)
logger.add_image("val_cls/predict",
cls_color_out,
global_step=global_step,
dataformats='HWC')
logger.add_image("val_cls/label",
cls_color_label,
global_step=global_step,
dataformats='HWC')
if hasattr(progress_bar, 'set_postfix'):
kwargs = {
me_name: '%.4f' % me_op.get()
for me_name, me_op in zip(metric_dict['name'],
metric_dict['op'])
}
progress_bar.set_postfix(
loss='%.3f' % float(loss),
avg_loss='%.3f' % float(total_loss / (b_idx + 1)),
# data_time = '%.3f' % float(t_data_1 - t_data_0),
net_time='%.3f' % float(t_net_1 - t_net_0),
**kwargs)
t_data_0 = time.time()
dist_print("avg_loss_over_epoch", total_loss / len(data_loader))
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
logger.add_scalar('val_metric/' + me_name,
me_op.get(),
global_step=epoch)
# Pyten-20201019-SaveBestMetric
update_best_metric = True
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
if me_name == "iou":
continue
cur_metric = me_op.get()
if cur_metric < metric_dict["best_metric"][me_name]:
update_best_metric = False
if update_best_metric:
for me_name, me_op in zip(metric_dict['name'], metric_dict['op']):
metric_dict["best_metric"][me_name] = me_op.get()
cfg.best_epoch = epoch
dist_print("best metric updated!(epoch%d)" % epoch)
def run_test(net,
data_root,
exp_name,
work_dir,
distributed,
cfg,
batch_size=1):
# torch.backends.cudnn.benchmark = True
output_path = os.path.join(work_dir, exp_name)
if not os.path.exists(output_path) and is_main_process():
os.mkdir(output_path)
synchronize()
row_anchor = np.linspace(90, 255, 128).tolist()
col_sample = np.linspace(0, 1640 - 1, 256)
col_sample_w = col_sample[1] - col_sample[0]
loader = get_test_loader(batch_size, data_root, 'CULane', distributed)
filter_f = lambda x: int(np.round(x))
# import pdb;pdb.set_trace()
for i, data in enumerate(dist_tqdm(loader)):
imgs, names = data
imgs = imgs.cuda()
with torch.no_grad():
out = net(imgs)
for j in range(len(names)):
name = names[j]
line_save_path = os.path.join(output_path, name[:-3] + 'lines.txt')
save_dir, _ = os.path.split(line_save_path)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
with open(line_save_path, 'w') as writer:
lane_exit_out = out["lane_exit_out"].sigmoid()
lane_exit_out = lane_exit_out > cfg.thresh_lc
for lane_index in range(lane_exit_out.size(1)):
if lane_exit_out[0][lane_index] == True:
x_list = []
y_list = []
vertex_wise_confidence_out = out[
"vertex_wise_confidence_out_" +
str(lane_index + 1)].sigmoid()
vertex_wise_confidence_out = vertex_wise_confidence_out > cfg.thresh_vc
row_wise_vertex_location_out = F.log_softmax(
out["row_wise_vertex_location_out_" +
str(lane_index + 1)],
dim=0)
row_wise_vertex_location_out = torch.argmax(
row_wise_vertex_location_out, dim=0)
row_wise_vertex_location_out[
~vertex_wise_confidence_out] = 256
row_wise_vertex_location_out = row_wise_vertex_location_out.detach(
).cpu().numpy()
estimator = RANSACRegressor(random_state=42,
min_samples=2,
residual_threshold=10.0)
##model = make_pipeline(PolynomialFeatures(2), estimator)
for k in range(row_wise_vertex_location_out.shape[0]):
if row_wise_vertex_location_out[k] != 256:
x = row_wise_vertex_location_out[
k] * col_sample_w
y = row_anchor[k] / 256 * 590
x_list.append(x)
y_list.append(y)
#writer.write('%d %d ' % (filter_f(row_wise_vertex_location_out[k] * col_sample_w), filter_f(row_anchor[k] / 256 * 590)))
#writer.write('\n')
if len(x_list) <= 1:
continue
X = np.array(x_list)
y = np.array(y_list)
y = y[:, np.newaxis]
y_plot = np.linspace(y.min(), y.max())
estimator.fit(y, X)
x_plot = estimator.predict(y_plot[:, np.newaxis])
for x, y in zip(x_plot, y_plot):
writer.write('%d %d ' % (filter_f(x), filter_f(y)))
writer.write('\n')