def predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = detect_one_image(img, pred_func)
final = draw_final_outputs(
img, results) # image contain boxes,labels and scores
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
def visualize(model, model_path, nr_visualize=100, output_dir='output'):
"""
Visualize some intermediate results (proposals, raw predictions) inside the pipeline.
"""
df = get_train_dataflow() # we don't visualize mask stuff
df.reset_state()
pred = OfflinePredictor(
PredictConfig(model=model,
session_init=get_model_loader(model_path),
input_names=['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_{}_proposals/boxes'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'generate_{}_proposals/probs'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'fastrcnn_all_probs',
'final_boxes',
'final_probs',
'final_labels',
]))
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
utils.fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df.get_data()),
nr_visualize):
img = dp[0]
if cfg.MODE_MASK:
gt_boxes, gt_labels, gt_masks = dp[-3:]
else:
gt_boxes, gt_labels = dp[-2:]
rpn_boxes, rpn_scores, all_probs, \
final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels)
# draw groundtruth boxes
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
# draw best proposals for each groundtruth, to show recall
proposal_viz, good_proposals_ind = draw_proposal_recall(
img, rpn_boxes, rpn_scores, gt_boxes)
# draw the scores for the above proposals
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind],
all_probs[good_proposals_ind])
results = [
DetectionResult(*args)
for args in zip(final_boxes, final_probs, final_labels,
[None] * len(final_labels))
]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches(
[gt_viz, proposal_viz, score_viz, final_viz], 2, 2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz)
pbar.update()
def predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = detect_one_image(img, pred_func)
print(len(results))
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
def do_predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = predict_image(img, pred_func)
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
cv2.imwrite("output.png", viz)
logger.info("Inference output written to output.png")
tpviz.interactive_imshow(viz)
def visualize(model_path, nr_visualize=50, output_dir='output'):
df = get_train_dataflow_coco() # we don't visualize mask stuff
df.reset_state()
pred = OfflinePredictor(
PredictConfig(model=Model(),
session_init=get_model_loader(model_path),
input_names=['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_rpn_proposals/boxes',
'generate_rpn_proposals/probs',
'fastrcnn_all_probs',
'final_boxes',
'final_probs',
'final_labels',
]))
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
utils.fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df.get_data()),
nr_visualize):
img, _, _, gt_boxes, gt_labels = dp
rpn_boxes, rpn_scores, all_probs, \
final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels)
# draw groundtruth boxes
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
# draw best proposals for each groundtruth, to show recall
proposal_viz, good_proposals_ind = draw_proposal_recall(
img, rpn_boxes, rpn_scores, gt_boxes)
# draw the scores for the above proposals
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind],
all_probs[good_proposals_ind])
if config.USE_SECOND_HEAD:
results = [
SecondDetectionResult(*args)
for args in zip(final_boxes, final_probs, final_labels,
[None] * len(final_labels))
]
else:
results = [
DetectionResult(*args)
for args in zip(final_boxes, final_probs, final_labels,
[None] * len(final_labels))
]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches(
[gt_viz, proposal_viz, score_viz, final_viz], 2, 2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz)
pbar.update()
def visualize(model, model_path, nr_visualize=100, output_dir='output'):
"""
Visualize some intermediate results (proposals, raw predictions) inside the pipeline.
"""
df = get_train_dataflow() # we don't visualize mask stuff
df.reset_state()
pred = OfflinePredictor(PredictConfig(
model=model,
session_init=get_model_loader(model_path),
input_names=['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_{}_proposals/boxes'.format('fpn' if cfg.MODE_FPN else 'rpn'),
'generate_{}_proposals/scores'.format('fpn' if cfg.MODE_FPN else 'rpn'),
'fastrcnn_all_scores',
'output/boxes',
'output/scores',
'output/labels',
]))
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
utils.fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df), nr_visualize):
img = dp[0]
if cfg.MODE_MASK:
gt_boxes, gt_labels, gt_masks = dp[-3:]
else:
gt_boxes, gt_labels = dp[-2:]
rpn_boxes, rpn_scores, all_scores, \
final_boxes, final_scores, final_labels = pred(img, gt_boxes, gt_labels)
# draw groundtruth boxes
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
# draw best proposals for each groundtruth, to show recall
proposal_viz, good_proposals_ind = draw_proposal_recall(img, rpn_boxes, rpn_scores, gt_boxes)
# draw the scores for the above proposals
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_scores[good_proposals_ind])
results = [DetectionResult(*args) for args in
zip(final_boxes, final_scores, final_labels,
[None] * len(final_labels))]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches([
gt_viz, proposal_viz,
score_viz, final_viz], 2, 2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz)
pbar.update()
def do_predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = predict_image(img, pred_func)
if cfg.MODE_MASK:
final = draw_final_outputs_blackwhite(img, results)
else:
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
cv2.imwrite("output.png", viz)
logger.info(
"Inference output for {} written to output.png".format(input_file))
tpviz.interactive_imshow(viz)
def sample(model_path):
pred = PredictConfig(session_init=get_model_loader(model_path),
model=Model(),
input_names=['label', 'z'],
output_names=['gen/gen'])
ds = MapData(RandomZData((100, 100)),
lambda dp: [np.arange(100) % 10, dp[0]])
pred = SimpleDatasetPredictor(pred, ds)
for o in pred.get_result():
o = o[0] * 255.0
viz = stack_patches(o, nr_row=10, nr_col=10)
viz = cv2.resize(viz, (800, 800))
interactive_imshow(viz)
def predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
t = time.time()
results = detect_one_image(img, pred_func)
t_final = time.time() - t
height, width, channels = img.shape
print("Time: ", t_final, " for ", height * width / 1e6,
" Mpixels , i.e. Width=", width, " Height=", height, " Channels=",
channels)
print("Throughput: ", height * width / 1e6 / t_final, " Mpixels/Sec")
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
def predict(model_path, input_file):
pred = OfflinePredictor(
PredictConfig(model=Model(),
session_init=get_model_loader(model_path),
input_names=['image'],
output_names=[
'fastrcnn_fg_probs',
'fastrcnn_fg_boxes',
]))
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = detect_one_image(img, pred)
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
def sample(model_path):
pred = PredictConfig(
session_init=get_model_loader(model_path),
model=Model(),
input_names=['label', 'z'],
output_names=['gen/gen'])
ds = MapData(RandomZData((100, 100)),
lambda dp: [np.arange(100) % 10, dp[0]])
pred = SimpleDatasetPredictor(pred, ds)
for o in pred.get_result():
o = o[0] * 255.0
viz = stack_patches(o, nr_row=10, nr_col=10)
viz = cv2.resize(viz, (800, 800))
interactive_imshow(viz)
def do_predict(pred_func, input_file):
'''
输入input_file,读取与图片,然后调用pred_func,得到了box,score,lables,
结果输出到output.jpg,并交互显示
boxes,labels,scores
:param pred_func:
:param input_file:
:return:
'''
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = predict_image(img, pred_func)
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
cv2.imwrite("output.png", viz)
logger.info("Inference output for {} written to output.png".format(input_file))
tpviz.interactive_imshow(viz)
def visualize(model_path, nr_visualize=50, output_dir='output'):
pred = OfflinePredictor(
PredictConfig(model=Model(),
session_init=get_model_loader(model_path),
input_names=['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_rpn_proposals/boxes',
'generate_rpn_proposals/probs',
'fastrcnn_all_probs',
'fastrcnn_fg_probs',
'fastrcnn_fg_boxes',
]))
df = get_train_dataflow()
df.reset_state()
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
utils.fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df.get_data()),
nr_visualize):
img, _, _, gt_boxes, gt_labels = dp
rpn_boxes, rpn_scores, all_probs, fg_probs, fg_boxes = pred(
img, gt_boxes, gt_labels)
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
proposal_viz, good_proposals_ind = draw_proposal_recall(
img, rpn_boxes, rpn_scores, gt_boxes)
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind],
all_probs[good_proposals_ind])
fg_boxes = clip_boxes(fg_boxes, img.shape[:2])
fg_viz = draw_predictions(img, fg_boxes, fg_probs)
results = nms_fastrcnn_results(fg_boxes, fg_probs)
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches(
[gt_viz, proposal_viz, score_viz, fg_viz, final_viz], 2, 3)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz)
pbar.update()
def sample(model_path):
pred = OfflinePredictor(
PredictConfig(session_init=get_model_loader(model_path),
model=Model(),
input_names=['z_code', 'z_noise'],
output_names=['gen/viz']))
# sample all one-hot encodings (10 times)
z_cat = np.tile(np.eye(10), [10, 1])
# sample continuos variables from -2 to +2 as mentioned in the paper
z_uni = np.linspace(-2.0, 2.0, num=100)
z_uni = z_uni[:, None]
IMG_SIZE = 400
while True:
# only categorical turned on
z_noise = np.random.uniform(-1, 1, (100, NOISE_DIM))
zc = np.concatenate((z_cat, z_uni * 0, z_uni * 0), axis=1)
o = pred(zc, z_noise)[0]
viz1 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz1 = cv2.resize(viz1, (IMG_SIZE, IMG_SIZE))
# show effect of first continous variable with fixed noise
zc = np.concatenate((z_cat, z_uni, z_uni * 0), axis=1)
o = pred(zc, z_noise * 0)[0]
viz2 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz2 = cv2.resize(viz2, (IMG_SIZE, IMG_SIZE))
# show effect of second continous variable with fixed noise
zc = np.concatenate((z_cat, z_uni * 0, z_uni), axis=1)
o = pred(zc, z_noise * 0)[0]
viz3 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz3 = cv2.resize(viz3, (IMG_SIZE, IMG_SIZE))
canvas = viz.stack_patches([viz1, viz2, viz3],
nr_row=1,
nr_col=3,
border=5,
bgcolor=(255, 0, 0))
viz.interactive_imshow(canvas)
def sample(model_path):
pred = OfflinePredictor(PredictConfig(
session_init=get_model_loader(model_path),
model=Model(),
input_names=['z_code', 'z_noise'],
output_names=['gen/viz']))
# sample all one-hot encodings (10 times)
z_cat = np.tile(np.eye(10), [10, 1])
# sample continuos variables from -2 to +2 as mentioned in the paper
z_uni = np.linspace(-2.0, 2.0, num=100)
z_uni = z_uni[:, None]
IMG_SIZE = 400
while True:
# only categorical turned on
z_noise = np.random.uniform(-1, 1, (100, NOISE_DIM))
zc = np.concatenate((z_cat, z_uni * 0, z_uni * 0), axis=1)
o = pred(zc, z_noise)[0]
viz1 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz1 = cv2.resize(viz1, (IMG_SIZE, IMG_SIZE))
# show effect of first continous variable with fixed noise
zc = np.concatenate((z_cat, z_uni, z_uni * 0), axis=1)
o = pred(zc, z_noise * 0)[0]
viz2 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz2 = cv2.resize(viz2, (IMG_SIZE, IMG_SIZE))
# show effect of second continous variable with fixed noise
zc = np.concatenate((z_cat, z_uni * 0, z_uni), axis=1)
o = pred(zc, z_noise * 0)[0]
viz3 = viz.stack_patches(o, nr_row=10, nr_col=10)
viz3 = cv2.resize(viz3, (IMG_SIZE, IMG_SIZE))
canvas = viz.stack_patches(
[viz1, viz2, viz3],
nr_row=1, nr_col=3, border=5, bgcolor=(255, 0, 0))
viz.interactive_imshow(canvas)
def predict_unlabeled(model,
model_path,
nr_visualize=100,
output_dir='output_patch_samples'):
"""Predict the pseudo label information of unlabeled data."""
assert cfg.EVAL.PSEUDO_INFERENCE, 'set cfg.EVAL.PSEUDO_INFERENCE=True'
df, dataset_size = get_eval_unlabeled_dataflow(cfg.DATA.TRAIN,
return_size=True)
df.reset_state()
predcfg = PredictConfig(
model=model,
session_init=SmartInit(model_path),
input_names=['image'], # ['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_{}_proposals/boxes'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'generate_{}_proposals/scores'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'fastrcnn_all_scores',
'output/boxes',
'output/scores', # score of the labels
'output/labels',
])
pred = OfflinePredictor(predcfg)
if os.path.isdir(output_dir):
if os.path.isfile(os.path.join(output_dir, 'pseudo_data.npy')):
os.remove(os.path.join(output_dir, 'pseudo_data.npy'))
if not os.path.isdir(os.path.join(output_dir, 'vis')):
os.makedirs(os.path.join(output_dir, 'vis'))
else:
shutil.rmtree(os.path.join(output_dir, 'vis'))
fs.mkdir_p(output_dir + '/vis')
else:
fs.mkdir_p(output_dir)
fs.mkdir_p(output_dir + '/vis')
logger.warning('-' * 100)
logger.warning('Write to {}'.format(output_dir))
logger.warning('-' * 100)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df), nr_visualize):
img, img_id = dp # dp['image'], dp['img_id']
rpn_boxes, rpn_scores, all_scores, \
final_boxes, final_scores, final_labels = pred(img)
outs = {
'proposals_boxes': rpn_boxes, # (?,4)
'proposals_scores': rpn_scores, # (?,)
'boxes': final_boxes,
'scores': final_scores,
'labels': final_labels
}
ratios = [10,
10] # [top 20% as background, bottom 20% as background]
bg_ind, fg_ind = custom.find_bg_and_fg_proposals(all_scores,
ratios=ratios)
bg_viz = draw_predictions(img, rpn_boxes[bg_ind],
all_scores[bg_ind])
fg_viz = draw_predictions(img, rpn_boxes[fg_ind],
all_scores[fg_ind])
results = [
DetectionResult(*args)
for args in zip(final_boxes, final_scores, final_labels,
[None] * len(final_labels))
]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches([bg_viz, fg_viz, final_viz], 2, 2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
assert cv2.imwrite('{}/vis/{:03d}.png'.format(output_dir, idx),
viz)
pbar.update()
logger.info('Write {} samples to {}'.format(nr_visualize, output_dir))
## Parallel inference the whole unlabled data
pseudo_preds = collections.defaultdict(list)
num_tower = max(cfg.TRAIN.NUM_GPUS, 1)
graph_funcs = MultiTowerOfflinePredictor(predcfg, list(
range(num_tower))).get_predictors()
dataflows = [
get_eval_unlabeled_dataflow(cfg.DATA.TRAIN,
shard=k,
num_shards=num_tower)
for k in range(num_tower)
]
all_results = multithread_predict_dataflow(dataflows, graph_funcs)
for id, result in tqdm.tqdm(enumerate(all_results)):
img_id = result['image_id']
outs = {
'proposals_boxes':
result['proposal_box'].astype(np.float16), # (?,4)
'proposals_scores':
result['proposal_score'].astype(np.float16), # (?,)
# 'frcnn_all_scores': result['frcnn_score'].astype(np.float16),
'boxes': result['bbox'].astype(np.float16), # (?,4)
'scores': result['score'].astype(np.float16), # (?,)
'labels': result['category_id'].astype(np.float16) # (?,)
}
pseudo_preds[img_id] = outs
logger.warn('Writing to {}'.format(
os.path.join(output_dir, 'pseudo_data.npy')))
try:
dd.io.save(os.path.join(output_dir, 'pseudo_data.npy'), pseudo_preds)
except RuntimeError:
logger.error('Save failed. Check reasons manually...')
def do_visualize(model, model_path, nr_visualize=100, output_dir='output'):
"""
Visualize some intermediate results (proposals, raw predictions) inside the pipeline.
"""
df = get_train_dataflow() # we don't visualize mask stuff
df.reset_state()
pred = OfflinePredictor(
PredictConfig(
model=model,
session_init=get_model_loader(model_path),
input_names=['images', 'orig_image_dims', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_{}_proposals_topk_per_image/boxes'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'generate_{}_proposals_topk_per_image/scores'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'fastrcnn_all_scores',
'output/boxes',
'output/scores',
'output/labels',
]))
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
utils.fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df), nr_visualize):
img, gt_boxes, gt_labels = dp['images'], dp['gt_boxes'], dp[
'gt_labels']
orig_shape = img.shape[:2]
rpn_boxes, rpn_scores, all_scores, \
final_boxes, final_scores, final_labels = pred(np.expand_dims(img, axis=0),
np.expand_dims(np.array(img.shape), axis=0),
np.expand_dims(gt_boxes, axis=0),
np.expand_dims(gt_labels, axis=0))
# draw groundtruth boxes
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
# draw best proposals for each groundtruth, to show recall
# custom op creates different shape for boxes, convert back to original
rpn_boxes = np.array([i[1:] for i in rpn_boxes])
proposal_viz, good_proposals_ind = draw_proposal_recall(
img, rpn_boxes, rpn_scores, gt_boxes)
# draw the scores for the above proposals
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind],
all_scores[good_proposals_ind])
results = [
DetectionResult(*args)
for args in zip(final_boxes, final_scores, final_labels,
[None] * len(final_labels))
]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches(
[gt_viz, proposal_viz, score_viz, final_viz], 2, 2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz)
pbar.update()
def preprocess(fname):
print("start preproc mapillary")
start = time.time()
label_fname = fname.replace(train_img_path,
train_label_path).replace(".jpg", ".png")
pil_label = Image.open(label_fname)
label = np.array(pil_label)
instances = np.unique(label)
instance_classes = [x // 256 for x in instances]
# filter by categories we use
instances_valid = [
cls in config.MAPILLARY_CAT_IDS_TO_USE for cls in instance_classes
]
instances = [
inst for inst, valid in zip(instances, instances_valid) if valid
]
instance_classes = [
cls for cls, valid in zip(instance_classes, instances_valid)
if valid
]
if len(instances) == 0:
print("no instances")
pil_label.close()
return None
if map_to_coco:
instance_classes = [
config.MAPILLARY_TO_COCO_MAP[cls] for cls in instance_classes
]
instance_classes = [
config.VOID_LABEL if cls == config.VOID_LABEL else
COCOMeta.category_id_to_class_id[cls]
for cls in instance_classes
]
else:
# remap to contiguous numbers starting with 1
instance_classes = [
config.MAPILLARY_CAT_IDS_TO_USE.index(cls) + 1
for cls in instance_classes
]
masks = np.array([label == inst for inst in instances], dtype=np.uint8)
#import cProfile
#start1 = time.time()
boxes1 = np.array(
[get_bbox_from_segmentation_mask(mask) for mask in masks],
dtype=np.float32)
#boxes1_time = time.time() - start1
#pr = cProfile.Profile()
#pr.enable()
#start1 = time.time()
#boxes2 = get_bboxes_from_segmentation_masks(masks)
#print("boxes1", boxes1_time, "boxes2", time.time() - start1)
#pr.disable()
#pr.print_stats(sort="cumulative")
#assert (boxes1 == boxes2).all(), (boxes1, boxes2)
boxes = boxes1
second_klass = np.array(instance_classes, dtype=np.int)
klass = np.ones_like(second_klass)
is_crowd = np.zeros_like(second_klass)
res = preproc_img(fname, boxes, klass, second_klass, is_crowd, aug)
if res is None:
print("mapillary: preproc_img returned None on", fname)
pil_label.close()
return None
ret, params = res
if add_mask:
do_flip, h, w = params[1]
assert do_flip in (True, False), do_flip
# augment label
label = np.array(pil_label.resize((w, h), Image.NEAREST))
if do_flip:
label = label[:, ::-1]
# create augmented masks
masks = np.array([label == inst for inst in instances],
dtype=np.uint8)
ret.append(masks)
end = time.time()
elapsed = end - start
print("mapillary example done, elapsed:", elapsed)
VISUALIZE = False
if VISUALIZE:
from viz import draw_annotation, draw_mask
config.CLASS_NAMES = [str(idx) for idx in range(81)]
im = ret[0]
boxes = ret[3]
draw_klass = ret[-2]
viz = draw_annotation(im, boxes, draw_klass)
for mask in masks:
viz = draw_mask(viz, mask)
tpviz.interactive_imshow(viz)
pil_label.close()
return ret
images=np.array([im for im,_ in images_and_shape])
orgin_shape=[s for _,s in images_and_shape]
result=self.predict_416(images,batchSize,score_thresh,iou_thresh)
for r,orgin in zip(result,orgin_shape):
w,h=orgin
if len(r['boxes'])==0 :continue
bb=r['boxes']*np.array([w,h,w,h])/416
bb[:, [0, 2]] = np.maximum(bb[:, [0, 2]], 0)
bb[:, [1, 3]] = np.maximum(bb[:, [1, 3]], 0)
bb[:, [0, 2]] = np.minimum(bb[:, [0, 2]], w)
bb[:, [1, 3]] = np.minimum(bb[:, [1, 3]], h)
r['boxes']=bb
return result
import tensorpack.utils.viz as viz
if __name__ == '__main__':
model_path='/home/zxk/AI/tensorflow-yolov3/checkpoint/yolov3.ckpt'
service=YoLoService(model_path)
imagelist=['/home/zxk/PycharmProjects/deepAI1/daily/8/DeepLearning/myproject/yolo3/data/demo_data/611.jpg']
result=service.predict_imagelist(imagelist)
# for r in result:
# print(r['boxes'].shape,r['labels'].shape,r['scores'].shape)
# print(r['boxes'])
img=cv2.imread('/home/zxk/AI/coco/val2017/000000579893.jpg')
bbox=service.predict(img)
img=viz.draw_boxes(img,bbox['boxes'])
viz.interactive_imshow(img)
def preprocess(fname):
# print("start preproc mapillary")
start = time.time()
label_fname = fname.replace(train_img_path,
train_label_path).replace(".jpg", ".png")
pil_label = Image.open(label_fname)
label = np.array(pil_label)
instances = np.unique(label)
instance_classes = [x // 256 for x in instances]
if len(instances) == 0:
print("no instances")
pil_label.close()
return None
masks = np.array([label == inst for inst in instances], dtype=np.uint8)
boxes1 = np.array(
[get_bbox_from_segmentation_mask(mask) for mask in masks],
dtype=np.float32)
boxes = boxes1
# second_klass = np.array(instance_classes, dtype=np.int)
second_klass = np.zeros_like(instance_classes, dtype=np.int)
klass = np.ones_like(second_klass)
is_crowd = np.zeros_like(second_klass)
res = preproc_img(fname, boxes, klass, second_klass, is_crowd, aug)
if res is None:
print("davis: preproc_img returned None on", fname)
pil_label.close()
return None
ret, params = res
if add_mask:
do_flip, h, w = params[1]
assert do_flip in (True, False), do_flip
# augment label
label = np.array(pil_label.resize((w, h), Image.NEAREST))
if do_flip:
label = label[:, ::-1]
# create augmented masks
masks = np.array([label == inst for inst in instances],
dtype=np.uint8)
ret.append(masks)
end = time.time()
elapsed = end - start
# print("davis example done, elapsed:", elapsed)
VISUALIZE = False
if VISUALIZE:
from viz import draw_annotation, draw_mask
config.CLASS_NAMES = [str(idx) for idx in range(81)]
im = ret[0]
boxes = ret[3]
draw_klass = ret[-2]
viz = draw_annotation(im, boxes, draw_klass)
for mask in masks:
viz = draw_mask(viz, mask)
tpviz.interactive_imshow(viz)
pil_label.close()
return ret
def predict(pred_func, input_file):
img = cv2.imread(input_file, cv2.IMREAD_COLOR)
results = detect_one_image(img, pred_func)
final = draw_final_outputs(img, results)
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
default='',
type=str,
help='Configurations of object detection model',
nargs='+'
)
args = parser.parse_args()
if args.config:
cfg.update_args(args.config)
obj_detector = TensorPackDetector('/root/datasets/figmarcnn/checkpoint')
img = cv2.imread('/root/datasets/img-folder/a.png', cv2.IMREAD_COLOR)
results = obj_detector.detect(img, rgb=False)
final = draw_final_outputs(img, results) # image contain boxes,labels and scores
viz = np.concatenate((img, final), axis=1)
tpviz.interactive_imshow(viz)
'''
--image
/root/datasets/myimage/8.jpeg
--cam
0
--obj_model
two-stage
--obj_ckpt
/root/datasets/figmarcnn/checkpoint
--obj_config
DATA.BASEDIR=/root/datasets/COCO/DIR
def collect_samples(model,
model_path,
nr_visualize=100,
output_dir='output_patch_samples'):
"""
Visualize some intermediate results (proposals, raw predictions) inside the
pipeline.
"""
df = get_train_dataflow()
df.reset_state()
pred = OfflinePredictor(
PredictConfig(model=model,
session_init=SmartInit(model_path),
input_names=['image', 'gt_boxes', 'gt_labels'],
output_names=[
'generate_{}_proposals/boxes'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'generate_{}_proposals/scores'.format(
'fpn' if cfg.MODE_FPN else 'rpn'),
'fastrcnn_all_scores',
'output/boxes',
'output/scores',
'output/labels',
]))
if os.path.isdir(output_dir):
shutil.rmtree(output_dir)
fs.mkdir_p(output_dir)
with tqdm.tqdm(total=nr_visualize) as pbar:
for idx, dp in itertools.islice(enumerate(df), nr_visualize):
img, gt_boxes, gt_labels = dp['image'], dp['gt_boxes'], dp[
'gt_labels']
rpn_boxes, rpn_scores, all_scores, \
final_boxes, final_scores, final_labels = pred(img, gt_boxes, gt_labels)
# draw groundtruth boxes
gt_viz = draw_annotation(img, gt_boxes, gt_labels)
ratios = [10,
10] #[top 20% as background, bottom 20% as background]
bg_ind, fg_ind = custom.find_bg_and_fg_proposals(all_scores,
ratios=ratios)
bg_viz = draw_predictions(img, rpn_boxes[bg_ind],
all_scores[bg_ind])
fg_viz = draw_predictions(img, rpn_boxes[fg_ind],
all_scores[fg_ind])
# draw best proposals for each groundtruth, to show recall
proposal_viz, good_proposals_ind = draw_proposal_recall(
img, rpn_boxes, rpn_scores, gt_boxes)
# draw the scores for the above proposals
score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind],
all_scores[good_proposals_ind])
results = [
DetectionResult(*args)
for args in zip(final_boxes, final_scores, final_labels,
[None] * len(final_labels))
]
final_viz = draw_final_outputs(img, results)
viz = tpviz.stack_patches([gt_viz, bg_viz, fg_viz, final_viz], 2,
2)
if os.environ.get('DISPLAY', None):
tpviz.interactive_imshow(viz)
cv2.imwrite('{}/{:03d}.png'.format(output_dir, idx), viz)
pbar.update()
else:
raise Exception("Unsupported dataset: {}".format(args.dataset))
print('Start to visualize dataset: {}'.format(args.dataset))
print("Type 'x' to stop.")
while True:
ind = random.randint(0, len(ds) - 1)
img, sample = ds[ind]
print("Visualizing image {}".format(sample["img"].split("/")[-1]))
if multi_bbox_per_image:
people = sample["people"]
else:
people = [sample]
for person in people:
x, y, w, h = person["bbox"]
display_str = [
"{}/{}".format(k, v) for k, v in person["attrs"].items()
]
draw_bounding_box_on_image(img,
y,
x, (y + h), (x + w),
display_str_list=display_str,
thickness=3,
use_normalized_coordinates=False)
# Convert pil image to opencv format for display control
image_bgr = pil_to_cv_image(img)
interactive_imshow(image_bgr)
