def saveEvalResults(generator, cfg, obj_mapping, hoi_mapping, evalData=None): my_output_path = cfg.results_path + 'hoi' + cfg.my_results_dir + '/res/' + generator.data_type + generator.approach + '/' path = cfg.part_results_path + cfg.dataset + "/hoi" + cfg.my_results_dir mode = generator.data_type if not os.path.exists(path): path = path[:-1] path += '/' nb_empty = 0 if evalData is None: evalData = [] for batchidx, (imageID, imageMeta) in enumerate(generator.imagesMeta.items()): if (batchidx+1) % (max(1,generator.nb_batches // 100)) == 0 or batchidx==1 or (batchidx+1) == generator.nb_batches: utils.update_progress_new(batchidx+1, generator.nb_batches, imageID) if os.path.exists(my_output_path + imageID + '.pkl'): data = utils.load_obj(my_output_path + imageID) if data is not None and len(data) > 0: evalData.extend(data) else: nb_empty += 1 evalData = cp.copy(evalData) mAP, AP, _ = metrics.computeHOImAP(evalData, generator.imagesMeta, obj_mapping, hoi_mapping, cfg) saveMeta = {'mAP': mAP, 'zAP': AP.tolist(), 'nb_empties': nb_empty} utils.save_dict(saveMeta, path+mode+'_mAP') print('mAP', mode, mAP) print('empties', nb_empty)
def computeRPNARHelper(predMeta, GTMeta): import filters_helper as helper nb_gt_samples = len(GTMeta) Ps = [100, 300] IoU = np.zeros((2, nb_gt_samples)) for idx in range(nb_gt_samples): if idx % 100 == 0: utils.update_progress_new(idx, nb_gt_samples, '') gt = GTMeta[idx] bbox = gt['bbox'] imageID = gt['image_id'] pred_bboxes = np.array(predMeta[imageID]) overlaps = helper._computeIoUs(bbox, pred_bboxes) ol_idxs = np.argsort(overlaps)[::-1] max_iou = np.max(overlaps) done_Ps = [False for _ in range(len(Ps))] for ol_idx in ol_idxs: overlap = overlaps[ol_idx] pred_bbox = pred_bboxes[ol_idx, :] top = pred_bbox[4] for P_idx, P in enumerate(Ps): if done_Ps[P_idx] or top > P: continue if top <= P: done_Ps[P_idx] = True if overlap >= 0.5: IoU[P_idx, idx] = max_iou # true positive if all(x for x in done_Ps): break R = [np.sum(x >= 0.5) / nb_gt_samples for x in IoU] # ious = [x/100 for x in range(50,100,5)] # recalls = np.zeros((len(ious))) # for idx, iou in enumerate(ious): # r = np.sum(IoU>=iou) / nb_gt_samples # recalls[idx] = r # # AR = np.mean(recalls) overlaps = [[ol - 0.5 for ol in x if ol > 0] for x in IoU] AR = [2 * np.sum(x) / nb_gt_samples for x in overlaps] return AR, R, IoU
def loadEvalData(generator, my_output_path): evalData = [] for batchidx, (imageID, imageMeta) in enumerate(generator.imagesMeta.items()): if (batchidx + 1) % (max( 1, generator.nb_batches // 100)) == 0 or batchidx == 1 or ( batchidx + 1) == generator.nb_batches: utils.update_progress_new(batchidx + 1, generator.nb_batches, imageID) data = utils.load_obj(my_output_path + imageID) if data is not None and len(data) > 0: evalData.extend(data) return evalData
def saveEvalData(generator, Stages, cfg, obj_mapping): cfg.my_output_path = cfg.results_path + 'det' + cfg.my_results_dir + '/res/' + generator.data_type + '/' if not os.path.exists(cfg.my_output_path): os.makedirs(cfg.my_output_path) save_path = cfg.my_output_path print(' save_path:', save_path) evalData = [] imagesIDs = list(generator.imagesMeta.keys()) r.shuffle(imagesIDs) for batchidx, imageID in enumerate(imagesIDs): if (batchidx + 1) % (generator.nb_batches // 100) == 0 or batchidx == 1 or ( batchidx + 1) == generator.nb_batches: utils.update_progress_new(batchidx + 1, generator.nb_batches, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue imageMeta = generator.imagesMeta[imageID] imageMeta['id'] = imageID imageInputs = generator._getImageInputs(imageID) X, imageDims = filters_rpn.prepareInputs(imageMeta, generator.images_path, cfg) Y_tmp = filters_detection.loadData(imageInputs, cfg) proposals, target_labels, target_deltas = Y_tmp #STAGE 1 # proposals = Stages.stageone([img], y, imageMeta, imageDims) #STAGE 2 bboxes = Stages.stagetwo([X, proposals], imageMeta, imageDims) if bboxes is None: utils.save_obj(None, save_path + str(imageID)) continue #CONVERT evalData = filters_detection.convertResults(bboxes[0], imageMeta, obj_mapping, imageDims['scale'], cfg.rpn_stride) utils.save_obj(evalData, save_path + str(imageID)) return evalData
def saveInputData(generator, Stages, cfg, do_train_eval=False): rdir = 'evalnew' if do_train_eval else 'new' mode = 'test' if do_train_eval else generator.data_type cfg.my_output_path = cfg.results_path + 'det' + cfg.my_results_dir + '/output/' + generator.data_type + rdir + '/' if not os.path.exists(cfg.my_output_path): os.makedirs(cfg.my_output_path) if not os.path.exists(cfg.my_output_path): raise Exception('Output directory does not exist! %s' % cfg.my_output_path) save_path = cfg.my_output_path print(' save_path:', save_path) print(' mode:', mode) genIterator = generator.begin() inputMeta = None bboxes = None for batchidx in range(generator.nb_batches): X, y, imageMeta, imageDims, times = next(genIterator) imageID = imageMeta['imageName'].split('.')[0] # # imageID = 'HICO_train2015_00019135' # imageMeta = generator.imagesMeta[imageID] # X, y, imageDims = Stages.stagezero(imageMeta, generator.data_type) if (batchidx+1) % (max(1,generator.nb_batches // 100)) == 0 or batchidx==0 or (batchidx+1) == generator.nb_batches: utils.update_progress_new(batchidx, generator.nb_batches, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue #STAGE 1 proposals = Stages.stageone([X], y, imageMeta, imageDims) #STAGE 2 bboxes = Stages.stagetwo([proposals], imageMeta, imageDims) #STAGE 3 all_hbboxes, all_obboxes, all_target_labels, val_map = Stages.stagethree_targets(bboxes, imageMeta, imageDims) #CONVERT inputMeta = filters_hoi.convertData([all_hbboxes, all_obboxes, all_target_labels, val_map], cfg, mode=mode) utils.save_obj(inputMeta, save_path + imageID) return inputMeta, imageID, bboxes
def computeRPNARHelperOld(batch, GTMeta, nb_gt_samples): import filters_helper as helper props = np.array([x['score'] for x in batch]) sorted_idxs = props.argsort()[::-1] nb_rois = len(sorted_idxs) IoU = np.zeros((nb_rois)) for i, idx in enumerate(sorted_idxs): if i % 1000 == 0: utils.update_progress_new(i, nb_rois, '') roi = batch[idx] bbox = roi['bbox'] imageID = roi['image_id'] GTs = GTMeta[imageID] gt_bboxes = GTs['gt_bboxes'] overlap = helper._computeIoUs(bbox, gt_bboxes) max_iou = np.max(overlap) best_idx = np.argmax(overlap) if max_iou >= 0.5: if gt_bboxes[best_idx, 4] == 0: IoU[idx] = max_iou # true positive GTMeta[imageID]['gt_bboxes'][best_idx, 4] = 1 R5 = np.sum(IoU >= 0.5) / nb_gt_samples ious = [x / 100 for x in range(50, 100, 5)] recalls = np.zeros((len(ious))) for idx, iou in enumerate(ious): r = np.sum(IoU >= iou) / nb_gt_samples recalls[idx] = r AR = np.mean(recalls) overlaps = [x - 0.5 for x in IoU if x > 0] AR = 2 * np.sum(overlaps) / nb_gt_samples return AR, R5, IoU
def saveEvalData(generator, Stages, cfg): genIterator = generator.begin() evalData = [] for i in range(generator.nb_batches): [img, proposals], y, imageMeta, imageDims, times = next(genIterator) imageID = imageMeta['imageID'] utils.update_progress_new(i + 1, generator.nb_batches, imageID) #STAGE 1 # proposals = Stages.stageone(X, y, imageMeta, imageDims) proposals = proposals[0, :, :] #CONVERT evalData += filters_rpn.convertResults(proposals, imageMeta, imageDims['scale'], cfg.rpn_stride) return evalData
def saveInputData(generator, Stages, cfg): cfg.my_output_path = cfg.results_path + 'rpn' + cfg.my_results_dir + '/output/' if not os.path.exists(cfg.my_output_path): raise Exception('Output directory does not exist! %s' % cfg.my_output_path) if not os.path.exists(cfg.my_output_path + generator.data_type + '/'): os.makedirs(cfg.my_output_path + generator.data_type + '/') save_path = cfg.my_output_path + generator.data_type + '/' print(' save_path:', save_path) genIterator = generator.begin() detMeta = {} for batchidx in range(generator.nb_batches): img, y, imageMeta, imageDims, times = next(genIterator) imageID = str(imageMeta['imageID']) if (batchidx + 1) % (generator.nb_batches // 100) == 0 or batchidx == 1 or ( batchidx + 1) == generator.nb_batches: utils.update_progress_new(batchidx + 1, generator.nb_batches, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue #STAGE 1 proposals = Stages.stageone([img], y, imageMeta, imageDims) #STAGE 2 proposals, target_labels, target_deltas = Stages.stagetwo_targets( proposals, imageMeta, imageDims) #CONVERT if proposals is None: utils.save_obj(None, save_path + imageID) continue detMeta = filters_detection.convertData( [proposals, target_labels, target_deltas], cfg) utils.save_obj(detMeta, save_path + imageID)
def saveEvalData(generator, Stages, cfg, hoi_mapping): cfg.my_output_path = cfg.results_path + 'hoi' + cfg.my_results_dir + '/res/' + generator.data_type + generator.approach + '/' if not os.path.exists(cfg.my_output_path): os.makedirs(cfg.my_output_path) save_path = cfg.my_output_path print(' save_path:', save_path) evalData = [] imageMeta = None imagesIDs = list(generator.imagesMeta.keys()) r.shuffle(imagesIDs) for batchidx, imageID in enumerate(imagesIDs): if (batchidx+1) % (max(100,generator.nb_batches // 100)) == 0 or batchidx==1 or (batchidx+1) == generator.nb_batches: utils.update_progress_new(batchidx+1, generator.nb_batches, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue imageMeta = generator.imagesMeta[imageID] imageMeta['id'] = imageID # [X, all_hbboxes, all_obboxes, all_val_map], all_target_labels, imageMeta, imageDims, _ = next(genIterator) imageInputs = generator._getImageInputs(imageID) X, imageDims = filters_rpn.prepareInputs(imageMeta, generator.images_path, cfg) Y_tmp = filters_hoi.loadData(imageInputs, imageDims, cfg) if Y_tmp is None: utils.save_obj(None, save_path + imageID) continue all_hbboxes, all_obboxes, all_target_labels, all_val_map = Y_tmp #STAGE 3 pred_hbboxes, pred_obboxes, pred_props = Stages.stagethree([X,all_hbboxes,all_obboxes], imageMeta, imageDims, obj_mapping=None) if pred_hbboxes is None: utils.save_obj(None, save_path + imageID) continue #CONVERT evalData = filters_hoi.convertResults(pred_hbboxes, pred_obboxes, pred_props, imageMeta, imageDims['scale'], cfg, hoi_mapping) utils.save_obj(evalData, save_path + imageID) return evalData, imageMeta
def saveInputData(imagesMeta, data_type, cfg): load_path = cfg.data_path + 'images/' + data_type + '/' save_path = cfg.my_output_path + data_type + 'newest/' if not os.path.exists(save_path): os.makedirs(save_path) print('save_path', save_path) nb_images = len(imagesMeta) for batchidx, (imageID, imageMeta) in enumerate(imagesMeta.items()): imageID = imageMeta['imageName'].split('.')[0] utils.update_progress_new(batchidx + 1, nb_images, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue img, imageDims = filters_rpn.prepareInputs(imageMeta, load_path, cfg) [Y1, Y2, M] = filters_rpn.createTargets(imageMeta, imageDims, cfg) rpnMeta = filters_rpn.convertData([Y1, Y2, M], cfg) utils.save_obj(rpnMeta, save_path + imageID)
def saveEvalData(generator, Stages, cfg, hoi_mapping): cfg.my_output_path = cfg.results_path + 'hoi' + cfg.my_results_dir + '/res/' + generator.data_type + 'res/' if not os.path.exists(cfg.my_output_path): os.makedirs(cfg.my_output_path) save_path = cfg.my_output_path print(' save_path:', save_path) evalData = [] imageMeta = None imagesIDs = list(generator.imagesMeta.keys()) r.shuffle(imagesIDs) for batchidx, imageID in enumerate(imagesIDs): if (batchidx+1) % (max(100,generator.nb_batches // 100)) == 0 or batchidx==1 or (batchidx+1) == generator.nb_batches: utils.update_progress_new(batchidx+1, generator.nb_batches, imageID) path = save_path + imageID + '.pkl' if os.path.exists(path): continue imageMeta = generator.imagesMeta[imageID] imageMeta['id'] = imageID X, y, imageDims = Stages.stagezero(imageMeta, generator.data_type) # gt_label = imageMeta['label'] # intval_beg = gt_label // 2 * 2 proposals = Stages.stageone([X], y, imageMeta, imageDims) bboxes = Stages.stagetwo([proposals], imageMeta, imageDims) pred_hbboxes, pred_obboxes, pred_props = Stages.stagethree([bboxes], imageMeta, imageDims) #CONVERT evalData = filters_hoi.convertResults(pred_hbboxes, pred_obboxes, pred_props, imageMeta, imageDims['scale'], cfg, hoi_mapping) utils.save_obj(evalData, save_path + imageID) # break return evalData, imageMeta
print(cfg.my_input_path+'testnew/') sys.stdout.flush() #if True: nb_total = np.zeros(cfg.nb_hoi_classes) nb_tp = np.zeros(cfg.nb_hoi_classes) nb_empty = 0 nb_total_preds = 0 for j, (imageID, imageMeta) in enumerate(generator.imagesMeta.items()): # imageID = 'HICO_train2015_00028567' # imageMeta = generator.imagesMeta[imageID] if (j+1) % 100 == 0: utils.update_progress_new((j+1), generator.nb_images, imageID) img = cv.imread(generator.images_path + imageMeta['imageName']) X, imageDims = filters_rpn.prepareInputs(imageMeta, generator.images_path, cfg) objs = imageMeta['objects'] gt_rels = imageMeta['rels'] gtbboxes = helper._transformGTBBox(objs, obj_mapping, None, scale=imageDims['scale'], rpn_stride=cfg.rpn_stride, dosplit=False) checks = np.zeros(len(gt_rels)) if np.max(gtbboxes[:,2]) > 2+imageDims['output_shape'][1] or np.max(gtbboxes[:,3]) > 2+imageDims['output_shape'][0]: print('bad bbs', imageID, np.max(gtbboxes[:,2]), np.max(gtbboxes[:,3]), imageDims['output_shape']) imageInputs = utils.load_obj(cfg.my_input_path + 'testnew/' + imageID) if imageInputs is None: idxs = []
generator = genVal genIterator = generator.begin() nb_iterations = 1 all_times = np.zeros((nb_iterations, 5)) for i in range(nb_iterations): X, y, imageMeta, imageDims, times = next(genIterator) # imageID = 'Play_Saxophone_007' # imageMeta = generator.imagesMeta[imageID] # X, y, imageDims = Stages.stagezero(imageMeta, generator.data_type) imageID = imageMeta['imageName'].split('.')[0] if (i + 1) % 100 == 0: utils.update_progress_new((i + 1), nb_iterations, imageID) print('imageID', imageID) print('Stage one...') proposals, times = Stages.stageone([X], y, imageMeta, imageDims) all_times[i, 0:2] = times print('Stage two...') bboxes, times = Stages.stagetwo([proposals], imageMeta, imageDims) all_times[i, 2:4] = times print('Stage three...') pred_hbboxes, pred_obboxes, pred_props, times = Stages.stagethree( [bboxes], imageMeta, imageDims, obj_mapping) all_times[i, 4:5] = times # continue gt_obj_label = obj_mapping[hoi_mapping[imageMeta['label']]['obj']]
#trainer.compileModel(cfg) def unnormCoords(box, shape): xmin = box[1] * shape[1]; xmax = box[3] * shape[1] ymin = box[0] * shape[0]; ymax = box[2] * shape[0] return [xmin, ymin, xmax-xmin, ymax-ymin] idx = 0 j = 0 for i in range(genTest.nb_batches): X, y = next(trainIterator) break j += y.shape[1] # utils.update_progress(i / genTest.nb_samples) utils.update_progress_new(j, genTest.nb_samples, [y.shape[1],i,0,0], '') # continue # print('t',X[0].shape, X[1].shape, X[2].shape, y.shape) print(X[1].shape) image = X[0][idx] prsBB = X[1][idx][0] # objBB = X[2][idx][0] y = y[idx] image -= np.min(image) image /= 255 image = image[:,:,(2,1,0)] # image = np.fliplr(image) prsBB = unnormCoords(prsBB[1:], image.shape) # prsBB[0] = image.shape[1] - prsBB[0] - prsBB[2] # objBB = unnormCoords(objBB[1:], image.shape)
##STAGE 3 #Stages = stages.AllStages(cfg, None, obj_mapping, hoi_mapping, mode='test') #hbboxes, obboxes, target_labels, val_map = Stages.stagethree_targets(bboxes, imageMeta, imageDims) #patterns = filters_hoi.createInteractionPatterns(hbboxes, obboxes, cfg) #CONVERT #inputMeta = filters_hoi.convertData([hbboxes, obboxes, target_labels, val_map], cfg, mode=genTest.data_type) # #utils.save_obj(inputMeta, cfg.part_data_path + imageID) iterator = genTrain genItr = iterator.begin() for batchidx in range(1): [img, all_hbboxes, all_obboxes, patterns], target_labels, imageMeta, imageDims, _ = next(genItr) imageID = imageMeta['imageName'] utils.update_progress_new(batchidx + 1, iterator.nb_batches, imageID) # [img, hbboxes, obboxes, patterns], target_labels, imageMeta, imageDims, _ = next(genItr) X, _ = filters_rpn.prepareInputs(imageMeta, iterator.images_path, cfg) imageID = imageMeta['imageName'] # continue # draw.drawPositiveCropHoI(None, None, hcrops, ocrops, patterns, target_labels, imageMeta, imageDims, cfg, obj_mapping) # import draw import draw img = np.copy(X[0]) img += cfg.PIXEL_MEANS img = img.astype(np.uint8)
if True: # Load data print('Loading data...') data = extract_data.object_data(False) cfg = data.cfg dataset = 'val' if dataset == 'val': print('Validation data') imagesMeta = data.valGTMeta elif dataset == 'test': print('Test data') imagesMeta = data.testGTMeta else: print('Train data') imagesMeta = data.trainGTMeta nb_images = len(imagesMeta) from_anchor_path = cfg.part_data_path + cfg.dataset + '/anchors/' + dataset + '/' to_anchor_path = cfg.data_path + 'anchors/' + dataset + '/' if not os.path.exists(to_anchor_path): os.makedirs(to_anchor_path) for idx, (imageID, imageMeta) in enumerate(imagesMeta.items()): imageName = imageMeta['imageName'].split('.')[0] + '.pkl' copyfile(from_anchor_path + imageName, to_anchor_path + imageName) utils.update_progress_new(idx + 1, nb_images, imageMeta['imageName'])
bboxes2 = np.copy(bboxes1) bboxes2 = filters_detection.prepareInputs(bboxes2, imageDims, imageMeta) import draw import filters_detection img = np.copy(X[0]) img += cfg.PIXEL_MEANS img = img.astype(np.uint8) bboxes2 = filters_detection.unprepareInputs(bboxes2, imageDims) draw.drawOverlapAnchors(img, bboxes2[0], imageMeta, imageDims, cfg) draw.drawGTBoxes(img, imageMeta, imageDims) if False: redux = {} imageID = '487566' redux[imageID] = genTrain.imagesInputs[imageID] i = 0 goal = 5000 for imageID, inputMeta in genTrain.imagesInputs.items(): redux[imageID] = inputMeta utils.update_progress_new(i + 1, goal, imageID) if i == goal: break i += 1 #utils.save_obj(redux, cfg.my_output_path + 'proposals_redux')
# imageID='339823' # imageName = '000000339823' roisMeta = utils.load_obj(rois_path + imageName) target_deltas = np.copy(roisMeta['target_deltas']).tolist() roisMeta['rois'] = [[int(x * 1000) for x in box] for box in roisMeta['rois']] new_target_deltas = [] for row in roisMeta['target_deltas']: coord = [] for x in row: coord.append(int(x * 1000)) new_target_deltas.append(coord) roisMeta['target_deltas'] = new_target_deltas inputsMeta[imageID] = roisMeta if idx == 0: print('first') print('old:') print(utils.load_obj(rois_path + imageName)) print('new') print(roisMeta) utils.save_obj(inputsMeta[imageID], save_path + dataset + 'new/' + imageID) utils.update_progress_new(idx + 1, nb_images, imageID) #utils.save_obj(inputsMeta, save_path + 'proposals_'+dataset)
def saveEvalResults(generator, cfg, obj_mapping, hoi_mapping, evalData=None): evalDataInput = evalData my_output_path = cfg.results_path + 'hoi' + cfg.my_results_dir + '/res/' + generator.data_type + 'res/' path = cfg.part_results_path + cfg.dataset + "/hoi" + cfg.my_results_dir mode = generator.data_type if not os.path.exists(path): path = path[:-1] path += '/' nb_empty = 0 nb_gt_samples = np.zeros(cfg.nb_hoi_classes) if evalData is None or True: evalData = [] for batchidx, (imageID, imageMeta) in enumerate(generator.imagesMeta.items()): if (batchidx+1) % (max(1,generator.nb_batches // 100)) == 0 or batchidx==1 or (batchidx+1) == generator.nb_batches: utils.update_progress_new(batchidx+1, generator.nb_batches, imageID) gt_label = imageMeta['label'] data = utils.load_obj(my_output_path + imageID) best_score = -1 best_idx = None for idx, det in enumerate(data): if det['score'] > best_score: best_score = det['score'] best_idx = idx best_data = [data[best_idx]] best_data[0]['gt'] = gt_label nb_gt_samples[gt_label] += 1 if data is not None and len(data) > 0: evalData.extend(best_data) evalData = evalDataInput evalData = cp.copy(evalData) # return evalData, None cfm = np.zeros((cfg.nb_hoi_classes, cfg.nb_hoi_classes)) APs = np.zeros(cfg.nb_hoi_classes) for label in range(cfg.nb_hoi_classes): subset = [x for x in evalData if x['category_id']==label] if len(subset)==0: continue props = [x['score'] for x in subset] nb_preds = len(props) idxs = np.argsort(props)[::-1] tps = np.zeros(nb_preds) fps = np.zeros(nb_preds) nb_class_samples = nb_gt_samples[label] for i in range(nb_preds): idx = idxs[i] pred = subset[idx] cfm[pred['gt'], pred['category_id']] += 1 if pred['category_id'] == pred['gt']: tps[i] = 1 else: fps[i] = 1 if np.sum(tps)==0: continue tp = np.cumsum(tps) fp = np.cumsum(fps) print(label, tp[-1], nb_class_samples) # break recall = tp / nb_class_samples precision = tp / (fp+tp) Ps = np.zeros((11)) for rec in range(0,10): idxs = np.where(recall>= rec/10.0)[0] if len(idxs) == 0: p = 0.0 else: p = np.max(precision[idxs]) Ps[rec] = p AP = np.mean(Ps) APs[label] = AP mAP = np.mean(APs) return evalData, mAP, cfm saveMeta = {'mAP': mAP, 'zAP': AP.tolist(), 'nb_empties': nb_empty} utils.save_dict(saveMeta, path+mode+'_mAP') print('mAP', mode, mAP) print('empties', nb_empty)
# meta data data = extract_data.object_data(False) # config cfg = data.cfg obj_mapping = data.class_mapping # data genTrain = DataGenerator(imagesMeta = data.trainGTMeta, cfg=cfg, data_type='train', do_meta=True) #genVal = DataGenerator(imagesMeta = data.valGTMeta, cfg=cfg, data_type='val', do_meta=True) genItr = genTrain.begin() for batchidx in range(genTrain.nb_batches): [X,rois], y, imageMeta, imageDims, _ = next(genItr) # if batchidx+1 % 100 == 0: utils.update_progress_new(batchidx+1, genTrain.nb_batches, '') # import draw # import filters_detection # # img = np.copy(X[0]) # img += cfg.PIXEL_MEANS # img = img.astype(np.uint8) # rois = filters_detection.unprepareInputs(rois, imageDims) # # draw.drawOverlapAnchors(img, rois[0], imageMeta, imageDims, cfg) # # break
for i, (imageID, predMeta) in enumerate(predsMeta.items()): imageMeta = imagesMeta[str(imageID)] gt_bboxes = imageMeta['objects'] gtbboxes = helper._transformGTBBox(gt_bboxes, obj_mapping, None, scale=[1, 1], rpn_stride=1, dosplit=False) X, imageDims = filters_rpn.prepareInputs(imageMeta, images_path, cfg) pred_bboxes = np.ones((len(predMeta), 6)) utils.update_progress_new(i + 1, len(predsMeta), imageID) for idx, pred in enumerate(predMeta): prop = pred['score'] lbl = obj_mapping[inv_coco_mapping[int(pred['category_id'])]] bbox = pred['bbox'] pred_bboxes[idx, :] = np.copy( [x * imageDims['scale'][0] / 16 for x in bbox] + [prop] + [lbl]) bbox[2] += bbox[0] bbox[3] += bbox[1] if gtbboxes.shape[0] > 0: ious = helper._computeIoUs(bbox, gtbboxes)