add Swin det eval code and configs

Author: xperzy

object_detection/Swin/box_ops.py

@@ -0,0 +1,168 @@
+import numpy as np
+import paddle
+
+
+def box_xyxy_to_cxcywh_numpy(box):
+    """convert box from top-left/bottom-right format:
+    [x0, y0, x1, y1]
+    to center-size format:
+    [center_x, center_y, width, height]
+
+    Args:
+        box: numpy array, last_dim=4, stop-left/bottom-right format boxes
+    Return:
+        numpy array, last_dim=4, center-size format boxes
+    """
+
+    #x0, y0, x1, y1 = box.unbind(-1)
+    x0 = box[:, 0]
+    y0 = box[:, 1]
+    x1 = box[:, 2]
+    y1 = box[:, 3]
+    xc = x0 + (x1-x0)/2
+    yc = y0 + (y1-y0)/2
+    w = x1 - x0
+    h = y1 - y0
+    return np.stack([xc, yc, w, h], axis=-1)
+
+
+
+def box_cxcywh_to_xyxy(box):
+    """convert box from center-size format:
+    [center_x, center_y, width, height]
+    to top-left/bottom-right format:
+    [x0, y0, x1, y1]
+
+    Args:
+        box: paddle.Tensor, last_dim=4, stores center-size format boxes
+    Return:
+        paddle.Tensor, last_dim=4, top-left/bottom-right format boxes
+    """
+
+    x_c, y_c, w, h = box.unbind(-1)
+    x0 = x_c - 0.5 * w
+    y0 = y_c - 0.5 * h
+    x1 = x_c + 0.5 * w
+    y1 = y_c + 0.5 * h
+    return paddle.stack([x0, y0, x1, y1], axis=-1)
+
+
+def box_xyxy_to_cxcywh(box):
+    """convert box from top-left/bottom-right format:
+    [x0, y0, x1, y1]
+    to center-size format:
+    [center_x, center_y, width, height]
+
+    Args:
+        box: paddle.Tensor, last_dim=4, stop-left/bottom-right format boxes
+    Return:
+        paddle.Tensor, last_dim=4, center-size format boxes
+    """
+
+    x0, y0, x1, y1 = box.unbind(-1)
+    xc = x0 + (x1-x0)/2
+    yc = y0 + (y1-y0)/2
+    w = x1 - x0
+    h = y1 - y0
+    return paddle.stack([xc, yc, w, h], axis=-1)
+
+
+def box_area(boxes):
+    """ compute area of a set of boxes in (x1, y1, x2, y2) format
+    Args:
+        boxes: paddle.Tensor, shape = Nx4, must in (x1, y1, x2, y2) format
+    Return:
+        areas: paddle.Tensor, N, areas of each box
+    """
+
+    return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+
+
+def box_iou(boxes1, boxes2):
+    """compute iou of 2 sets of boxes in (x1, y1, x2, y2) format
+
+    This method returns the iou between every pair of boxes 
+    in two sets of boxes.
+
+    Args:
+        boxes1: paddle.Tensor, shape=N x 4, boxes are stored in (x1, y1, x2, y2) format
+        boxes2: paddle.Tensor, shape=N x 4, boxes are stored in (x1, y1, x2, y2) format
+    Return:
+        iou: iou ratios between each pair of boxes in boxes1 and boxes2
+        union: union areas between each pair of boxes in boxes1 and boxes2
+    """
+
+    area1 = box_area(boxes1)
+    area2 = box_area(boxes2)
+
+    boxes1 = boxes1.unsqueeze(1) # N x 1 x 4
+    lt = paddle.maximum(boxes1[:, :, :2], boxes2[:, :2])
+    rb = paddle.minimum(boxes1[:, :, 2:], boxes2[:, 2:])
+
+    wh = (rb - lt).clip(min=0)
+    inter = wh[:, :, 0] * wh[:, :, 1]
+
+    union = area1.unsqueeze(1) + area2 - inter # broadcast
+
+    iou = inter / union
+    return iou, union
+
+
+def generalized_box_iou(boxes1, boxes2):
+    """Compute GIoU of each pais in boxes1 and boxes2 
+
+    GIoU = IoU - |A_c - U| / |A_c|
+    where A_c is the smallest convex hull that encloses both boxes, U is the union of boxes
+    Details illustrations can be found in https://giou.stanford.edu/
+
+    Args:
+        boxes1: paddle.Tensor, shape=N x 4, boxes are stored in (x1, y1, x2, y2) format
+        boxes2: paddle.Tensor, shape=N x 4, boxes are stored in (x1, y1, x2, y2) format
+    Return:
+        giou: giou ratios between each pair of boxes in boxes1 and boxes2
+    """
+
+    iou, union = box_iou(boxes1, boxes2)
+
+    boxes1 = boxes1.unsqueeze(1) # N x 1 x 4
+    lt = paddle.minimum(boxes1[:, :, :2], boxes2[:, :2])
+    rb = paddle.maximum(boxes1[:, :, 2:], boxes2[:, 2:])
+
+    wh = (rb - lt).clip(min=0)
+    area = wh[:, :, 0] * wh[:, :, 1]
+
+    return iou - (area-union) / area
+
+
+def masks_to_boxes(masks):
+    """convert masks to bboxes
+
+    Args:
+        masks: paddle.Tensor, NxHxW
+    Return:
+        boxes: paddle.Tensor, Nx4
+    """
+
+    if masks.numel() == 0:
+        return paddle.zeros((0, 4))
+    h, w = masks.shape[-2:]
+    y = paddle.arange(0, h, dtype='float32')
+    x = paddle.arange(0, w, dtype='float32')
+    y, x = paddle.meshgrid(y, x)
+
+    x_mask = (masks * x.unsqueeze(0))
+    x_max = x_mask.flatten(1).max(-1)[0]
+
+    #x_min = x_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)
+    x_min = paddle.where(masks == 0, paddle.ones_like(x_mask)*float(1e8), x_mask)
+    x_min = x_min.flatten(1).min(-1)[0]
+
+    y_mask = (masks * y.unsqueeze(0))
+    y_max = y_mask.flatten(1).max(-1)[0]
+    #y_min = y_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]
+    y_min = paddle.where(masks == 0, paddle.ones_like(y_mask) * float(1e8), y_mask)
+    y_min = y_min.flatten(1).min(-1)[0]
+
+    return paddle.stack([x_min, y_min, x_max, y_max], 1)
+
+