YOLOv6-4.0部分代码阅读笔记-figure_iou.py
figure_iou.py
yolov6\utils\figure_iou.py
目录
figure_iou.py
1.所需的库和模块
2.class IOUloss:
3.def pairwise_bbox_iou(box1, box2, box_format='xywh'):
1.所需的库和模块
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import math
import torch
2.class IOUloss:
class IOUloss:
# 计算IoU损失。
""" Calculate IoU loss.
"""
# reduction ：这个参数指定了在计算损失或评估指标时如何处理多个值。 'none' 表示不对值进行任何特殊处理，即不进行求和、平均或最大/最小值计算。其他的值包括 'mean' （平均值）、 'sum' （总和）等，这些值影响如何聚合多个损失或指标值。
def __init__(self, box_format='xywh', iou_type='ciou', reduction='none', eps=1e-7):
# 类别的设置。
""" Setting of the class.
Args:
box_format: (string), must be one of 'xywh' or 'xyxy'. 必须是“xywh”或“xyxy”之一。
iou_type: (string), can be one of 'ciou', 'diou', 'giou' or 'siou' 可以是“ciou”、“diou”、“giou”或“siou”之一。
reduction: (string), specifies the reduction to apply to the output, must be one of 'none', 'mean','sum'. 指定应用于输出的缩减，必须是“none”、“mean”、“sum”之一。
eps: (float), a value to avoid divide by zero error. 一个避免被零错误除的值。
"""
self.box_format = box_format
self.iou_type = iou_type.lower()
self.reduction = reduction
self.eps = eps
def __call__(self, box1, box2):
# 计算 iou 。 box1 和 box2 是形状为[M, 4]和[Nm 4]的torch张量。
""" calculate iou. box1 and box2 are torch tensor with shape [M, 4] and [Nm 4].
"""
if box1.shape[0] != box2.shape[0]:
box2 = box2.T
if self.box_format == 'xyxy':
b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
elif self.box_format == 'xywh':
b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2
else:
if self.box_format == 'xyxy':
b1_x1, b1_y1, b1_x2, b1_y2 = torch.split(box1, 1, dim=-1)
b2_x1, b2_y1, b2_x2, b2_y2 = torch.split(box2, 1, dim=-1)
elif self.box_format == 'xywh':
b1_x1, b1_y1, b1_w, b1_h = torch.split(box1, 1, dim=-1)
b2_x1, b2_y1, b2_w, b2_h = torch.split(box2, 1, dim=-1)
b1_x1, b1_x2 = b1_x1 - b1_w / 2, b1_x1 + b1_w / 2
b1_y1, b1_y2 = b1_y1 - b1_h / 2, b1_y1 + b1_h / 2
b2_x1, b2_x2 = b2_x1 - b2_w / 2, b2_x1 + b2_w / 2
b2_y1, b2_y2 = b2_y1 - b2_h / 2, b2_y1 + b2_h / 2
# Intersection area 交叉区域
# torch.clamp(input, min, max, out=None) → Tensor
# clamp() 函数的功能将输入 input 张量每个元素的值压缩到区间 [min,max]，并返回结果到一个新张量。
# input ：输入张量。
# min ：限制范围下限。
# max ：限制范围上限。
# out ：输出张量。
# pytorch中，一般来说如果对tensor的一个函数后加上了下划线，则表明这是一个 in-place 类型。
# in-place 类型是指，当在一个tensor上操作了之后，是直接修改了这个tensor，而不是返回一个新的tensor并不修改旧的tensor。
inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
(torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)
# Union Area 联合区域
w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + self.eps
w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + self.eps
union = w1 * h1 + w2 * h2 - inter + self.eps
iou = inter / union
cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1) # convex width 外接矩形的宽度
ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height 外接矩形的高度
if self.iou_type == 'giou':
c_area = cw * ch + self.eps # convex area
iou = iou - (c_area - union) / c_area
elif self.iou_type in ['diou', 'ciou']:
c2 = cw ** 2 + ch ** 2 + self.eps # convex diagonal squared
rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 +
(b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4 # center distance squared
if self.iou_type == 'diou':
iou = iou - rho2 / c2
elif self.iou_type == 'ciou':
v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
with torch.no_grad():
alpha = v / (v - iou + (1 + self.eps))
iou = iou - (rho2 / c2 + v * alpha)
elif self.iou_type == 'siou':
# SIoU Loss https://arxiv.org/pdf/2205.12740.pdf
s_cw = (b2_x1 + b2_x2 - b1_x1 - b1_x2) * 0.5 + self.eps
s_ch = (b2_y1 + b2_y2 - b1_y1 - b1_y2) * 0.5 + self.eps
sigma = torch.pow(s_cw ** 2 + s_ch ** 2, 0.5)
sin_alpha_1 = torch.abs(s_cw) / sigma
sin_alpha_2 = torch.abs(s_ch) / sigma
threshold = pow(2, 0.5) / 2
sin_alpha = torch.where(sin_alpha_1 > threshold, sin_alpha_2, sin_alpha_1)
angle_cost = torch.cos(torch.arcsin(sin_alpha) * 2 - math.pi / 2)
rho_x = (s_cw / cw) ** 2
rho_y = (s_ch / ch) ** 2
gamma = angle_cost - 2
distance_cost = 2 - torch.exp(gamma * rho_x) - torch.exp(gamma * rho_y)
omiga_w = torch.abs(w1 - w2) / torch.max(w1, w2)
omiga_h = torch.abs(h1 - h2) / torch.max(h1, h2)
shape_cost = torch.pow(1 - torch.exp(-1 * omiga_w), 4) + torch.pow(1 - torch.exp(-1 * omiga_h), 4)
iou = iou - 0.5 * (distance_cost + shape_cost)
loss = 1.0 - iou
if self.reduction == 'sum':
loss = loss.sum()
elif self.reduction == 'mean':
loss = loss.mean()
return loss3.def pairwise_bbox_iou(box1, box2, box_format='xywh'):
def pairwise_bbox_iou(box1, box2, box_format='xywh'):
"""Calculate iou.
This code is based on https://github.com/Megvii-BaseDetection/YOLOX/blob/main/yolox/utils/boxes.py
"""
# lt （left top） ：计算交集的左上角坐标，使用 torch.max 取两个边界框左上角的最大值。
# rb （right bottom） ：计算交集的右下角坐标，使用 torch.min 取两个边界框右下角的最小值。
if box_format == 'xyxy':
lt = torch.max(box1[:, None, :2], box2[:, :2])
rb = torch.min(box1[:, None, 2:], box2[:, 2:])
area_1 = torch.prod(box1[:, 2:] - box1[:, :2], 1)
area_2 = torch.prod(box2[:, 2:] - box2[:, :2], 1)
elif box_format == 'xywh':
lt = torch.max(
(box1[:, None, :2] - box1[:, None, 2:] / 2),
(box2[:, :2] - box2[:, 2:] / 2),
)
rb = torch.min(
(box1[:, None, :2] + box1[:, None, 2:] / 2),
(box2[:, :2] + box2[:, 2:] / 2),
)
area_1 = torch.prod(box1[:, 2:], 1)
area_2 = torch.prod(box2[:, 2:], 1)
valid = (lt < rb).type(lt.type()).prod(dim=2)
inter = torch.prod(rb - lt, 2) * valid
# area_1[:, None] 是第一个边界框的面积，通过在 area_1 前面增加一个 None 维度，使其从一维数组变成二维数组，以便于进行广播（broadcasting）操作。
return inter / (area_1[:, None] + area_2 - inter)
# 在表达式 inter / (area_1[:, None] + area_2 - inter) 中， [:, None] 操作的意义是增加一个额外的维度，以便于进行广播（broadcasting）操作。这是一种常见的操作，用于使具有不同形状的数组能够进行数学运算。
# 具体来说 ：
# 1. area_1[:, None] ：
# area_1 是一个一维数组，包含了每个边界框的面积。
# [:, None] 操作在 area_1 的第二个维度（索引为 1 的维度）增加了一个新的轴，将其从形状 (n,) 变为 (n, 1) ，其中 n 是边界框的数量。
# 2. 广播机制 ：
# 在 PyTorch 中，广播机制允许形状不同的数组进行数学运算。当一个数组的形状是 (n, 1) ，另一个数组的形状是 (m,) 时，它们可以进行运算，因为 PyTorch 会自动将形状为 (m,) 的数组扩展到 (m, 1) ，然后沿着新的维度进行广播，使其形状变为 (n, m) 。
# 3. 应用在本例中：
# area_1[:, None] 使得 area_1 从 (n,) 变为 (n, 1) 。
# area_2 也是一个一维数组，形状为 (m,) 。
# 当执行 area_1[:, None] + area_2 时， area_2 被广播到 (n, m) ，其中 n 是 area_1 的长度， m 是 area_2 的长度。
# 这样，每个 area_1 中的元素都会与 area_2 中的每个元素相加，得到一个形状为 (n, m) 的结果。
# 4. 计算并集面积：
# 通过这种方式， area_1[:, None] + area_2 - inter 计算的是每个 area_1 中的边界框面积与每个 area_2 中的边界框面积之和，再减去它们之间的交集面积 inter ，得到并集面积。
# 总结来说， [:, None] 操作是为了使一维数组能够与另一个一维数组进行广播运算，从而在计算 IoU 时能够处理多个边界框的面积。这种操作在处理多维数组和批量操作时非常有用。