def setUp(self):
n_bbox = 8
feat_size = (self.img_size[0] // 16, self.img_size[1] // 16)
self.n_anchor = self.n_anchor_base * np.prod(feat_size)
self.anchor = generate_random_bbox(
self.n_anchor, self.img_size, 16, 200)
self.bbox = generate_random_bbox(n_bbox, self.img_size, 16, 200)
self.anchor_target_layer = AnchorTargetCreator(
self.n_sample, pos_ratio=self.pos_ratio,
)
def setUp(self):
n_bbox = 8
feat_size = (self.img_size[0] // 16, self.img_size[1] // 16)
self.n_anchor = self.n_anchor_base * np.prod(feat_size)
self.anchor = generate_random_bbox(self.n_anchor, self.img_size, 16,
200)
self.bbox = generate_random_bbox(n_bbox, self.img_size, 16, 200)
self.anchor_target_layer = AnchorTargetCreator(
self.n_sample,
pos_ratio=self.pos_ratio,
)
def setUp(self):
n_roi = 1024
n_bbox = 10
self.roi = generate_random_bbox(n_roi, (392, 512), 16, 250)
self.bbox = generate_random_bbox(n_bbox, (392, 512), 16, 250)
self.label = np.random.randint(
0, self.n_class - 1, size=(n_bbox,), dtype=np.int32)
self.proposal_target_creator = ProposalTargetCreator(
n_sample=self.n_sample,
pos_ratio=self.pos_ratio,
)
def setUp(self):
self.roi = generate_random_bbox(self.n_roi, (392, 512), 16, 250)
self.bbox = generate_random_bbox(self.n_bbox, (392, 512), 16, 250)
self.label = np.random.randint(0,
self.n_class - 1,
size=(self.n_bbox, ),
dtype=np.int32)
self.proposal_target_creator = ProposalTargetCreator(
n_sample=self.n_sample,
pos_ratio=self.pos_ratio,
)
def __call__(self, x, img_size, scale):
B, _, H, W = x.shape
n_anchor = self.n_anchor_base * H * W
rpn_locs = _random_array(self.xp, (B, n_anchor, 4))
rpn_cls_scores = _random_array(self.xp, (B, n_anchor, 2))
rois = self.xp.asarray(
generate_random_bbox(self.n_roi, img_size, 16, min(img_size)))
roi_indices = self.xp.zeros((len(rois), ), dtype=np.int32)
anchor = self.xp.asarray(
generate_random_bbox(n_anchor, img_size, 16, min(img_size)))
return (chainer.Variable(rpn_locs), chainer.Variable(rpn_cls_scores),
rois, roi_indices, anchor)
def __call__(self, x, img_size, scale):
B, _, H, W = x.shape
n_anchor = self.n_anchor_base * H * W
rpn_locs = _random_array(self.xp, (B, n_anchor, 4))
rpn_cls_scores = _random_array(self.xp, (B, n_anchor, 2))
rois = self.xp.asarray(generate_random_bbox(
self.n_roi, img_size, 16, min(img_size)))
roi_indices = self.xp.zeros((len(rois),), dtype=np.int32)
anchor = self.xp.asarray(generate_random_bbox(
n_anchor, img_size, 16, min(img_size)))
return (chainer.Variable(rpn_locs),
chainer.Variable(rpn_cls_scores), rois, roi_indices, anchor)
def setUp(self):
self.n_anchor_base = 6
self.feat_stride = 4
self.n_fg_class = 3
self.n_roi = 24
self.n_bbox = 3
self.model = LightHeadRCNNTrainChain(
DummyLightHeadRCNN(
n_anchor_base=self.n_anchor_base,
feat_stride=self.feat_stride,
n_fg_class=self.n_fg_class,
n_roi=self.n_roi,
min_size=600,
max_size=800,
loc_normalize_mean=(0., 0., 0., 0.),
loc_normalize_std=(0.1, 0.1, 0.2, 0.2),
))
self.bboxes = generate_random_bbox(self.n_bbox, (600, 800), 16,
350)[np.newaxis]
self.labels = np.random.randint(0,
self.n_fg_class,
size=(1, self.n_bbox)).astype(np.int32)
self.imgs = _random_array((1, 3, 600, 800))
self.scales = np.array([1.])
def test_random_crop_with_bbox_constraints(self):
img = np.random.randint(0, 256, size=(3, 480, 640)).astype(np.float32)
bbox = generate_random_bbox(10, img.shape[1:], 0.1, 0.9)
out, param = random_crop_with_bbox_constraints(img,
bbox,
min_scale=0.3,
max_scale=1,
max_aspect_ratio=2,
return_param=True)
if param['constraint'] is None:
np.testing.assert_equal(out, img)
else:
np.testing.assert_equal(out, img[:, param['y_slice'],
param['x_slice']])
self.assertGreaterEqual(out.size, img.size * 0.3 * 0.3)
self.assertLessEqual(out.size, img.size * 1 * 1)
# to ignore rounding error, add 1
self.assertLessEqual(out.shape[1] / (out.shape[2] + 1),
img.shape[1] / img.shape[2] * 2)
self.assertLessEqual(out.shape[2] / (out.shape[1] + 1),
img.shape[2] / img.shape[1] * 2)
bb = np.array((param['y_slice'].start, param['x_slice'].start,
param['y_slice'].stop, param['x_slice'].stop))
iou = bbox_iou(bb[np.newaxis], bbox)
min_iou, max_iou = param['constraint']
if min_iou:
self.assertGreaterEqual(iou.min(), min_iou)
if max_iou:
self.assertLessEqual(iou.max(), max_iou)
def setUp(self):
self.img = np.random.randint(0, 255, size=(3, 32, 48))
self.bbox = generate_random_bbox(self.n_bbox, (48, 32), 8, 16)
if self.label is not None:
self.label = np.array(self.label, dtype=int)
if self.score is not None:
self.score = np.array(self.score)
def get_example(self, i):
img = np.random.randint(0, 256, size=(3, 48, 64))
n_bbox = np.random.randint(10, 20)
bbox = generate_random_bbox(n_bbox, (48, 64), 5, 20)
label = np.random.randint(0, 20, size=n_bbox).astype(np.int32)
return (img, bbox, label) + self.options
def test_non_maximum_suppression_consistency(self):
bbox = generate_random_bbox(6000, (600, 800), 32, 512)
cpu_selec = non_maximum_suppression(bbox, 0.5)
gpu_selec = non_maximum_suppression(cuda.to_gpu(bbox), 0.5)
np.testing.assert_equal(cpu_selec, cuda.to_cpu(gpu_selec))
def test_non_maximum_suppression_consistency(self):
bbox = generate_random_bbox(6000, (600, 800), 32, 512)
cpu_selec = non_maximum_suppression(bbox, 0.5)
gpu_selec = non_maximum_suppression(cuda.to_gpu(bbox), 0.5)
np.testing.assert_equal(cpu_selec, cuda.to_cpu(gpu_selec))
def setUp(self):
self.comm = create_communicator('naive')
batchsize_per_process = 5
batchsize = batchsize_per_process * self.comm.size
if self.comm.rank == 0:
bboxes = [
generate_random_bbox(5, (256, 324), 24, 120) for _ in range(10)
]
labels = [
np.random.choice(np.arange(3, dtype=np.int32), size=(5, ))
for _ in range(10)
]
else:
bboxes = None
labels = None
initial_count = self.comm.rank * batchsize_per_process
bboxes = self.comm.bcast_obj(bboxes)
labels = self.comm.bcast_obj(labels)
self.bboxes = bboxes
self.labels = labels
self.dataset = TupleDataset(np.random.uniform(size=(10, 3, 32, 48)),
bboxes, labels)
self.initial_count = initial_count
self.batchsize = batchsize
def get_example(self, i):
img = np.random.randint(0, 256, size=(3, 48, 64))
n_bbox = np.random.randint(10, 20)
mask = np.random.randint(0, 2, size=(n_bbox, 48, 64), dtype=np.bool)
bbox = generate_random_bbox(n_bbox, (48, 64), 5, 20)
label = np.random.randint(0, 20, size=n_bbox).astype(np.int32)
return (img, bbox, mask, label) + self.options
def setUp(self):
self.img = np.random.randint(0, 255, size=(3, 32, 48))
self.bbox = generate_random_bbox(
self.n_bbox, (48, 32), 8, 16)
if self.label is not None:
self.label = np.array(self.label, dtype=int)
if self.score is not None:
self.score = np.array(self.score)
def setUp(self):
n_roi = 5
n_class = 6
self.roi_size = 7
self.size = (18, 24)
self.bg_label = 0
self.roi_mask_prob = np.random.uniform(size=(n_roi, self.roi_size,
self.roi_size))
self.roi_prob = np.random.uniform(size=(n_roi, n_class))
self.bbox = generate_random_bbox(n_roi, self.size, 0, 18)
def test_rotate_bbox(self):
size = (32, 24)
bbox = generate_random_bbox(10, size, 0, 24)
out = rotate_bbox(bbox, self.angle, size)
if self.angle % 180 != 0:
rotate_size = size[::-1]
else:
rotate_size = size
out = rotate_bbox(out, -1 * self.angle, rotate_size)
np.testing.assert_almost_equal(out, bbox, decimal=6)
def predict(self, imgs):
bboxes = []
labels = []
scores = []
for _ in imgs:
n_bbox = np.random.randint(0, 10)
bboxes.append(generate_random_bbox(n_bbox, (48, 32), 4, 12))
labels.append(np.random.randint(0, 19, size=n_bbox))
scores.append(np.random.uniform(0, 1, size=n_bbox))
return bboxes, labels, scores
def setUp(self):
if hasattr(self, 'no_img'):
self.img = None
else:
self.img = np.random.randint(0, 255, size=(3, 32, 48))
self.bbox = generate_random_bbox(self.n_bbox, (48, 32), 8, 16)
if self.label is not None:
self.label = np.array(self.label, dtype=int)
if self.score is not None:
self.score = np.array(self.score)
if not hasattr(self, 'instance_colors'):
self.instance_colors = None
def predict(self, imgs):
bboxes = []
labels = []
scores = []
for _ in imgs:
n_bbox = np.random.randint(0, 10)
bboxes.append(generate_random_bbox(
n_bbox, (48, 32), 4, 12))
labels.append(np.random.randint(0, 19, size=n_bbox))
scores.append(np.random.uniform(0, 1, size=n_bbox))
return bboxes, labels, scores
def setUp(self):
bboxes = [generate_random_bbox(5, (256, 324), 24, 120)
for _ in range(10)]
labels = np.ones((10, 5))
self.dataset = TupleDataset(
np.random.uniform(size=(10, 3, 32, 48)),
bboxes,
labels)
self.link = _DetectionStubLink(bboxes, labels)
self.iterator = SerialIterator(
self.dataset, 5, repeat=False, shuffle=False)
self.evaluator = DetectionVOCEvaluator(self.iterator, self.link)
self.expect_map = 1
def setUp(self):
feat_size = (self.img_size[0] // 16, self.img_size[1] // 16)
n_anchor = np.int32(self.n_anchor_base * np.prod(feat_size))
self.score = np.random.uniform(low=0, high=1,
size=(n_anchor, )).astype(np.float32)
self.bbox_d = np.random.uniform(low=-1, high=1.,
size=(n_anchor, 4)).astype(np.float32)
self.anchor = generate_random_bbox(n_anchor, self.img_size, 16, 200)
self.proposal_creator = ProposalCreator(
n_train_post_nms=self.n_train_post_nms,
n_test_post_nms=self.n_test_post_nms,
min_size=0)
def predict(self, imgs):
bboxes = []
labels = []
scores = []
for img in imgs:
n_bbox = np.random.randint(1, 10)
bboxes.append(generate_random_bbox(n_bbox, img.shape[1:], 4, 12))
labels.append(
np.random.randint(0, 20, size=n_bbox).astype(np.int32))
scores.append(
np.random.uniform(0, 1, size=n_bbox).astype(np.float32))
return bboxes, labels, scores
def setUp(self):
bboxes = [generate_random_bbox(5, (256, 324), 24, 120)
for _ in range(10)]
labels = np.ones((10, 5))
self.dataset = TupleDataset(
np.random.uniform(size=(10, 3, 32, 48)),
bboxes,
labels)
self.link = _DetectionStubLink(bboxes, labels)
self.iterator = SerialIterator(
self.dataset, 5, repeat=False, shuffle=False)
self.evaluator = DetectionVOCEvaluator(
self.iterator, self.link, label_names=('cls0', 'cls1', 'cls2'))
self.expected_ap = 1
def setUp(self):
faster_rcnn = FasterRCNNVGG16(
n_fg_class=self.n_fg_class, pretrained_model=False)
self.link = FasterRCNNTrainChain(faster_rcnn)
self.n_bbox = 3
self.bboxes = chainer.Variable(
generate_random_bbox(self.n_bbox, (600, 800), 16, 350)[np.newaxis])
_labels = np.random.randint(
0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32)
self.labels = chainer.Variable(_labels)
_imgs = np.random.uniform(
low=-122.5, high=122.5, size=(1, 3, 600, 800)).astype(np.float32)
self.imgs = chainer.Variable(_imgs)
self.scale = chainer.Variable(np.array(1.))
def setUp(self):
n_roi = 1024
n_mask = 10
img_size = (392, 512)
self.roi = generate_random_bbox(n_roi, img_size, 16, 250)
self.mask = np.random.uniform(size=(n_mask, img_size[0],
img_size[1])) > 0.5
self.label = np.random.randint(0,
self.n_class - 1,
size=(n_mask, ),
dtype=np.int32)
self.proposal_target_creator = ProposalTargetCreator(
n_sample=self.n_sample, pos_ratio=self.pos_ratio)
def predict(self, imgs):
bboxes = []
labels = []
scores = []
for img in imgs:
n_bbox = np.random.randint(1, 10)
bboxes.append(generate_random_bbox(
n_bbox, img.shape[1:], 4, 12))
labels.append(np.random.randint(
0, 20, size=n_bbox).astype(np.int32))
scores.append(np.random.uniform(
0, 1, size=n_bbox).astype(np.float32))
return bboxes, labels, scores
def setUp(self):
feat_size = (self.img_size[0] // 16, self.img_size[1] // 16)
n_anchor = np.int32(self.n_anchor_base * np.prod(feat_size))
self.score = np.random.uniform(
low=0, high=1, size=(n_anchor,)).astype(np.float32)
self.bbox_d = np.random.uniform(
low=-1, high=1., size=(n_anchor, 4)).astype(np.float32)
self.anchor = generate_random_bbox(n_anchor, self.img_size, 16, 200)
self.proposal_creator = ProposalCreator(
n_train_post_nms=self.n_train_post_nms,
n_test_post_nms=self.n_test_post_nms,
min_size=0)
chainer.config.train = self.train
def setUp(self):
bboxes = [generate_random_bbox(5, (256, 324), 24, 120)
for _ in range(10)]
areas = [[np.array([(bb[2] - bb[0]) * bb[3] - bb[0]]) for bb in bbox]
for bbox in bboxes]
labels = 2 * np.ones((10, 5), dtype=np.int32)
crowdeds = np.zeros((10, 5))
self.dataset = TupleDataset(
np.random.uniform(size=(10, 3, 32, 48)),
bboxes, labels, areas, crowdeds)
self.link = _DetectionStubLink(bboxes, labels)
self.iterator = SerialIterator(
self.dataset, 5, repeat=False, shuffle=False)
self.evaluator = DetectionCOCOEvaluator(
self.iterator, self.link, label_names=('cls0', 'cls1', 'cls2'))
self.expected_ap = 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_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 setUp(self):
proposal_creator_params = {
'n_train_post_nms': self.n_train_post_nms,
'n_test_post_nms': self.n_test_post_nms
}
self.model = LightHeadRCNNTrainChain(
LightHeadRCNNResNet101(
self.n_fg_class,
pretrained_model=None,
proposal_creator_params=proposal_creator_params))
self.bboxes = generate_random_bbox(self.n_bbox, (600, 800), 16,
350)[np.newaxis]
self.labels = np.random.randint(0,
self.n_fg_class,
size=(1, self.n_bbox)).astype(np.int32)
self.imgs = _random_array((1, 3, 600, 800))
self.scales = np.array([1.])
def _decode(self, loc, conf):
value = to_cpu(self._value)
loc = to_cpu(loc)
conf = to_cpu(conf)
if not hasattr(self, '_count'):
self._count = 0
np.testing.assert_equal(loc, value[self._count, :, :4])
np.testing.assert_equal(conf, value[self._count, :, 4:])
self._count += 1
n_bbox = np.random.randint(self._n_anchor - 1)
bbox = generate_random_bbox(n_bbox, (self._insize, self._insize), 8,
48)
label = np.random.randint(self._n_fg_class - 1, size=n_bbox) \
.astype(np.int32)
score = np.random.uniform(size=n_bbox).astype(np.float32)
return bbox, label, score
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)
self.assertIsInstance(bbox, np.ndarray)
self.assertEqual(bbox.shape, (n, 4))
self.assertTrue(np.all(bbox[:, [0, 2]] < img_size[0]))
self.assertTrue(np.all(bbox[:, [0, 2]] >= 0))
self.assertTrue(np.all(bbox[:, [1, 3]] < img_size[1]))
self.assertTrue(np.all(bbox[:, [1, 3]] >= 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(self):
H = 80
W = 90
n_inst = 10
mask = np.zeros((n_inst, H, W), dtype=np.bool)
bbox = generate_random_bbox(n_inst, (H, W), 10, 30).astype(np.int32)
for i, bb in enumerate(bbox):
y_min, x_min, y_max, x_max = bb
m = np.random.randint(0, 2, size=(y_max - y_min, x_max - x_min))
m[5, 5] = 1 # At least one element is one
mask[i, y_min:y_max, x_min:x_max] = m
bbox = mask_to_bbox(mask)
size = H * 2
out_H = size
out_W = W * 2
out_mask = scale_mask(mask, bbox, size)
expected = resize(mask.astype(np.float32), (out_H, out_W),
interpolation=PIL.Image.NEAREST).astype(np.bool)
np.testing.assert_equal(out_mask, expected)
def setUp(self):
self.n_anchor_base = 6
self.feat_stride = 4
self.n_fg_class = 3
self.n_roi = 24
self.n_bbox = 3
self.link = FasterRCNNTrainChain(DummyFasterRCNN(
n_anchor_base=self.n_anchor_base,
feat_stride=self.feat_stride,
n_fg_class=self.n_fg_class,
n_roi=self.n_roi,
min_size=600,
max_size=800,
))
self.bboxes = chainer.Variable(
generate_random_bbox(self.n_bbox, (600, 800), 16, 350)[np.newaxis])
_labels = np.random.randint(
0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32)
self.labels = chainer.Variable(_labels)
self.imgs = chainer.Variable(_random_array((1, 3, 600, 800)))
self.scale = chainer.Variable(np.array(1.))
def setUp(self):
self.n_anchor_base = 6
self.feat_stride = 4
self.n_fg_class = 3
self.n_roi = 24
self.n_bbox = 3
self.link = FasterRCNNTrainChain(DummyFasterRCNN(
n_anchor_base=self.n_anchor_base,
feat_stride=self.feat_stride,
n_fg_class=self.n_fg_class,
n_roi=self.n_roi,
min_size=600,
max_size=800,
))
self.bboxes = chainer.Variable(
generate_random_bbox(self.n_bbox, (600, 800), 16, 350)[np.newaxis])
_labels = np.random.randint(
0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32)
self.labels = chainer.Variable(_labels)
self.imgs = chainer.Variable(_random_array((1, 3, 600, 800)))
self.scale = chainer.Variable(np.array(1.))
def _decode(self, loc, obj, conf):
locs = to_cpu(self._locs)
objs = to_cpu(self._objs)
confs = to_cpu(self._confs)
loc = to_cpu(loc)
obj = to_cpu(obj)
conf = to_cpu(conf)
if not hasattr(self, '_count'):
self._count = 0
np.testing.assert_equal(loc, locs[self._count])
np.testing.assert_equal(obj, objs[self._count])
np.testing.assert_equal(conf, confs[self._count])
self._count += 1
n_bbox = np.random.randint(self._n_anchor - 1)
bbox = generate_random_bbox(
n_bbox, (self._insize, self._insize), 8, 48)
label = np.random.randint(self._n_fg_class - 1, size=n_bbox) \
.astype(np.int32)
score = np.random.uniform(size=n_bbox).astype(np.float32)
return bbox, label, score
def test_random_crop_with_bbox_constraints(self):
img = np.random.randint(0, 256, size=(3, 480, 640)).astype(np.float32)
bbox = generate_random_bbox(10, img.shape[1:], 0.1, 0.9)
out, param = random_crop_with_bbox_constraints(
img, bbox,
min_scale=0.3, max_scale=1,
max_aspect_ratio=2,
return_param=True)
if param['constraint'] is None:
np.testing.assert_equal(out, img)
else:
np.testing.assert_equal(
out, img[:, param['y_slice'], param['x_slice']])
# to ignore rounding error, add 1
self.assertGreaterEqual(
out.shape[0] * (out.shape[1] + 1) * (out.shape[2] + 1),
img.size * 0.3 * 0.3)
self.assertLessEqual(out.size, img.size * 1 * 1)
self.assertLessEqual(
out.shape[1] / (out.shape[2] + 1),
img.shape[1] / img.shape[2] * 2)
self.assertLessEqual(
out.shape[2] / (out.shape[1] + 1),
img.shape[2] / img.shape[1] * 2)
bb = np.array((
param['y_slice'].start, param['x_slice'].start,
param['y_slice'].stop, param['x_slice'].stop))
iou = bbox_iou(bb[np.newaxis], bbox)
min_iou, max_iou = param['constraint']
if min_iou:
self.assertGreaterEqual(iou.min(), min_iou)
if max_iou:
self.assertLessEqual(iou.max(), max_iou)
def setUp(self):
self.src_bbox = generate_random_bbox(8, (64, 32), 4, 16)
self.dst_bbox = self.src_bbox + 1
def setUp(self):
self.bbox = generate_random_bbox(6000, (600, 800), 32, 512)
self.score = np.random.uniform(0, 100, size=(len(self.bbox), ))
self.limit = 100
self.threshold = 0.5
def setUp(self):
self.src_bbox = generate_random_bbox(8, (64, 32), 4, 16)
self.dst_bbox = self.src_bbox + 1
def setUp(self):
self.bbox = generate_random_bbox(6000, (600, 800), 32, 512)
self.score = np.random.uniform(0, 100, size=(len(self.bbox),))
self.limit = 100
self.threshold = 0.5