def test_chunker(self):
l = [0] * 10
gen_chunks = commons.chunker(l, 5)
chunks = list(gen_chunks)
self.assertEqual(len(chunks), 2)
self.assertEqual(len(chunks[0]), 5)
self.assertEqual(len(chunks[1]), 5)
gen_chunks = commons.chunker(l, 1000)
chunks = list(gen_chunks)
self.assertEqual(len(chunks), 1)
self.assertEqual(len(chunks[0]), 10)
def redetection_by_sampling(self, prev_box, img):
"""
default redetection method
"""
imgwh = Coordinate.get_imgwh(img)
translation_f = min(1.5, 0.6 * 1.15**self.failed_cnt)
candidates = prev_box.gen_noise_samples(imgwh, 'gaussian', ADNetConf.g()['redetection']['samples'],
gaussian_translation_f=translation_f)
scores = []
for c_batch in commons.chunker(candidates, ADNetRunner.MAX_BATCHSIZE):
samples = [commons.extract_region(img, box) for box in c_batch]
classes = self.persistent_sess.run(
self.adnet.layer_scores,
feed_dict={
self.adnet.input_tensor: samples,
self.adnet.action_history_tensor: [commons.onehot_flatten(self.action_histories_old)]*len(c_batch),
self.tensor_is_training: False
}
)
scores.extend([x[1] for x in classes])
top5_idx = [i[0] for i in sorted(enumerate(scores), reverse=True, key=lambda x: x[1])][:5]
mean_score = sum([scores[x] for x in top5_idx]) / 5.0
if mean_score >= self.latest_score:
mean_box = candidates[0]
for i in range(1, 5):
mean_box += candidates[i]
return mean_box / 5.0, mean_score
return None, 0.0
def _finetune_fc(self, img, pos_boxes, neg_boxes, pos_lb_action, learning_rate, iter, iter_score=1):
BATCHSIZE = ADNetConf.g()['minibatch_size']
def get_img(idx, posneg):
if isinstance(img, tuple):
return img[posneg][idx]
return img
pos_samples = [commons.extract_region(get_img(i, 0), box) for i, box in enumerate(pos_boxes)]
neg_samples = [commons.extract_region(get_img(i, 1), box) for i, box in enumerate(neg_boxes)]
# pos_feats, neg_feats = self._get_features(pos_samples), self._get_features(neg_samples)
# commons.imshow_grid('pos', pos_samples[-50:], 10, 5)
# commons.imshow_grid('neg', neg_samples[-50:], 10, 5)
cv2.waitKey(1)
for i in range(iter):
batch_idxs = commons.random_idxs(len(pos_boxes), BATCHSIZE)
batch_feats = [x.feat for x in commons.choices_by_idx(pos_boxes, batch_idxs)]
batch_lb_action = commons.choices_by_idx(pos_lb_action, batch_idxs)
self.persistent_sess.run(
self.adnet.weighted_grads_op1,
feed_dict={
self.adnet.layer_feat: batch_feats,
self.adnet.label_tensor: batch_lb_action,
self.adnet.action_history_tensor: np.zeros(shape=(BATCHSIZE, 1, 1, 110)),
self.learning_rate_placeholder: learning_rate,
self.tensor_is_training: True
}
)
if i % iter_score == 0:
# training score auxiliary(fc2)
# -- hard score example mining
scores = []
for batch_neg in commons.chunker([x.feat for x in neg_boxes], ADNetRunner.MAX_BATCHSIZE):
scores_batch = self.persistent_sess.run(
self.adnet.layer_scores,
feed_dict={
self.adnet.layer_feat: batch_neg,
self.adnet.action_history_tensor: np.zeros(shape=(len(batch_neg), 1, 1, 110)),
self.learning_rate_placeholder: learning_rate,
self.tensor_is_training: False
}
)
scores.extend(scores_batch)
desc_order_idx = [i[0] for i in sorted(enumerate(scores), reverse=True, key=lambda x:x[1][1])]
# -- train
batch_feats_neg = [x.feat for x in commons.choices_by_idx(neg_boxes, desc_order_idx[:BATCHSIZE])]
self.persistent_sess.run(
self.adnet.weighted_grads_op2,
feed_dict={
self.adnet.layer_feat: batch_feats + batch_feats_neg,
self.adnet.class_tensor: [1]*len(batch_feats) + [0]*len(batch_feats_neg),
self.adnet.action_history_tensor: np.zeros(shape=(len(batch_feats)+len(batch_feats_neg), 1, 1, 110)),
self.learning_rate_placeholder: learning_rate,
self.tensor_is_training: True
}
)
def _get_features(self, samples):
feats = []
for batch in commons.chunker(samples, ADNetRunner.MAX_BATCHSIZE):
feats_batch = self.persistent_sess.run(
self.adnet.layer_feat,
feed_dict={self.adnet.input_tensor: batch})
feats.extend(feats_batch)
return feats
def inference(self,
tf_sess,
image,
cutoff_instance_max=0.0,
cutoff_instance_avg=0.0):
# TODO : Mirror Padding?
cascades, windows = Network.sliding_window(image, self.img_size, 0.5)
# by batch
outputs = []
padding = self.pad_size
mirror_padded = mirror_pad(image, padding)
for ws in chunker(windows, 64):
b = []
for w in ws:
b.append(mirror_padded[w.y:w.y + w.h + padding * 2,
w.x:w.x + w.w + padding * 2])
output = tf_sess.run(self.get_output(),
feed_dict={
self.input_batch: b,
self.is_training: False
})
outputs.append(output)
outputs = np.concatenate(outputs, axis=0)
# merge multiple results
merged_output = np.zeros((image.shape[0], image.shape[1], 1),
dtype=np.float32)
for window, output in zip(windows, outputs):
merged_output[window.indices()] = np.maximum(
output, merged_output[window.indices()])
merged_output = merged_output.reshape((image.shape[0], image.shape[1]))
# sementation to instance-aware segmentations.
instances, scores = Network.parse_merged_output(
merged_output,
cutoff=0.5,
cutoff_instance_max=cutoff_instance_max,
cutoff_instance_avg=cutoff_instance_avg)
# instances = Network.watershed_merged_output(instances)
return {'instances': instances, 'scores': scores}
def _get_features(self, samples):
feats = []
for batch in commons.chunker(samples, ADNetRunner.MAX_BATCHSIZE):
feats_batch = self.persistent_sess.run(self.adnet.layer_feat, feed_dict={
self.adnet.input_tensor: batch
})
feats.extend(feats_batch)
return feats
# train_fc_finetune_hem
self._finetune_fc(
img, pos_boxes, neg_boxes, pos_lb_action,
ADNetConf.get()['initial_finetune']['learning_rate'],
ADNetConf.get()['initial_finetune']['iter']
)
self.histories.append((pos_boxes, neg_boxes, pos_lb_action, np.copy(img), self.iteration))
_logger.info('ADNetRunner.initial_finetune t=%.3f' % t)
self.stopwatch.stop('initial_finetune')