目标检测的Tricks | 【Trick10】工具类文件调用(coco评价指标包、日志工具、Tensorboard工具...)

目标检测的Tricks | 【Trick10】工具类文件调用(coco评价指标包、日志工具、Tensorboard工具...),第1张


如有错误,恳请指出。


对于一些评价指标与常见的日志记录与输出,除了自己写或者是使用普通的python提供的工具包,比如说是logging等,其实还可以使用一些大佬写好的工具函数来调用,就拿我目前看过为数不多的项目代码,对于日志信息记录啥的,基本都会使用一个MetricLogger的工具类,还有记录数值的也有SmoothedValue这么一个工具类。对于目标检测中的验证,也有coco评价指标包来进行调用。

文章目录
  • 1. coco评价指标包调用
  • 2. 日志工具代码调用
  • 3. Tensorboard工具调用

1. coco评价指标包调用

在训练完一个epoch数据之后,一般需要进行一个验证不过也可以全部训练完再进行验证。而在yolov3spp项目中,这里将预测结果送入官网写的计算coco评价指标包里,计算出coco评价指标:mAP@[IoU=0.50:0.95]、mAP@[IoU=0.50]、mAR@[IoU=0.50:0.95]等。而且这个工具包只需要在验证集进行调用即可,训练集训练与最后测试的过程是不需要用的。

对于这些工具类的文件代码,其实会掉包使用就好了。

调用流程如下:

# 遍历一遍验证集,将标签信息全部读取一遍,方便使用pycocotools来计算map,以下两条代码是等价的
# 根据val_dataset来获取img与target
# coco = get_coco_api_from_dataset(val_dataset)
coco = get_coco_api_from_dataset(data_loader.dataset)
coco_evaluator = CocoEvaluator(coco, iou_types)        # iou_types: ['bbox']
...
# 获取后处理后的预测信息,此处的output包含对这张图像的:预测边界框信息、预测类别、预测置信度
# 一张图像对应了这张图像的一个信息字典(每个字典包含这三个信息)
res = {img_id: output for img_id, output in zip(img_index, outputs)}
coco_evaluator.update(res)     # 对当前验证的batch进行更新保留
coco_evaluator.synchronize_between_processes()
coco_evaluator.accumulate()
coco_evaluator.summarize()
# 所需的评价指标:{list: 12}
result_info = coco_evaluator.coco_eval[iou_types[0]].stats.tolist()

对于这里的输出结果,result_info的内容,如下所示;

# COCO results:
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.597
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.816
 Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.658
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.221
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.467
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.688
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.477
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.684
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.698
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.352
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.587
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.769

如果对这些指标不认识的,可以查看我曾经写过的一篇博文:目标检测中的评估指标:PR曲线、AP、mAP,下面简要介绍:

# 这两行分别表示IoU取不同时候的mAP结果(分别阈值取0.5与0.75时的结果)
APIoU=.50% AP at IoU=.50 (PASCAL VOC metric)   # 该指标就是pascol voc的评价指标
APIoU=.75% AP at IoU=.75 (strict metric)

# 表示当 IoU从0.5~0.95这段范围中,间隔为0.05,一共10个IoU值上mAP的均值,这个是coco数据集上最主要的评判指标
AP% AP at IoU=.50:.05:.95 (primary challenge metric)   # 该指标是coco数据集的评价指标

所以在yolospp代码中,这里取第一,第二,第八行:

# 平均mAP指标:coco数据集上最主要的评判指标
Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] 
# IoU取0.5时的mAP结果:pascol voc的评价指标
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] 
 # 平均mAP指标:coco数据集上最主要的评判指标
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] 

如下所示:

# 遍历一遍验证集,将标签信息全部读取一遍,方便使用pycocotools来计算map
coco = get_coco_api_from_dataset(val_dataset)

# 每训练完一个epoch,都会进行验证一次,返回的结果就是输出的一些列coco的指标
result_info = train_util.evaluate(model, val_datasetloader, coco=coco, device=device)

# 获取验证结果
coco_mAP = result_info[0]
voc_mAP = result_info[1]
coco_mAR = result_info[8]

2. 日志工具代码调用

这里主要是介绍MetricLogger类的调用流程。

  • 1)以验证过程为例,在evaluate函数使用如下:
# 构建MetricLogger类对象,选择用空格符来间隔信息,默认是\tab
metric_logger = utils.MetricLogger(delimiter="  ")
...
# 这里的img_index对于的是哪一张图像的索引
# iterable: data_loader 表示不断加载数据出来,一次取出一个batch_size的img
#           由于这里自定义了batch,设置了collate_fn函数,所以还会输出其他内容: targets, paths, shapes, img_index
# print_freq: 100 表示100轮打印一次参数
# header: 开头打印的内容,这里为"Test: "
for imgs, targets, paths, shapes, img_index in metric_logger.log_every(data_loader, 100, header):
    ...
    metric_logger.update(model_time=model_time, evaluator_time=evaluator_time)
# 收集所有进程的统计信息
metric_logger.synchronize_between_processes()
print("Averaged stats:", metric_logger)

验证过程中打印的内容:

Test:   [   0/1456]  eta: 0:06:45.600605  model_time: 0.1178 (0.1178)  evaluator_time: 0.0083 (0.0083)  time: 0.2786  data: 0.1483  max mem: 0
Test:   [ 100/1456]  eta: 0:02:30.134258  model_time: 0.1056 (0.1006)  evaluator_time: 0.0055 (0.0071)  time: 0.1101  data: 0.0001  max mem: 0
Test:   [ 200/1456]  eta: 0:02:48.761989  model_time: 0.3777 (0.1227)  evaluator_time: 0.0065 (0.0069)  time: 0.3621  data: 0.0001  max mem: 0
...
Test:  Total time: 0:08:30 (0.3506 s / it)
Averaged stats: model_time: 0.1293 (0.3195)  evaluator_time: 0.0044 (0.0064)
  • 2)以训练过程为例,在train_one_epoch函数使用如下:
metric_logger = utils.MetricLogger(delimiter="  ")
metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))
header = 'Epoch: [{}]'.format(epoch)
for i, (imgs, targets, paths, _, _) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
    ...
    now_lr = optimizer.param_groups[0]["lr"]
    metric_logger.update(loss=losses_reduced, **loss_dict_reduced)
    metric_logger.update(lr=now_lr)
# 收集所有进程的统计信息
metric_logger.synchronize_between_processes()
print("lr and loss stats:", metric_logger)

训练过程中打印的内容:

Epoch: [0]  [   0/1430]  eta: 0:25:21.825325  lr: 0.000001  loss: 19.4350 (19.4350)  box_loss: 7.8804 (7.8804)  obj_loss: 4.9758 (4.9758)  class_loss: 6.5787 (6.5787)  time: 1.0642  data: 0.2971  max mem: 0
Epoch: [0]  [  50/1430]  eta: 0:12:22.615927  lr: 0.000051  loss: 14.0581 (18.1472)  box_loss: 5.0861 (7.0637)  obj_loss: 3.2172 (5.4319)  class_loss: 5.7547 (5.6516)  time: 0.5375  data: 0.0001  max mem: 0
Epoch: [0]  [ 100/1430]  eta: 0:11:26.523765  lr: 0.000101  loss: 11.8562 (16.4655)  box_loss: 4.0006 (6.1806)  obj_loss: 2.8863 (4.7584)  class_loss: 4.9694 (5.5265)  time: 0.5013  data: 0.0001  max mem: 0
...
Epoch: [0] Total time: 0:11:56 (0.5012 s / it)
lr and loss stats: lr: 0.001000  loss: 2.7556 (9.9921)  box_loss: 0.7867 (4.2556)  obj_loss: 1.0168 (2.7375)  class_loss: 0.9520 (2.9990)
  • 补充说明:

在MetricLogger类,如果有想要增加变量,并其的更新信息进行打印,其实只需要进行update即可,也就是调用函数metric_logger.update(lr=now_lr),这个函数会自动的将参数lr变成一个字典遍历,自动构建一个类来存储其不断更新的信息,部分代码见如下:

class MetricLogger(object):
    def __init__(self, delimiter="\t"):
        # 存储参数变量,且不断更新
        self.meters = defaultdict(SmoothedValue)
        self.delimiter = delimiter
    
    # 自动保留字典遍历,记录其更新信息
    def update(self, **kwargs):
        for k, v in kwargs.items():
            if isinstance(v, torch.Tensor):
                v = v.item()
            assert isinstance(v, (float, int))
            self.meters[k].update(v)
    
    # 之后是其他的定义,这里我就不贴上来了
    ...
    
    # 打印本身返回的内容
    def __str__(self):
        loss_str = []
        for name, meter in self.meters.items():
            loss_str.append(
                "{}: {}".format(name, str(meter))
            )
        return self.delimiter.join(loss_str)
    
class SmoothedValue(object):
    """Track a series of values and provide access to smoothed values over a
    window or the global series average.
    """
    def __init__(self, window_size=20, fmt=None):
        if fmt is None:
            fmt = "{value:.4f} ({global_avg:.4f})"
        self.deque = deque(maxlen=window_size)  # deque简单理解成加强版list
        self.total = 0.0
        self.count = 0
        self.fmt = fmt

    def update(self, value, n=1):
        self.deque.append(value)
        self.count += n
        self.total += value * n

    def synchronize_between_processes(self):
        """
        Warning: does not synchronize the deque!
        """
        if not is_dist_avail_and_initialized():
            return
        t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
        dist.barrier()
        dist.all_reduce(t)
        t = t.tolist()
        self.count = int(t[0])
        self.total = t[1]

    @property
    def median(self):  # @property 是装饰器,这里可简单理解为增加median属性(只读)
        d = torch.tensor(list(self.deque))
        return d.median().item()

    @property
    def avg(self):
        d = torch.tensor(list(self.deque), dtype=torch.float32)
        return d.mean().item()

    @property
    def global_avg(self):
        return self.total / self.count

    @property
    def max(self):
        return max(self.deque)

    @property
    def value(self):
        return self.deque[-1]

    def __str__(self):
        return self.fmt.format(
            median=self.median,
            avg=self.avg,
            global_avg=self.global_avg,
            max=self.max,
            value=self.value)
  • 总结:

在验证过程中,保留的变量是model_time, evaluator_time,所以会打印其更新信息;而在训练过程中,保留的变量是loss,box_loss,obj_loss,class_loss,lr,所以会打印其更新信息。而默认的输出信息有:eta,time,data与max mem。详情可以查看上述我贴上来的部分打印信息,对比就可以清楚了解。


3. Tensorboard工具调用

tensorboard是一个可视化工具,可以在网页上动态的查看当前epoch所获得的各项参数。常见的还有另外的一个可视化工具:visdom,对于visdom的安装与简单使用可以查看我之前的博文:visdom安装与基本用法

这里以yolov3spp中的使用过程为例,来介绍tensorboard的使用,具体的使用方法这里就不再细述。在yolov3spp中训练过程的tensorboard使用流程如下所示:

from torch.utils.tensorboard import SummaryWriter

# 构建一个可视化类
tb_writer = SummaryWriter(comment=opt.name)

# 写入tensorboard,可通过网页打开查看相关信息
if tb_writer:
    tags = ['train/giou_loss', 'train/obj_loss', 'train/cls_loss', 'train/loss', "learning_rate",
            "mAP@[IoU=0.50:0.95]", "mAP@[IoU=0.5]", "mAR@[IoU=0.50:0.95]"]
    
    # 这里的mloss包含了4个部分:边界框损失、置信度损失、分类损失、总损失
    # mloss + [lr, coco_mAP, voc_mAP, coco_mAR] 就一共有八个指标,对应着八个标签tag
    for x, tag in zip(mloss.tolist() + [lr, coco_mAP, voc_mAP, coco_mAR], tags):
        # 以epoch为横坐标,x为竖坐标,tag为标题来进行更新
        tb_writer.add_scalar(tag, x, epoch)
  • 详细的参数定义如下:
def add_scalar(
    self, tag, scalar_value, global_step=None, walltime=None, new_style=False
):
    """Add scalar data to summary.

    Args:
        tag (string): Data identifier
        scalar_value (float or string/blobname): Value to save
        global_step (int): Global step value to record
        walltime (float): Optional override default walltime (time.time())
          with seconds after epoch of event
        new_style (boolean): Whether to use new style (tensor field) or old
          style (simple_value field). New style could lead to faster data loading.
    Examples::

        from torch.utils.tensorboard import SummaryWriter
        writer = SummaryWriter()
        x = range(100)
        for i in x:
            writer.add_scalar('y=2x', i * 2, i)
        writer.close()

    Expected result:

    .. image:: _static/img/tensorboard/add_scalar.png
       :scale: 50 %

    """
    torch._C._log_api_usage_once("tensorboard.logging.add_scalar")
    if self._check_caffe2_blob(scalar_value):
        from caffe2.python import workspace
        scalar_value = workspace.FetchBlob(scalar_value)

    summary = scalar(tag, scalar_value, new_style=new_style)
    self._get_file_writer().add_summary(summary, global_step, walltime)
  • 动态结果查看:

  • 补充:

在yolov3spp项目中,除了通过MetricLogger的工具类来迭代加载想控制台输出信息,用tensorboard向网页输出信息(可以动态的显示整个训练的曲线过程,功能比较多),此外还会使用最普通的txt来存储相关的信息,这个就是最基本的 *** 作了,和logging类似而已。

# 将coco的验证指标保存在一个txt文件当中
with open(results_file, "a") as f:
    # 记录coco的12个指标加上训练总损失和lr
    result_info = [str(round(i, 4)) for i in result_info + [mloss.tolist()[-1]]] + [str(round(lr, 6))]
    txt = "epoch:{} {}".format(epoch, '  '.join(result_info))
    f.write(txt + "\n")
  • 总结:

这篇内容介绍了coco工具类的使用,以及两个日志记录的工具。这些代码是我从项目中截取而来,对于完整的项目流程可以查看我的其他博客,或者自行查看源码。

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/790091.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-05
下一篇 2022-05-05

发表评论

登录后才能评论

评论列表(0条)

保存