def check_mask_voting(self, seg_prob, bbox, cls_prob, size, bg_label,
roi_size):
xp = chainer.cuda.get_array_module(seg_prob)
seg_prob, bbox, label, cls_prob = mask_voting(seg_prob,
bbox,
cls_prob,
size,
0.5,
0.3,
0.5,
0.4,
bg_label=bg_label)
n_roi = seg_prob.shape[0]
self.assertIsInstance(seg_prob, xp.ndarray)
self.assertEqual(seg_prob.shape[1:], (roi_size, roi_size))
self.assertTrue(
xp.all(xp.logical_and(seg_prob >= 0.0, seg_prob <= 1.0)))
self.assertIsInstance(label, xp.ndarray)
self.assertEqual(label.shape, (n_roi, ))
self.assertIsInstance(cls_prob, xp.ndarray)
self.assertEqual(cls_prob.shape, (n_roi, ))
assert_is_bbox(bbox, size)
def test_cub_label_dataset(self):
assert_is_label_dataset(
self.dataset, len(cub_label_names), n_example=10)
idx = np.random.choice(np.arange(10))
if self.return_bb:
bb = self.dataset[idx][2]
assert_is_bbox(bb[np.newaxis])
if self.return_prob_map:
img = self.dataset[idx][0]
prob_map = self.dataset[idx][-1]
self.assertEqual(prob_map.dtype, np.float32)
self.assertEqual(prob_map.shape, img.shape[1:])
self.assertTrue(np.min(prob_map) >= 0)
self.assertTrue(np.max(prob_map) <= 1)
def test_cub_label_dataset(self):
assert_is_label_dataset(self.dataset,
len(cub_label_names),
n_example=10)
idx = np.random.choice(np.arange(10))
if self.return_bb:
bb = self.dataset[idx][2]
assert_is_bbox(bb[np.newaxis])
if self.return_prob_map:
img = self.dataset[idx][0]
prob_map = self.dataset[idx][-1]
self.assertEqual(prob_map.dtype, np.float32)
self.assertEqual(prob_map.shape, img.shape[1:])
self.assertTrue(np.min(prob_map) >= 0)
self.assertTrue(np.max(prob_map) <= 1)
def test_generate_random_bbox(self):
img_size = (128, 256)
min_length = 16
max_length = 48
bbox = generate_random_bbox(self.n, img_size, min_length, max_length)
assert_is_bbox(bbox, img_size)
self.assertEqual(bbox.shape[0], self.n)
if self.n > 0:
h = bbox[:, 2] - bbox[:, 0]
w = bbox[:, 3] - bbox[:, 1]
self.assertTrue(np.all(h < max_length))
self.assertTrue(np.all(h >= min_length))
self.assertTrue(np.all(w < max_length))
self.assertTrue(np.all(w >= min_length))
def test_camvid_dataset(self):
assert_is_point_dataset(self.dataset, n_point=15, n_example=10)
idx = np.random.choice(np.arange(10))
if self.return_bb:
if self.return_prob_map:
bb = self.dataset[idx][-2]
else:
bb = self.dataset[idx][-1]
assert_is_bbox(bb[np.newaxis])
if self.return_prob_map:
img = self.dataset[idx][0]
prob_map = self.dataset[idx][-1]
self.assertEqual(prob_map.dtype, np.float32)
self.assertEqual(prob_map.shape, img.shape[1:])
self.assertTrue(np.min(prob_map) >= 0)
self.assertTrue(np.max(prob_map) <= 1)
def test_generate_random_bbox(self):
n = 32
img_size = (128, 256)
min_length = 16
max_length = 48
bbox = generate_random_bbox(n, img_size, min_length, max_length)
assert_is_bbox(bbox, img_size)
self.assertEqual(bbox.shape[0], n)
h = bbox[:, 2] - bbox[:, 0]
w = bbox[:, 3] - bbox[:, 1]
self.assertTrue(np.all(h < max_length))
self.assertTrue(np.all(h >= min_length))
self.assertTrue(np.all(w < max_length))
self.assertTrue(np.all(w >= min_length))
def _check_predict(self):
if self.return_values == 'detection':
assert_is_detection_link(self.link, self.n_fg_class)
elif self.return_values == 'instance_segmentation':
assert_is_instance_segmentation_link(self.link, self.n_fg_class)
elif self.return_values == 'rpn':
imgs = [
np.random.randint(
0, 256, size=(3, 480, 320)).astype(np.float32),
np.random.randint(
0, 256, size=(3, 480, 320)).astype(np.float32)]
result = self.link.predict(imgs)
assert len(result) == 1
assert len(result[0]) == len(imgs)
for i in range(len(result[0])):
roi = result[0][i]
assert_is_bbox(roi)
def test_coco_instance_segmentation_dataset(self):
assert_is_instance_segmentation_dataset(
self.dataset,
len(coco_instance_segmentation_label_names),
n_example=10)
if self.return_area:
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
_, mask, _, area = self.dataset[i][:4]
self.assertIsInstance(area, np.ndarray)
self.assertEqual(area.dtype, np.float32)
self.assertEqual(area.shape, (mask.shape[0],))
if self.return_crowded:
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
example = self.dataset[i]
if self.return_area:
crowded = example[4]
else:
crowded = example[3]
mask = example[1]
self.assertIsInstance(crowded, np.ndarray)
self.assertEqual(crowded.dtype, np.bool)
self.assertEqual(crowded.shape, (mask.shape[0],))
if not self.use_crowded:
np.testing.assert_equal(crowded, 0)
if self.return_bbox:
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
example = self.dataset[i]
bbox = example[-1]
img, mask = example[:2]
assert_is_bbox(bbox, img.shape[1:])
self.assertEqual(len(bbox), len(mask))
def test_coco_keypoint_dataset(self):
human_id = 0
assert_is_point_dataset(
self.dataset, len(coco_keypoint_names[human_id]),
n_example=30)
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
img, point, _, label, bbox = self.dataset[i][:5]
assert_is_bbox(bbox, img.shape[1:])
self.assertEqual(len(bbox), len(point))
self.assertIsInstance(label, np.ndarray)
self.assertEqual(label.dtype, np.int32)
self.assertEqual(label.shape, (point.shape[0],))
if self.return_area:
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
_, point, _, _, _, area = self.dataset[i][:6]
self.assertIsInstance(area, np.ndarray)
self.assertEqual(area.dtype, np.float32)
self.assertEqual(area.shape, (point.shape[0],))
if self.return_crowded:
for _ in range(10):
i = np.random.randint(0, len(self.dataset))
example = self.dataset[i]
crowded = example[-1]
point = example[1]
self.assertIsInstance(crowded, np.ndarray)
self.assertEqual(crowded.dtype, np.bool)
self.assertEqual(crowded.shape, (point.shape[0],))
if not self.use_crowded:
np.testing.assert_equal(crowded, 0)
def test_assert_is_bbox(self):
if self.valid:
assert_is_bbox(self.bbox, self.size)
else:
with self.assertRaises(AssertionError):
assert_is_bbox(self.bbox, self.size)
def test_assert_is_bbox(self):
if self.valid:
assert_is_bbox(self.bbox, self.size)
else:
with self.assertRaises(AssertionError):
assert_is_bbox(self.bbox, self.size)