text stringlengths 1 93.6k |
|---|
n = count.item()
|
loss /= n
|
intersection, union, target = intersectionAndUnionGPU(
|
output, target, args.num_classes, args.ignore_label)
|
if args.DDP:
|
dist.all_reduce(intersection)
|
dist.all_reduce(union)
|
dist.all_reduce(target)
|
intersection, union, target = intersection.cpu(
|
).numpy(), union.cpu().numpy(), target.cpu().numpy()
|
intersection_meter.update(intersection)
|
union_meter.update(union)
|
target_meter.update(target)
|
accuracy = sum(intersection_meter.val) / \
|
(sum(target_meter.val) + 1e-10)
|
loss_meter.update(loss.item(), n)
|
batch_time.update(time.time() - end)
|
end = time.time()
|
# calculate remain time
|
current_iter = epoch * len(train_loader) + i + 1
|
remain_iter = max_iter - current_iter
|
remain_time = remain_iter * batch_time.avg
|
t_m, t_s = divmod(remain_time, 60)
|
t_h, t_m = divmod(t_m, 60)
|
remain_time = '{:02d}:{:02d}:{:02d}'.format(
|
int(t_h), int(t_m), int(t_s))
|
lr = scheduler.get_last_lr()
|
if isinstance(lr, list):
|
lr = [round(x, 8) for x in lr]
|
elif isinstance(lr, float):
|
lr = round(lr, 8)
|
if (i + 1) % args.print_freq == 0 and main_process():
|
memory = torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024
|
logger.info(
|
'Epoch: [{}/{}][{}/{}] '
|
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
|
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}) '
|
'Remain {remain_time} '
|
'Loss {loss_meter.val:.4f} '
|
'Lr: {lr} '
|
'Memory: {memory:.2f} GB '
|
'Accuracy {accuracy:.4f}.'.format(
|
epoch + 1,
|
args.total_epoches,
|
i + 1,
|
len(train_loader),
|
batch_time=batch_time,
|
data_time=data_time,
|
remain_time=remain_time,
|
loss_meter=loss_meter,
|
lr=lr,
|
accuracy=accuracy,
|
memory=memory))
|
# add scalar to writer
|
if main_process():
|
if isinstance(lr, list):
|
lr = lr[0]
|
if args.use_tensorboard:
|
writer.add_scalar(
|
'loss_train_batch',
|
loss_meter.val,
|
current_iter)
|
writer.add_scalar('mIoU_train_batch', np.mean(
|
intersection / (union + 1e-10)), current_iter)
|
writer.add_scalar('mAcc_train_batch', np.mean(
|
intersection / (target + 1e-10)), current_iter)
|
writer.add_scalar('allAcc_train_batch', accuracy, current_iter)
|
writer.add_scalar('lr_train_batch', lr, current_iter)
|
# else:
|
# metrics_dict = {'loss_train_batch': loss_meter.val,
|
# 'mIoU_train_batch': np.mean(intersection / (union + 1e-10)),
|
# 'mAcc_train_batch': np.mean(intersection / (target + 1e-10)),
|
# 'allAcc_train_batch': accuracy,
|
# 'lr_train_batch': lr}
|
iou_class = intersection_meter.sum / (union_meter.sum + 1e-10)
|
accuracy_class = intersection_meter.sum / (target_meter.sum + 1e-10)
|
mIoU = np.mean(iou_class)
|
mAcc = np.mean(accuracy_class)
|
allAcc = sum(intersection_meter.sum) / (sum(target_meter.sum) + 1e-10)
|
if main_process():
|
logger.info(
|
'Train result at epoch [{}/{}]: mIoU/mAcc/allAcc {:.4f}/{:.4f}/{:.4f}.'.format(
|
epoch +
|
1,
|
args.total_epoches,
|
mIoU,
|
mAcc,
|
allAcc))
|
return loss_meter.avg, mIoU, mAcc, allAcc
|
def validate(val_loader, model, criterion):
|
if main_process():
|
logger.info(
|
'>>>>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>>>>>>>')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.