Yolov5's original loss function is ciou. When a = 3, the accuracy of using a-ciou will decrease by 1.2%. Is it true that a-ciou is not as effective as ciou?

Thanks for your excellent project. When I test the trained model, I find this error. In the file models/common.py, I can't find the class SSPF. Could you please tell me the cause of this problem？ Thank you very much !

Hi, I have tried to train alpha-iou with the Faster R-CNN using mmdetection. And the results confused me, cuz I couldn't got the same result as you described in paper. And I guss it maybe the different of loss weight you defined. Can you share your loss weight of your alpha-iou pre-defined ? My config is as below:

_base_ = './faster_rcnn_r50_fpn_1x_coco.py'
model = dict(
    roi_head=dict(
        bbox_head=dict(
            reg_decoded_bbox=True,
            loss_bbox=dict(type='AlphaIoULoss', loss_weight=1.0)
        )
    )
)

Hope to get your reply as soon as possible :) Thanks a lot 🤖

Dear author, Thanks for your work. I have a question about the result.png in runs/train.The loss of objectness and val objectness rise in the initial stage in voc_yolov5s_3diou result.png，I don't know how to explain this phenomenon.Besides,I cloned your code and run on my computer, i set batch-size=8 and set the funtcion bbox_iou function(DIoU=true , alpha=1) .And i got the [email protected] = 75.04, [email protected]:0.95=47.95. Could you please give me some suggestion on it. Thanks.

Hi, I have applied alpha IOU to yolov5, but I also applied EIOU to the algorithm. It seems that the function in your file named "general.py" code does not contain EIOU. Would you like to know how to modify the code if you want to add it? The following is the code written by a blogger I saw on CSDN, but when I train the model, the effect is not as good as the alpha IOU or eiou provided by you. The training effect is reduced by combining these two items. I think it may be a code problem, (Maybe it is the problem of dataset that I used.) so I want to ask you how you can combine eiou and alpha IOU?

# 参考：https://mp.weixin.qq.com/s/l22GJtA7Vd11dpY9QG4k2A
def bbox_alpha_iou(box1, box2, x1y1x2y2=False, GIoU=False, DIoU=False, CIoU=False, EIoU=False, alpha=3, eps=1e-9):
    # Returns tsqrt_he IoU of box1 to box2. box1 is 4, box2 is nx4
    box2 = box2.T

    # Get the coordinates of bounding boxes
    if x1y1x2y2:  # x1, y1, x2, y2 = box1
        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]
    else:  # transform from xywh to xyxy
        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

    # Intersection area
    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 + eps
    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
    union = w1 * h1 + w2 * h2 - inter + eps

    # change iou into pow(iou+eps) 加入α次幂
    # alpha iou
    iou = torch.pow(inter / union + eps, alpha)
    beta = 2 * alpha
    if GIoU or DIoU or CIoU or EIoU:
        # 两个框的最小闭包区域的width和height
        cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1)  # convex (smallest enclosing box) width
        ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1)  # convex height

        if CIoU or DIoU or EIoU:  # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
            # 最小外接矩形 对角线的长度平方
            c2 = cw ** beta + ch ** beta + eps  # convex diagonal
            rho_x = torch.abs(b2_x1 + b2_x2 - b1_x1 - b1_x2)
            rho_y = torch.abs(b2_y1 + b2_y2 - b1_y1 - b1_y2)
            # 两个框中心点之间距离的平方
            rho2 = (rho_x ** beta + rho_y ** beta) / (2 ** beta)  # center distance
            if DIoU:
                return iou - rho2 / c2  # DIoU

            elif CIoU:  # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
                v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
                with torch.no_grad():
                    alpha_ciou = v / ((1 + eps) - inter / union + v)
                # return iou - (rho2 / c2 + v * alpha_ciou)  # CIoU
                return iou - (rho2 / c2 + torch.pow(v * alpha_ciou + eps, alpha))  # CIoU

            # EIoU 在CIoU的基础上
            # 将预测框宽高的纵横比损失项 拆分成预测框的宽高分别与最小外接框宽高的差值
            # 加速了收敛提高了回归精度
            elif EIoU:
                rho_w2 = ((b2_x2 - b2_x1) - (b1_x2 - b1_x1)) ** beta
                rho_h2 = ((b2_y2 - b2_y1) - (b1_y2 - b1_y1)) ** beta
                cw2 = cw ** beta + eps
                ch2 = ch ** beta + eps
                return iou - (rho2 / c2 + rho_w2 / cw2 + rho_h2 / ch2)

            # GIoU https://arxiv.org/pdf/1902.09630.pdf
            c_area = torch.max(cw * ch + eps, union)  # convex area
            return iou - torch.pow((c_area - union) / c_area + eps, alpha)  # GIoU
    else:
        return iou  # torch.log(iou+eps) or iou

Hope to get your reply as soon as possible. Thank you so much!!!

Dear author, Thanks for your work. I have a question about the the formula of alpha-DIoU loss in Eq. (4) from the paper. The alpha-version of the penalty term computed based on B and Bgt is ρ^(2alpha) / c^(2alpha), where ρ(·) being the Euclidean distance and c being the diagonal length of the smallest enclosing box. In your code, utils/general.py, line 405: c2 = cw ** beta + ch ** beta + eps # convex diagonal and line 408: rho2 = (rho_x ** beta + rho_y ** beta) / (2 ** beta) # center distance, it calculates the alpha version of penalty term as (w^(2alpha) + h^(2alpha)) / ( ρx^(2alpha) + ρy^(2alpha)) [type 1]. Why not ((w^2 + h^2) / (ρx^2 + ρy^2))^alpha [type 2]? It seems type 2 is reasonable because it follows the form (term)^alpha, such as IoU^alpha, (BV)^alpha and keeps the representation of Euclidean distance. In type 1, I don't understand the meaning of w^(2alpha) + h^(2alpha), does it still mean distance? Could you please explain more details about your design and why it is better than type 2? I don't find the theoretical analysis about this part in the paper. Thanks

Hello, when I used the command line of the code you published, the accuracy was very low, and the accuracy was normal after adding "noAutoAnchor" in the command line. May I ask whether you used "NoAutoAnchor" in your original experiment?

Traceback (most recent call last):
  File "train.py", line 539, in <module>
    train(hyp, opt, device, tb_writer, wandb)
  File "train.py", line 199, in train
    image_weights=opt.image_weights, quad=opt.quad, prefix=colorstr('train: '))
  File "/data/yolo/Alpha-IoU/utils/datasets.py", line 72, in create_dataloader
    prefix=prefix)
  File "/data/yolo/Alpha-IoU/utils/datasets.py", line 399, in __init__
    cache, exists = torch.load(cache_path), True  # load
  File "/data/Anaconda3/envs/torch17/lib/python3.7/site-packages/torch/serialization.py", line 595, in load
    return _legacy_load(opened_file, map_location, pickle_module, **pickle_load_args)
  File "/data/Anaconda3/envs/torch17/lib/python3.7/site-packages/torch/serialization.py", line 764, in _legacy_load
    magic_number = pickle_module.load(f, **pickle_load_args)
_pickle.UnpicklingError: STACK_GLOBAL requires str