机器学习周报第38周

目录

• 一、文献阅读
• • [1.1 摘要](#1.1 摘要)
  • [1.2 背景](#1.2 背景)
  • [1.3 文章方法](#1.3 文章方法)
  • [1.4 创新点](#1.4 创新点)
  • [1.5 文章代码](#1.5 文章代码)
• 总结

一、文献阅读

论文标题：CenterNet: Keypoint Triplets for Object Detection

1.1 摘要

在目标检测中，基于关键点的方法经常会遇到大量错误对象边界框的问题，这可能是由于在裁剪区域内缺乏额外的评估。本文提出了一种有效的解决方案，该方案以最小的成本探索个体裁剪区域内的视觉模式。我们的框架建立在具有代表性的单阶段基于关键点的检测器CornerNet之上。我们的方法，名为CenterNet，将每个对象检测为关键点的三元组，而不是点对，从而提高了精确度和召回率。因此，我们设计了两个定制模块，级联角点池化 和中心池化，它们丰富了由左上角和右下角收集的信息，并提供了来自中心区域的更多可识别信息。在MS-COCO数据集上，CenterNet实现了47.0%的AP，比所有现有的单阶段检测器至少高出4.9%。此外，CenterNet的推理速度比排名最高的两阶段检测器更快，并显示出与这些检测器相当的性能。

1.2 背景

在深度学习，特别是卷积神经网络（CNN）的帮助下，目标检测得到了显着改善。 在当前时代，最流行的流程图之一是基于锚点的流程图，将一组具有预定义大小的矩形（锚点）放置在图像上，并将锚点回归到所需的值在地面真实物体的帮助下放置。 这些方法通常需要大量的锚点来确保与地面实况对象具有足够高的 IoU（交集比并集）率，并且每个锚点的大小和长宽比必须手动设置。 此外，锚点和卷积特征通常是错位的，这不利于边界框分类任务。

本文使用 CornerNet 作为基线。 为了检测角点，CornerNet 生成两个热图：左上角的热图和右下角的热图。 热图表示不同类别的关键点的位置，并为每个关键点分配一个置信度分数 。 此外，CornerNet 还预测每个角点的嵌入和一组偏移量。 嵌入用于识别两个角是否来自同一对象 。 偏移学习将热图的角点重新映射到输入图像。 为了生成对象边界框，根据得分从热图中选择前 k 个左上角和右下角。 然后，计算一对角点的嵌入向量的距离，以确定这对角点是否属于同一对象。 如果距离小于阈值，则生成对象边界框。 为边界框分配的置信度分数等于角点对的平均分数。

在表1中，我们提供了CornerNet的详细分析。 我们计算了 CornerNet 在 MS-COCO 验证数据集上的 FD1（错误发现）率，定义为错误边界框的比例。 定量结果表明，即使在 IoU 阈值较低的情况下，错误的边界框也占所有边界框的很大一部分，例如，CornerNet 在 IoU = 0.05 时获得了 32.7% 的 FD 率。 这意味着，每 100 个对象边界框中有 32.7 个与真实边界框的 IoU 低于 0.05。 小的错误边界框的 FD 率为 60.3%，甚至高于较大的边界框。 造成此结果的可能原因之一是 CornerNet 无法评估边界框内的区域。 使 CornerNet [21] 感知边界框中的视觉模式的一种潜在方法是将 CornerNet 适配为两级检测器，该检测器使用 RoI 池化 [11] 来评估边界框中的视觉模式。 然而，众所周知，这种范例的计算成本很高。

该管道使用一对角点关键点来表示每个对象，从而绕过了对锚框的需求，并实现了最先进的单阶段对象检测精度。 尽管如此，CornerNet的性能仍然受到其引用对象全局信息的能力相对较弱的限制。 也就是说，由于每个对象都是由一对角点构成的，因此算法可以灵敏地检测对象的边界，而无需知道应该将哪对关键点分组为对象。 因此，如图 1 所示，CornerNet 经常生成不正确的边界框，其中大部分可以通过一些补充信息（例如长宽比）轻松过滤掉。

为了解决这个问题，我们为 CornerNet 配备了感知每个提议区域内的视觉模式的能力，使其能够自行识别每个边界框的正确性。 在本文中，我们提出了一种名为 CenterNet 的低成本但有效的解决方案，它探索提案的中心部分，即靠近盒子几何中心的区域，并有一个额外的关键点。 我们直觉地认为，如果预测的边界框与真实框的 IoU 较高，则边界框中心区域的中心关键点被预测为同一类的概率较高，反之亦然。 因此，在推理过程中，在将提案生成为一对角点关键点后，我们通过检查是否有同一类的中心关键点落在其中心区域内来确定该提案是否确实是一个对象。 如图 1 所示，其想法是使用三元组而不是一对关键点来表示每个对象。

1.3 文章方法

为了改进中心关键点和角点的检测，我们提出了两种分别丰富中心和角点信息的策略。

第一个策略是中心池化 ，在分支中用于预测中心关键点。 中心池化有助于中心关键点在对象内获得更容易识别的视觉模式，从而更容易感知提案的中心部分。 我们通过在中心关键点预测的特征图上获得中心关键点在水平和垂直方向上的最大总响应来实现这一点。 第二种策略是级联角点池化，它使原始角点池化模块具有感知内部信息的能力。 我们通过在角点预测的特征图上获得对象边界和内部方向上的最大总响应来实现这一点。 根据经验，我们验证了这种双向池化方法更稳定，即对特征级噪声更鲁​​棒，这将有助于提高精度和召回率。

整体网络架构如图 2 所示。我们使用中心关键点和一对角点来表示每个对象。 具体来说，我们在CornerNet的基础上嵌入中心关键点的热图并预测中心关键点的偏移量。 然后，我们使用 CornerNet 中提出的方法来生成 top-k 边界框。 然而，为了有效地过滤掉不正确的边界框，我们利用检测到的中心关键点并执行以下过程：

（1）根据分数选择前k个中心关键点；

（2）使用相应的偏移量将这些中心关键点重新映射到输入图像；

(3)为每个边界框定义一个中心区域，并检查中心区域是否包含中心关键点。 请注意，检查的中心关键点的类标签应与边界框的类标签相同；

(4) 如果在中心区域检测到中心关键点，我们保留边界框。 边界框的分数被三重点（即左上角、右下角和中心关键点）的平均分数替换。 如果在中心区域没有检测到中心关键点，则边界框将被删除。

边界框中心区域的大小影响检测结果。 例如，小的中心区域会导致小边界框的召回率低，而大的中心区域会导致大边界框的精度低。这是因为一个较小的中心区域意味着只有当中心关键点非常精确地位于这个小区域内时，相应的边界框才会被保留。对于小边界框，如果中心区域太小，即使中心关键点非常接近边界框的中心，也可能因为轻微的定位误差就被排除在中心区域之外，导致这些小边界框的召回率降低。如果中心区域较大，即使中心关键点并没有非常精确地定位在边界框的中心，边界框也可能因为中心区域的包容性而被保留。这可能导致一些错误的边界框被错误地识别为目标，特别是对于大边界框，因为大的中心区域更容易包含错误的预测，从而降低了整体的检测精度。

因此，我们提出了一个尺度感知的中心区域来自适应地适应边界框的大小。 缩放感知中心区域倾向于为小边界框生成相对较大的中心区域，并为大边界框生成相对较小的中心区域。 设 tlx 和 tly 表示 i 的左上角坐标，brx 和 bry 表示 i 的右下角坐标。 定义中心区域 j。 设ctlx和ctly表示j的左上角坐标，cbrx和cbry表示j的右下角坐标。 那么tlx、tly、brx、bry、ctlx、ctly、cbrx和cbry应满足以下关系：

中心池化 。 物体的几何中心并不总是传达非常可识别的视觉图案（例如，人的头部包含强烈的视觉图案，但中心关键点通常位于人体的中间）。 为了解决这个问题，我们提出中心池化来捕获更丰富、更容易识别的视觉模式。 图4(a)展示了center pooling的原理。 center pooling的具体过程如下：backbone输出一个feature map，为了判断feature map中的某个像素是否是中心关键点，我们需要找到水平和垂直方向上的最大值并将这些值相加 。 通过这样做，中心池有助于改进中心关键点的检测。

在目标检测模型中，backbone网络（如ResNet, VGG等）通常会输出一个或多个特征图（Feature Map）。这些特征图是从原始输入图像中提取的，包含了图像的空间结构和纹理信息。为了确定特征图中的某个像素是否是一个中心关键点，我们需要评估该像素在水平（x方向）和垂直（y方向）上的表现。在水平和垂直方向上，我们会寻找特征图上的最大响应值。这些最大值通常表示了对象的边缘或角点，因为这些位置在特征图中往往会有较高的激活值。将这些在水平和垂直方向上找到的最大值相加以得到一个综合的评分。这个评分反映了特定像素成为中心关键点的可能性。通过这种池化操作，可以强化那些在两个方向上都有强响应的像素点，这有助于模型更准确地定位到对象的中心区域。中心池化通过突出显示这些中心区域的响应，有助于改进中心关键点的检测。中心池化通过强调对象中心区域的特征响应，可以帮助模型更有效地识别和定位目标对象的中心，从而提高目标检测*的准确性。

级联角池化：角点通常在对象外部：在目标检测中，对象的角点往往位于对象边界的外部，这些位置可能缺乏局部的外观特征，使得角点检测成为一个挑战。CornerNet使用角池化解决这个问题：CornerNet是一个目标检测框架，它使用角池化（Corner Pooling）来检测对象的角点。角池化的目的是在边界方向上寻找最大值，以确定角点的位。角池化通过在对象的边界方向上寻找最大响应值来工作，这些最大值代表了角点的可能位置。由于角池化主要关注边缘，这可能导致角点检测对边缘特别敏感，有时可能会将边缘错误地识别为角点。为了解决这个问题，需要让角点检测机制能够从对象的中心区域提取特征，而不仅仅是边界。

级联角池化首先沿着边界方向寻找最大边界值，然后在边界最大值的内部位置沿着垂直于边界的方向寻找内部最大值。级联角池化的关键是将边界方向上找到的最大值和内部方向上找到的最大值相加，以此来增强角点的特征表示。通过级联角池化，角点检测不仅能够获取到对象边界的信息，还能够捕捉到对象中心区域的视觉模式，这有助于更准确地定位角点，即使它们位于对象外部。

1.4 创新点

本文介绍了一种名为CenterNet的目标检测方法，其创新点主要包括以下几个方面：
关键点三元组表示：与传统的目标检测方法不同，CenterNet不是使用一个边界框或一对角点来表示对象，而是使用一个中心关键点和一对角点（即三元组）来表示每个对象，这增强了模型对对象的整体表示能力。

中心池化（Center Pooling）：为了更好地检测中心关键点，文中提出了中心池化技术。这种池化策略通过在水平和垂直方向上寻找最大值，并将这些值相加，从而帮助模型获得更丰富和更易于识别的视觉模式。

级联角池化（Cascade Corner Pooling）：为了解决角点检测对边缘过于敏感的问题，文中提出了级联角池化技术。这种技术首先在边界方向上寻找最大值，然后在内部方向上寻找最大值，并将这两个最大值相加，使得角点检测能够同时获取对象的边界信息和内部视觉模式。

有效的错误边界框过滤：CenterNet通过检测到的中心关键点来过滤掉不正确的边界框。具体来说，模型会检查每个边界框的中心区域是否包含有相同类别的中心关键点，如果没有，则该边界框会被移除。

尺度感知的中心区域：为了适应不同大小的边界框，文中提出了一种尺度感知的中心区域定义方法，该方法能够根据边界框的大小自适应地调整中心区域的大小。

1.5 文章代码

datasets
dataset_factory.py

dataset_factory = {
  'coco': COCO,
  'pascal': PascalVOC,
  'kitti': KITTI,
  'coco_hp': COCOHP
}

_sample_factory = {
  'exdet': EXDetDataset,
  'ctdet': CTDetDataset,
  'ddd': DddDataset,
  'multi_pose': MultiPoseDataset
}

def get_dataset(dataset, task):
  class Dataset(dataset_factory[dataset], _sample_factory[task]):
    pass
  return Dataset

dataset_factory ： 定义了数据集字典，根据配置选择相应的数据集，后面以COCO数据集为例；

_sample_factory ：任务字典，目标检测、肢体识别等，配置文件默认为目标检测，即取值为CTDetDataset

get_dataset： 相当于对数据集和任务类做了一个封装

这里的class Dataset(dataset_factory[dataset], _sample_factory[task])是一个python的多继承，即Dataset这个类继承了COCO和CTDetDataset，所以在main.py中可以看到

dataset/coco.py

这个文件比较简单，主要是一些参数的定义，比如总共多少个类、类别名称、默认的图片大小、数据集的均值和方差等。这里唯一要注意的地方是，如果换成自己的数据集，除了num_classes要改之外，均值和方差也需要根据自己的数据集计算，而不是直接使用默认值

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import pycocotools.coco as coco
from pycocotools.cocoeval import COCOeval
import numpy as np
import json
import os

import torch.utils.data as data

class COCO(data.Dataset):
  num_classes = 80
  default_resolution = [512, 512]
  mean = np.array([0.40789654, 0.44719302, 0.47026115],
                   dtype=np.float32).reshape(1, 1, 3)
  std  = np.array([0.28863828, 0.27408164, 0.27809835],
                   dtype=np.float32).reshape(1, 1, 3)

  def __init__(self, opt, split):
    super(COCO, self).__init__()
    self.data_dir = os.path.join(opt.data_dir, 'coco')
    self.img_dir = os.path.join(self.data_dir, '{}2017'.format(split))
    if split == 'test':
      self.annot_path = os.path.join(
          self.data_dir, 'annotations', 
          'image_info_test-dev2017.json').format(split)
    else:
      if opt.task == 'exdet':
        self.annot_path = os.path.join(
          self.data_dir, 'annotations', 
          'instances_extreme_{}2017.json').format(split)
      else:
        self.annot_path = os.path.join(
          self.data_dir, 'annotations', 
          'instances_{}2017.json').format(split)
    self.max_objs = 128
    self.class_name = [
      '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
      'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
      'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
      'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
      'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',
      'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
      'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',
      'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
      'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
      'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
      'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
      'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
      'scissors', 'teddy bear', 'hair drier', 'toothbrush']
    self._valid_ids = [
      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 
      14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 
      24, 25, 27, 28, 31, 32, 33, 34, 35, 36, 
      37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 
      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 
      58, 59, 60, 61, 62, 63, 64, 65, 67, 70, 
      72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 
      82, 84, 85, 86, 87, 88, 89, 90]
    self.cat_ids = {v: i for i, v in enumerate(self._valid_ids)}
    self.voc_color = [(v // 32 * 64 + 64, (v // 8) % 4 * 64, v % 8 * 32) \
                      for v in range(1, self.num_classes + 1)]
    self._data_rng = np.random.RandomState(123)
    self._eig_val = np.array([0.2141788, 0.01817699, 0.00341571],
                             dtype=np.float32)
    self._eig_vec = np.array([
        [-0.58752847, -0.69563484, 0.41340352],
        [-0.5832747, 0.00994535, -0.81221408],
        [-0.56089297, 0.71832671, 0.41158938]
    ], dtype=np.float32)
    # self.mean = np.array([0.485, 0.456, 0.406], np.float32).reshape(1, 1, 3)
    # self.std = np.array([0.229, 0.224, 0.225], np.float32).reshape(1, 1, 3)

    self.split = split
    self.opt = opt

    print('==> initializing coco 2017 {} data.'.format(split))
    self.coco = coco.COCO(self.annot_path)
    self.images = self.coco.getImgIds()
    self.num_samples = len(self.images)

    print('Loaded {} {} samples'.format(split, self.num_samples))

  def _to_float(self, x):
    return float("{:.2f}".format(x))

  def convert_eval_format(self, all_bboxes):
    # import pdb; pdb.set_trace()
    detections = []
    for image_id in all_bboxes:
      for cls_ind in all_bboxes[image_id]:
        category_id = self._valid_ids[cls_ind - 1]
        for bbox in all_bboxes[image_id][cls_ind]:
          bbox[2] -= bbox[0]
          bbox[3] -= bbox[1]
          score = bbox[4]
          bbox_out  = list(map(self._to_float, bbox[0:4]))

          detection = {
              "image_id": int(image_id),
              "category_id": int(category_id),
              "bbox": bbox_out,
              "score": float("{:.2f}".format(score))
          }
          if len(bbox) > 5:
              extreme_points = list(map(self._to_float, bbox[5:13]))
              detection["extreme_points"] = extreme_points
          detections.append(detection)
    return detections

  def __len__(self):
    return self.num_samples

  def save_results(self, results, save_dir):
    json.dump(self.convert_eval_format(results), 
                open('{}/results.json'.format(save_dir), 'w'))
  
  def run_eval(self, results, save_dir):
    # result_json = os.path.join(save_dir, "results.json")
    # detections  = self.convert_eval_format(results)
    # json.dump(detections, open(result_json, "w"))
    self.save_results(results, save_dir)
    coco_dets = self.coco.loadRes('{}/results.json'.format(save_dir))
    coco_eval = COCOeval(self.coco, coco_dets, "bbox")
    coco_eval.evaluate()
    coco_eval.accumulate()
    coco_eval.summarize()

sample/ctdet.py

核心类CTDetDataset，主要实现了训练时需要的数据迭代器。核心函数：getitem()

在函数内部出现了http://self.opt.xxx和http://self.coco.xxx这种类型的调用，但是仔细看CTDetDataset类，却没有__init__函数，更找不到这两个变量的定义。别忘了，在dataset_factory.py中Dataset类时继承了COCO和CTDetDataset两个类的，而且train_loader的定义中用的是Dataset类，所以在实际使用中，即epcho中这个__getitem__()是由Dataset调用的，所以这里的self.opt和self.coco在coco.py中定义！

2. 函数内部可以分成三个部分加载数据、数据增强、生成gt

加载数据

img_id = self.images[index]
        file_name = self.coco.loadImgs(ids=[img_id])[0]['file_name']
        img_path = os.path.join(self.img_dir, file_name)
        ann_ids = self.coco.getAnnIds(imgIds=[img_id])
        anns = self.coco.loadAnns(ids=ann_ids)
        num_objs = min(len(anns), self.max_objs)

        img = cv2.imread(img_path)

数据增强

height, width = img.shape[0], img.shape[1]
c = np.array([img.shape[1] / 2., img.shape[0] / 2.], dtype=np.float32)
if self.opt.keep_res:
    input_h = (height | self.opt.pad) + 1
    input_w = (width | self.opt.pad) + 1
    s = np.array([input_w, input_h], dtype=np.float32)
else:
    s = max(img.shape[0], img.shape[1]) * 1.0
    input_h, input_w = self.opt.input_h, self.opt.input_w

flipped = False
if self.split == 'train':
    if not self.opt.not_rand_crop:
        s = s * np.random.choice(np.arange(0.6, 1.4, 0.1))
        w_border = self._get_border(128, img.shape[1])
        h_border = self._get_border(128, img.shape[0])
        c[0] = np.random.randint(low=w_border, high=img.shape[1] - w_border)
        c[1] = np.random.randint(low=h_border, high=img.shape[0] - h_border)
    else:
        sf = self.opt.scale
        cf = self.opt.shift
        c[0] += s * np.clip(np.random.randn() * cf, -2 * cf, 2 * cf)
        c[1] += s * np.clip(np.random.randn() * cf, -2 * cf, 2 * cf)
        s = s * np.clip(np.random.randn() * sf + 1, 1 - sf, 1 + sf)

    if np.random.random() < self.opt.flip:
        flipped = True
        img = img[:, ::-1, :]
        c[0] = width - c[0] - 1

trans_input = get_affine_transform( c, s, 0, [input_w, input_h])
inp = cv2.warpAffine(img, trans_input,
                     (input_w, input_h),
                     flags=cv2.INTER_LINEAR)
inp = (inp.astype(np.float32) / 255.)
if self.split == 'train' and not self.opt.no_color_aug:
    color_aug(self._data_rng, inp, self._eig_val, self._eig_vec)
inp = (inp - self.mean) / self.std
inp = inp.transpose(2, 0, 1)

生成gt

output_h = input_h // self.opt.down_ratio
output_w = input_w // self.opt.down_ratio
num_classes = self.num_classes
trans_output = get_affine_transform(c, s, 0, [output_w, output_h])

hm = np.zeros((num_classes, output_h, output_w), dtype=np.float32)
wh = np.zeros((self.max_objs, 2), dtype=np.float32)
dense_wh = np.zeros((2, output_h, output_w), dtype=np.float32)
reg = np.zeros((self.max_objs, 2), dtype=np.float32)
ind = np.zeros((self.max_objs), dtype=np.int64)
reg_mask = np.zeros((self.max_objs), dtype=np.uint8)
cat_spec_wh = np.zeros((self.max_objs, num_classes * 2), dtype=np.float32)
cat_spec_mask = np.zeros((self.max_objs, num_classes * 2), dtype=np.uint8)

draw_gaussian = draw_msra_gaussian if self.opt.mse_loss else \
    draw_umich_gaussian

gt_det = []
for k in range(num_objs):
    ann = anns[k]
    bbox = self._coco_box_to_bbox(ann['bbox'])
    cls_id = int(self.cat_ids[ann['category_id']])
    if flipped:
        bbox[[0, 2]] = width - bbox[[2, 0]] - 1
    bbox[:2] = affine_transform(bbox[:2], trans_output)
    bbox[2:] = affine_transform(bbox[2:], trans_output)
    bbox[[0, 2]] = np.clip(bbox[[0, 2]], 0, output_w - 1)
    bbox[[1, 3]] = np.clip(bbox[[1, 3]], 0, output_h - 1)
    h, w = bbox[3] - bbox[1], bbox[2] - bbox[0]
    if h > 0 and w > 0:
        radius = gaussian_radius((math.ceil(h), math.ceil(w)))
        radius = max(0, int(radius))
        radius = self.opt.hm_gauss if self.opt.mse_loss else radius
        ct = np.array(
            [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2], dtype=np.float32)
        ct_int = ct.astype(np.int32)
        draw_gaussian(hm[cls_id], ct_int, radius)
        wh[k] = 1. * w, 1. * h
        ind[k] = ct_int[1] * output_w + ct_int[0]
        reg[k] = ct - ct_int
        reg_mask[k] = 1
        cat_spec_wh[k, cls_id * 2: cls_id * 2 + 2] = wh[k]
        cat_spec_mask[k, cls_id * 2: cls_id * 2 + 2] = 1
        if self.opt.dense_wh:
            draw_dense_reg(dense_wh, hm.max(axis=0), ct_int, wh[k], radius)
        gt_det.append([ct[0] - w / 2, ct[1] - h / 2,
                       ct[0] + w / 2, ct[1] + h / 2, 1, cls_id])

ret = {'input': inp, 'hm': hm, 'reg_mask': reg_mask, 'ind': ind, 'wh': wh}

总结

本周学习了Centernet的相关内容以及代码，下周将继续相关代码和目标检测的学习。