def get_boxes_from_image_dataframe(image_data, image_size):
if not image_data.empty:
# get the labels
label_ids_global = torch.tensor(list(image_data["classid"]),
dtype=torch.long)
difficult_flag = torch.tensor(list(image_data["difficult"] == 1),
dtype=torch.bool)
# get the boxes
boxes = image_data[["lx", "ty", "rx", "by"]].to_numpy()
# renorm boxes using the image size
boxes[:, 0] *= image_size.w
boxes[:, 2] *= image_size.w
boxes[:, 1] *= image_size.h
boxes[:, 3] *= image_size.h
boxes = torch.FloatTensor(boxes)
boxes = BoxList(boxes, image_size=image_size, mode="xyxy")
else:
boxes = BoxList.create_empty(image_size)
label_ids_global = torch.tensor([], dtype=torch.long)
difficult_flag = torch.tensor([], dtype=torch.bool)
boxes.add_field("labels", label_ids_global)
boxes.add_field("difficult", difficult_flag)
boxes.add_field("labels_original", label_ids_global)
boxes.add_field("difficult_original", difficult_flag)
return boxes
def show_annotated_image(img,
boxes,
labels,
scores,
class_ids,
score_threshold=0.0,
default_boxes=None,
transform_corners=None,
max_dets=None,
showfig=False,
image_id=None):
good_ids = torch.nonzero(scores.float() > score_threshold).view(-1)
if good_ids.numel() > 0:
if max_dets is not None:
_, ids = scores[good_ids].sort(descending=False)
good_ids = good_ids[ids[-max_dets:]]
boxes = boxes[good_ids].cpu()
labels = labels[good_ids].cpu()
scores = scores[good_ids].cpu()
label_names = ["Cl " + str(l.item()) for l in labels]
box_colors = ["yellow"] * len(boxes)
else:
boxes = BoxList.create_empty(boxes.image_size)
labels = torch.LongTensor(0)
scores = torch.FloatTensor(0)
label_names = []
box_colors = []
# create visualizations of default boxes
if default_boxes is not None:
default_boxes = default_boxes[good_ids].cpu()
# append boxes
boxes = torch.cat([default_boxes.bbox_xyxy, boxes.bbox_xyxy], 0)
labels = torch.cat(
[torch.Tensor(len(default_boxes)).to(labels).zero_(), labels], 0)
scores = torch.cat([
torch.Tensor(len(default_boxes)).to(scores).fill_(float("nan")),
scores
], 0)
label_names = [""] * len(default_boxes) + label_names
box_colors = ["cyan"] * len(default_boxes) + box_colors
else:
boxes = boxes.bbox_xyxy
if transform_corners is not None:
# draw polygons representing the corners of a transformation
transform_corners = transform_corners[good_ids].cpu()
vis_image(img,
showfig=showfig,
boxes=boxes,
scores=scores,
label_names=label_names,
colors=box_colors,
image_id=image_id,
polygons=transform_corners)
return
def _transform_image_to_pyramid(self,
image_id,
boxes=None,
do_augmentation=True,
hflip=False,
vflip=False,
pyramid_scales=(1, ),
mined_data=None):
img = self._get_dataset_image_by_id(image_id)
img_size = FeatureMapSize(img=img)
do_augmentation = do_augmentation and self.data_augmentation is not None
num_pyramid_levels = len(pyramid_scales)
use_mined_crop = mined_data is not None
if use_mined_crop:
crop_position = mined_data["crop_position_xyxy"]
if boxes is None:
boxes = BoxList.create_empty(img_size)
mask_cutoff_boxes = torch.zeros(len(boxes), dtype=torch.bool)
mask_difficult_boxes = torch.zeros(len(boxes), dtype=torch.bool)
box_inverse_transform = TransformList()
# batch level data augmentation
img, boxes = transforms_boxes.transpose(
img,
hflip=hflip,
vflip=vflip,
boxes=boxes,
transform_list=box_inverse_transform)
if use_mined_crop:
# update crop_position_xyxy with the symmetries
if hflip or vflip:
_, crop_position = transforms_boxes.transpose(
img, hflip=hflip, vflip=vflip, boxes=crop_position)
if do_augmentation:
if self.data_augmentation.do_random_crop:
if not use_mined_crop:
img, boxes, mask_cutoff_boxes, mask_difficult_boxes = \
self.data_augmentation.random_crop(img,
boxes=boxes,
transform_list=box_inverse_transform)
else:
img, boxes, mask_cutoff_boxes, mask_difficult_boxes = \
self.data_augmentation.crop_image(img, crop_position,
boxes=boxes,
transform_list=box_inverse_transform)
img, boxes = transforms_boxes.resize(
img,
target_size=self.data_augmentation.random_crop_size,
random_interpolation=self.data_augmentation.
random_interpolation,
boxes=boxes,
transform_list=box_inverse_transform)
# color distortion
img = self.data_augmentation.random_distort(img)
random_interpolation = self.data_augmentation.random_interpolation if do_augmentation else False
img_size = FeatureMapSize(img=img)
pyramid_sizes = [
FeatureMapSize(w=int(img_size.w * s), h=int(img_size.h * s))
for s in pyramid_scales
]
img_pyramid = []
boxes_pyramid = []
pyramid_box_inverse_transform = []
for p_size in pyramid_sizes:
box_inverse_transform_this_scale = copy.deepcopy(
box_inverse_transform)
p_img, p_boxes = transforms_boxes.resize(
img,
target_size=p_size,
random_interpolation=random_interpolation,
boxes=boxes,
transform_list=box_inverse_transform_this_scale)
pyramid_box_inverse_transform.append(
box_inverse_transform_this_scale)
img_pyramid.append(p_img)
boxes_pyramid.append(p_boxes)
transforms_th = [transforms.ToTensor()]
if self.img_normalization is not None:
transforms_th += [
transforms.Normalize(self.img_normalization["mean"],
self.img_normalization["std"])
]
for i_p in range(num_pyramid_levels):
img_pyramid[i_p] = transforms.Compose(transforms_th)(
img_pyramid[i_p])
return img_pyramid, boxes_pyramid, mask_cutoff_boxes, mask_difficult_boxes, pyramid_box_inverse_transform
def evaluate_detections(self,
all_boxes,
output_dir,
mAP_iou_threshold=0.5):
predictions = []
gt_boxes = []
roidb = self.roidb
for i_image, roi in enumerate(roidb):
image_size = FeatureMapSize(w=roi["width"], h=roi["height"])
if roi["boxes"].size > 0:
roi_gt_boxes = BoxList(roi["boxes"], image_size, mode="xyxy")
else:
roi_gt_boxes = BoxList.create_empty(image_size)
roi_gt_boxes.add_field(
"labels", torch.as_tensor(roi["gt_classes"],
dtype=torch.int32))
roi_gt_boxes.add_field(
"difficult",
torch.as_tensor(roi["gt_ishard"], dtype=torch.int32))
gt_boxes.append(roi_gt_boxes)
roi_detections = []
for i_class, class_boxes in enumerate(all_boxes):
assert len(class_boxes) == len(roidb), \
"Number of detection for class {0} image{1} ({2}) inconsistent with the length of roidb ({3})".format(i_class, i_image, len(class_boxes), len(roidb))
boxes = class_boxes[i_image]
if len(boxes) > 0:
assert boxes.shape[
1] == 5, "Detections should be of shape (:,5), but are {0} for class {1}, image {2}".format(
boxes.shape, i_class, i_image)
bbox = BoxList(boxes[:, :4], image_size, mode="xyxy")
scores = boxes[:, -1]
bbox.add_field(
"scores", torch.as_tensor(scores, dtype=torch.float32))
bbox.add_field(
"labels",
torch.full(scores.shape, i_class, dtype=torch.int32))
roi_detections.append(bbox)
if roi_detections:
roi_detections = cat_boxlist(roi_detections)
else:
roi_detections = BoxList.create_empty(image_size)
roi_detections.add_field(
"scores", torch.zeros((0, ), dtype=torch.float32))
roi_detections.add_field("labels",
torch.zeros((0, ), dtype=torch.int32))
predictions.append(roi_detections)
if False:
self.visualize_detections(i_image,
gt=roi_gt_boxes,
dets=roi_detections)
ap_data = do_voc_evaluation(predictions,
gt_boxes,
iou_thresh=mAP_iou_threshold,
use_07_metric=False)
print("mAP@{:0.2f}: {:0.4f}".format(mAP_iou_threshold, ap_data["map"]))
print("mAPw@{:0.2f}: {:0.4f}".format(mAP_iou_threshold,
ap_data["map_weighted"]))
print("recall@{:0.2f}: {:0.4f}".format(mAP_iou_threshold,
ap_data["recall"]))
return ap_data['map']