『TensorFlow』SSD源码学习_其六：标签整理

def _parse_voc_annotation(xml_path):
    """解析VOC格式的XML标注文件"""
    tree = ET.parse(xml_path)
    root = tree.getroot()
    size = root.find('size')
    width = int(size.find('width').text)
    height = int(size.find('height').text)
    objects = []
    for obj in root.iter('object'):
        difficult = int(obj.find('difficult').text)
        cls_name = obj.find('name').text.strip().lower()
        if cls_name not in VOC_LABELS:  # 过滤无效类别
            continue
        cls_id = VOC_LABELS[cls_name]  # 类别ID映射（如'cat'→3）
        bbox = obj.find('bndbox')
        xmin = float(bbox.find('xmin').text) - 1  # 转为0-based坐标
        ymin = float(bbox.find('ymin').text) - 1
        xmax = float(bbox.find('xmax').text) - 1
        ymax = float(bbox.find('ymax').text) - 1
        objects.append({
            'class_id': cls_id,
            'bbox': [xmin, ymin, xmax, ymax],
            'difficult': difficult
        })
    return {
        'image_path': image_path,
        'width': width,
        'height': height,
        'objects': objects
    }

def convert_bboxes_to_center_size(bboxes):
    """将(xmin, ymin, xmax, ymax)转换为(cx, cy, w, h)"""
    cx = (bboxes[..., 0] + bboxes[..., 2]) / 2.0  # 中心x坐标
    cy = (bboxes[..., 1] + bboxes[..., 3]) / 2.0  # 中心y坐标
    w = bboxes[..., 2] - bboxes[..., 0]  # 宽度
    h = bboxes[..., 3] - bboxes[..., 1]  # 高度
    return tf.stack([cx, cy, w, h], axis=-1)
 
def normalize_bboxes(bboxes, image_shape):
    """将绝对坐标归一化到[0, 1]"""
    height, width = image_shape[0], image_shape[1]
    xmin = bboxes[..., 0] / width
    ymin = bboxes[..., 1] / height
    xmax = bboxes[..., 2] / width
    ymax = bboxes[..., 3] / height
    return tf.stack([xmin, ymin, xmax, ymax], axis=-1)

def ssd_bboxes_encode(gt_boxes, anchors, matching_threshold=0.5):
    """将GT边界框与锚框匹配，生成标签和回归目标"""
    num_anchors = anchors.shape[0]
    num_gt = gt_boxes.shape[0]
    
    # 1. 计算所有GT与锚框的IoU矩阵（num_gt × num_anchors）
    iou_matrix = box_ops.iou(gt_boxes, anchors)
    
    # 2. 每个GT匹配IoU最大的锚框（保证每个GT至少有一个正样本）
    max_iou_per_gt = tf.reduce_max(iou_matrix, axis=1)  # 每个GT的最大IoU
    gt_indices = tf.range(num_gt)
    anchor_indices = tf.argmax(iou_matrix, axis=1)  # 每个GT对应的最佳锚框索引
    # 标记这些锚框为正样本
    positive_mask = tf.scatter_nd(
        indices=tf.stack([anchor_indices, gt_indices], axis=1),
        updates=tf.ones(num_gt, dtype=tf.bool),
        shape=[num_anchors, num_gt]
    )
    
    # 3. 锚框与任意GT的IoU > threshold也视为正样本
    max_iou_per_anchor = tf.reduce_max(iou_matrix, axis=0)  # 每个锚框的最大IoU
    positive_mask = tf.logical_or(
        positive_mask, 
        tf.greater(max_iou_per_anchor, matching_threshold)
    )
    
    # 4. 为正样本分配类别标签和回归目标
    # 类别标签：正样本为GT的class_id，负样本为0（背景）
    class_labels = tf.zeros(num_anchors, dtype=tf.int32)
    matched_gt_indices = tf.argmax(tf.cast(positive_mask, tf.int32), axis=1)
    class_labels = tf.where(
        tf.reduce_any(positive_mask, axis=1),
        gt_boxes[matched_gt_indices, 4],  # 假设gt_boxes最后一维为class_id
        class_labels
    )
    
    # 5. 计算边界框回归目标（GT与锚框的偏移量）
    # 回归公式：tx = (cx_gt - cx_anchor)/w_anchor, ty = (cy_gt - cy_anchor)/h_anchor
    # tw = log(w_gt/w_anchor), th = log(h_gt/h_anchor)
    gt_centers = convert_bboxes_to_center_size(gt_boxes[..., :4])  # (cx, cy, w, h)
    anchor_centers = convert_bboxes_to_center_size(anchors)
    tx = (gt_centers[matched_gt_indices, 0] - anchor_centers[:, 0]) / anchor_centers[:, 2]
    ty = (gt_centers[matched_gt_indices, 1] - anchor_centers[:, 1]) / anchor_centers[:, 3]
    tw = tf.math.log(gt_centers[matched_gt_indices, 2] / anchor_centers[:, 2])
    th = tf.math.log(gt_centers[matched_gt_indices, 3] / anchor_centers[:, 3])
    bbox_reg_targets = tf.stack([tx, ty, tw, th], axis=-1)
    
    return class_labels, bbox_reg_targets, positive_mask

def hard_negative_mining(losses, positive_mask, num_negatives_per_positive=3):
    """难负样本挖掘：选择损失最大的负样本，控制正负样本比例"""
    # 1. 区分正负样本损失
    positive_losses = tf.where(positive_mask, losses, tf.zeros_like(losses))
    negative_losses = tf.where(tf.logical_not(positive_mask), losses, tf.zeros_like(losses))
    
    # 2. 统计正样本数量
    num_positives = tf.reduce_sum(tf.cast(positive_mask, tf.int32))
    num_negatives = tf.minimum(
        num_negatives_per_positive * num_positives,  # 最多3倍正样本数量的负样本
        tf.size(losses) - num_positives  # 不超过总样本数
    )
    
    # 3. 选择损失最大的负样本
    if num_negatives > 0:
        negative_losses_sorted = tf.sort(negative_losses, direction='DESCENDING')
        negative_threshold = negative_losses_sorted[num_negatives - 1]
        negative_mask = tf.logical_and(
            tf.greater(negative_losses, negative_threshold),
            tf.logical_not(positive_mask)
        )
    else:
        negative_mask = tf.zeros_like(positive_mask, dtype=tf.bool)
    
    return tf.logical_or(positive_mask, negative_mask)  # 最终参与训练的样本mask

<annotation>
  <size><width>486</width><height>500</height></size>
  <object>
    <name>person</name>
    <bndbox><xmin>174</xmin><ymin>101</ymin><xmax>349</xmax><ymax>351</ymax></bndbox>
    <difficult>0</difficult>
  </object>
</annotation>

{
    'image_path': '2007_000027.jpg',
    'width': 486, 'height': 500,
    'objects': [{'class_id': 1, 'bbox': [173, 100, 348, 350], 'difficult': 0}]  # 0-based坐标
}