def __init__(self, dir=None): if dir is None: dir = get_dataset_path('ilsvrc_metadata') self.dir = os.path.expanduser(dir) mkdir_p(self.dir) f = os.path.join(self.dir, 'synsets.txt') if not os.path.isfile(f): self._download_caffe_meta() self.caffepb = None
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() 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) # 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 __init__(self, dir=None): if dir is None: print "plz input the dataset path" self.dir = dir mkdir_p(self.dir) f = os.path.join(self.dir, 'image_tr.txt') if not os.path.isfile(f): print "can not find image_tr.txt" self.caffepb = None
def proceed_validation(args, is_save=True, is_densecrf=False): import cv2 #name = "ningbo_val" name = "val" ds = dataset.PSSD(args.base_dir, args.meta_dir, name) ds = BatchData(ds, 1) pred_config = PredictConfig(model=Model(), session_init=get_model_loader(args.load), input_names=['image'], output_names=['prob']) predictor = OfflinePredictor(pred_config) from tensorpack.utils.fs import mkdir_p result_dir = "result/pssd_apr26" #result_dir = "ningbo_validation" mkdir_p(result_dir) i = 1 stat = MIoUStatistics(CLASS_NUM) logger.info("start validation....") for image, label in tqdm(ds.get_data()): label = np.squeeze(label) image = np.squeeze(image) def mypredictor(input_img): #input image: 1*H*W*3 #output : H*W*C output = predictor(input_img) return output[0][0] prediction = predict_scaler(image, mypredictor, scales=[0.5, 0.75, 1, 1.25, 1.5], classes=CLASS_NUM, tile_size=CROP_SIZE, is_densecrf=is_densecrf) prediction = np.argmax(prediction, axis=2) stat.feed(prediction, label) if is_save: cv2.imwrite( os.path.join(result_dir, "{}.png".format(i)), np.concatenate((image, visualize_label(label), visualize_label(prediction)), axis=1)) #imwrite_grid(image,label,prediction, border=512, prefix_dir=result_dir, imageId = i) i += 1 logger.info("mIoU: {}".format(stat.mIoU)) logger.info("mean_accuracy: {}".format(stat.mean_accuracy)) logger.info("accuracy: {}".format(stat.accuracy))
def generate_trimap_pascal(rador=1): #main_img_dir = "/data_a/dataset/cityscapes" #meta_txt = "cityscapes" main_img_dir = "/data_a/dataset/pascalvoc2012/VOC2012trainval/VOCdevkit/VOC2012" meta_txt = "pascalvoc12" from tensorpack.utils.fs import mkdir_p trimap_dir = os.path.join(main_img_dir, "trimap_gt{}".format(rador)) mkdir_p(trimap_dir) print(trimap_dir) f = open(os.path.join(meta_txt, "train.txt")) result_f = open( os.path.join(meta_txt, "train_tripmap{}.txt".format(rador)), "w") lines = f.readlines() from tqdm import tqdm for l in tqdm(lines): l = l.strip("\n") img_dir, label_dir = l.split(" ") img = cv2.imread(os.path.join(main_img_dir, img_dir)) label = cv2.imread(os.path.join(main_img_dir, label_dir), 0) new_label = label.copy() basename = os.path.basename(label_dir) #edge = cv2.Canny(label, 100, 200).astype("float32") #xs,ys = np.where(edge==255) w, h = label.shape for x in range(w): for y in range(h): if is_edge(x, y, label): new_label[x - rador:x + rador, y - rador:y + rador] = 255 tripmap_name = os.path.join(trimap_dir, basename) cv2.imshow("im", img / 255.0) cv2.imshow("raw-originlabel", label) cv2.imshow("color-originlabel", visualize_label(label)) cv2.imshow("raw-newlabel", new_label) cv2.imshow("color-newlabel", visualize_label(new_label)) cv2.waitKey(0) #cv2.imwrite(tripmap_name, new_label) result_f.write("{} {}\n".format(img_dir, tripmap_name)) f.close() result_f.close()
def proceed_test(args, is_densecrf=False): import cv2 ds = dataset.Aerial(args.base_dir, args.meta_dir, "test") imglist = ds.imglist ds = BatchData(ds, 1) pred_config = PredictConfig(model=Model(), session_init=get_model_loader(args.load), input_names=['image'], output_names=['prob']) predictor = OfflinePredictor(pred_config) from tensorpack.utils.fs import mkdir_p result_dir = "test-{}".format(os.path.basename(__file__).rstrip(".py")) import shutil shutil.rmtree(result_dir, ignore_errors=True) mkdir_p(result_dir) mkdir_p(os.path.join(result_dir, "compressed")) import subprocess logger.info("start validation....") _itr = ds.get_data() for i in tqdm(range(len(imglist))): image = next(_itr) name = os.path.basename(imglist[i]).rstrip(".tif") image = np.squeeze(image) prediction = predict_scaler(image, predictor, scales=[0.9, 1, 1.1], classes=CLASS_NUM, tile_size=CROP_SIZE, is_densecrf=is_densecrf) prediction = np.argmax(prediction, axis=2) prediction = prediction * 255 # to 0-255 file_path = os.path.join(result_dir, "{}.tif".format(name)) compressed_file_path = os.path.join(result_dir, "compressed", "{}.tif".format(name)) cv2.imwrite(file_path, prediction) command = "gdal_translate --config GDAL_PAM_ENABLED NO -co COMPRESS=CCITTFAX4 -co NBITS=1 " + file_path + " " + compressed_file_path print command subprocess.call(command, shell=True)
def view_data(base_dir, meta_dir, batch_size): ds = RepeatedData(get_data('train', base_dir, meta_dir, batch_size), -1) ds.reset_state() from tensorpack.utils.fs import mkdir_p result_dir = "result/view" #result_dir = "ningbo_validation" mkdir_p(result_dir) i = 0 for ims, labels in ds.get_data(): for im, label in zip(ims, labels): #aa = visualize_label(label) #pass #cv2.imshow("im", im / 255.0) #cv2.imshow("raw-label", label) #cv2.imshow("color-label", visualize_label(label)) cv2.imwrite(os.path.join(result_dir, "{}.png".format(i)), np.concatenate((im, visualize_label(label)), axis=1)) #cv2.waitKey(0) i += 1 print i
def proceed_test_dir(args): import cv2 ll = os.listdir(args.test_dir) pred_config = PredictConfig(model=Model(), session_init=get_model_loader(args.load), input_names=['image'], output_names=['prob']) predictor = OfflinePredictor(pred_config) from tensorpack.utils.fs import mkdir_p result_dir = "test-from-dir" visual_dir = os.path.join(result_dir, "visualization") final_dir = os.path.join(result_dir, "final") import shutil shutil.rmtree(result_dir, ignore_errors=True) mkdir_p(result_dir) mkdir_p(visual_dir) mkdir_p(final_dir) logger.info("start validation....") def mypredictor(input_img): # input image: 1*H*W*3 # output : H*W*C output = predictor(input_img[np.newaxis, :, :, :]) return output[0][0] for i in tqdm(range(len(ll))): filename = ll[i] image = cv2.imread(os.path.join(args.test_dir, filename)) prediction = predict_scaler(image, mypredictor, scales=[0.5, 0.75, 1, 1.25, 1.5], classes=CLASS_NUM, tile_size=CROP_SIZE, is_densecrf=False) prediction = np.argmax(prediction, axis=2) cv2.imwrite(os.path.join(final_dir, "{}".format(filename)), prediction) cv2.imwrite( os.path.join(visual_dir, "{}".format(filename)), np.concatenate((image, visualize_label(prediction)), axis=1))
parser.add_argument('-s', '--scale', help='scale the image data (maybe by 255)', default=1, type=int) parser.add_argument('--index', help='index of the image component in datapoint', default=0, type=int) parser.add_argument('-n', '--number', help='number of images to dump', default=10, type=int) args = parser.parse_args() logger.auto_set_dir(action='d') get_config_func = imp.load_source('config_script', args.config).get_config config = get_config_func() config.dataset.reset_state() if args.output: mkdir_p(args.output) cnt = 0 index = args.index # TODO: as an argument? for dp in config.dataset.get_data(): imgbatch = dp[index] if cnt > args.number: break for bi, img in enumerate(imgbatch): cnt += 1 fname = os.path.join(args.output, '{:03d}-{}.png'.format(cnt, bi)) cv2.imwrite(fname, img * args.scale) NR_DP_TEST = args.number logger.info("Testing dataflow speed:") ds = RepeatedData(config.dataset, -1) with tqdm.tqdm(total=NR_DP_TEST, leave=True, unit='data points') as pbar:
def cam(model, option, gradcam=False, flag=None): model_file = option.load data_dir = option.data if option.imagenet: valnum = 50000 elif option.cub: valnum = 5794 ds = get_data('val', option) pred_config = PredictConfig( model=model, session_init=get_model_loader(model_file), input_names=['input', 'label','bbox'], output_names= ['wrong-top1', 'top5', 'actmap', 'grad'], return_input=True ) if option.imagenet: meta = Imagenet.ImagenetMeta(dir=option.data). \ get_synset_words_1000(option.dataname) meta_labels = Imagenet.ImagenetMeta(dir=option.data). \ get_synset_1000(option.dataname) elif option.cub: meta = CUB200.CUB200Meta(dir=option.data). \ get_synset_words_1000(option.dataname) meta_labels = CUB200.CUB200Meta(dir=option.data). \ get_synset_1000(option.dataname) pred = SimpleDatasetPredictor(pred_config, ds) cnt = 0 cnt_false = 0 hit_known = 0 hit_top1 = 0 index = int(option.locthr*100) if option.camrelu: dirname = os.path.join( 'train_log',option.logdir,'result_camrelu',str(index)) else: dirname = os.path.join( 'train_log',option.logdir,'result_norelu',str(index)) if not os.path.isdir(dirname): mkdir_p(dirname) for inp, outp in pred.get_result(): images, labels, bbox = inp if gradcam: wrongs, top5, convmaps, grads_val = outp batch = wrongs.shape[0] if option.chlast: NUMBER,HEIGHT,WIDTH,CHANNEL = np.shape(convmaps) else: NUMBER,CHANNEL,HEIGHT,WIDTH = np.shape(convmaps) if not option.chlast: grads_val = np.transpose(grads_val, [0,2,3,1]) W = np.mean(grads_val, axis=(1,2)) if option.chlast: convmaps = np.transpose(convmaps, [0,3,1,2]) else: wrongs, top5, convmaps, W = outp batch = wrongs.shape[0] NUMBER,CHANNEL,HEIGHT,WIDTH = np.shape(convmaps) for i in range(batch): gxa = int(bbox[i][0][0]) gya = int(bbox[i][0][1]) gxb = int(bbox[i][1][0]) gyb = int(bbox[i][1][1]) # generating heatmap weight = W[i] # c x 1 convmap = convmaps[i, :, :, :] # c x h x w mergedmap = np.matmul(weight, convmap.reshape((CHANNEL, -1))). \ reshape(HEIGHT, WIDTH) if option.camrelu: mergedmap = np.maximum(mergedmap, 0) mergedmap = cv2.resize(mergedmap, (option.final_size, option.final_size)) heatmap = viz.intensity_to_rgb(mergedmap, normalize=True) blend = images[i] * 0.5 + heatmap * 0.5 # initialization for boundary box bbox_img = images[i] bbox_img = bbox_img.astype('uint8') heatmap = heatmap.astype('uint8') blend = blend.astype('uint8') # thresholding heatmap # For computation efficiency, we revise this part by directly using mergedmap. gray_heatmap = cv2.cvtColor(heatmap,cv2.COLOR_RGB2GRAY) th_value = np.max(gray_heatmap)*option.locthr _, thred_gray_heatmap = \ cv2.threshold(gray_heatmap,int(th_value), 255,cv2.THRESH_TOZERO) _, contours, _ = \ cv2.findContours(thred_gray_heatmap, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) # calculate bbox coordinates rect = [] for c in contours: x, y, w, h = cv2.boundingRect(c) rect.append([x,y,w,h]) if rect == []: estimated_box = [0,0,1,1] #dummy else: x,y,w,h = large_rect(rect) estimated_box = [x,y,x+w,y+h] cv2.rectangle(bbox_img, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.rectangle(bbox_img, (gxa, gya), (gxb, gyb), (0, 0, 255), 2) gt_box = [gxa,gya,gxb,gyb] IOU_ = bb_IOU(estimated_box, gt_box) if IOU_ > 0.5 or IOU_ == 0.5: hit_known = hit_known + 1 if (IOU_ > 0.5 or IOU_ == 0.5) and not wrongs[i]: hit_top1 = hit_top1 + 1 if wrongs[i]: cnt_false += 1 concat = np.concatenate((bbox_img, heatmap, blend), axis=1) classname = meta[meta_labels[labels[i]]].split(',')[0] if cnt < 500: if option.camrelu: cv2.imwrite( 'train_log/{}/result_camrelu/{}/cam{}-{}.jpg'. \ format(option.logdir, index, cnt, classname), concat) else: cv2.imwrite( 'train_log/{}/result_norelu/{}/cam{}-{}.jpg'. \ format(option.logdir, index, cnt, classname), concat) cnt += 1 if cnt == valnum: if option.camrelu: fname = 'train_log/{}/result_camrelu/{}/Loc.txt'. \ format(option.logdir, index) else: fname = 'train_log/{}/result_norelu/{}/Loc.txt'. \ format(option.logdir, index) f = open(fname, 'w') acc_known = hit_known/cnt acc_top1 = hit_top1/cnt top1_acc = 1 - cnt_false / (cnt) if option.camrelu: print ("\nGRADCAM (use relu)") else: print ("\nCAM (do not use relu)") print ('Flag: {}\nCAM Threshold: {}\nGT-known Loc: {} \ \nTop-1 Loc: {}\nTop-1 Acc: {}' \ .format(flag,option.locthr,acc_known,acc_top1,top1_acc)) line = 'GT-known Loc: {}\nTop-1 Loc: {}\nTop-1 Acc: {}'. \ format(acc_known,acc_top1,top1_acc) f.write(line) f.close() return
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...')
# Author: Yuxin Wu <*****@*****.**> import glob, cv2 import numpy as np import sys, os from tensorpack.utils.fs import mkdir_p from runner import get_runner, get_parallel_runner from model import colorize from calibr import load_camera_from_calibr if __name__ == '__main__': dir = sys.argv[1] undistdir = sys.argv[2] outdir = sys.argv[3] mkdir_p(undistdir) mkdir_p(outdir) runner, _ = get_runner('../data/cpm.npy') C0, C1, d0, d1 = load_camera_from_calibr( '../calibr-1211/camchain-homeyihuaDesktopCPM3D_kalibrfinal3.yaml') for f in sorted(glob.glob(os.path.join(dir, '*.jpg'))): im = cv2.imread(f, cv2.IMREAD_COLOR) im = cv2.undistort(im, C0.K, d0) cv2.imwrite(os.path.join(undistdir, os.path.basename(f)), im) im = cv2.resize(im, (368, 368)) out = runner(im) np.save(os.path.join(outdir, os.path.basename(f)), out)
def main(): parser = argparse.ArgumentParser(description='CortexML') parser.add_argument("--arch", type=str, default="small", help="Architecture to use") parser.add_argument("--dataset", type=str, default="MNIST", help="The dataset you want to use", choices=datasets.DATASETS.keys()) parser.add_argument("--epochs", type=int, default=None, help="Number of training epochs") parser.add_argument("--quant", type=str, default="affine", choices=["affine", "symmetric", "none"]) parser.add_argument('--no-cache', action='store_true') parser.add_argument("--weight-clusters", type=int, default=0) parser.add_argument("--batch", type=int, default=32, help="Batch size per GPU to use") parser.add_argument("--checkpoint-dir", type=str, default="./checkpoints") parser.add_argument("--log-dir", type=str, default="./train_log") parser.add_argument("--lr", type=str, default=None, help="Learning rate or learning rate schedule") parser.add_argument( "--post-quantize", action='store_true', help= "Will load a pretrained model and quantize for the specified amount of epochs" ) args = parser.parse_args() logger.set_logger_dir(args.log_dir, action='n') fs.mkdir_p(args.checkpoint_dir) # 1. Train the model (if it doesn't exist) if args.no_cache or not os.path.exists( args.checkpoint_dir + "/checkpoint") or args.post_quantize: print("Model not found, training...") train(args.checkpoint_dir, model_name=args.arch, dataset=args.dataset, num_epochs=args.epochs, quant_type=args.quant, batch_size_per_gpu=args.batch, lr=args.lr, post_quantize_only=args.post_quantize) print("Model training complete.") K.clear_session() else: print( "Using a model in {}. Delete the corresponding folder to start afresh." .format(args.checkpoint_dir)) if args.quant == "none": return # 2. Evaluate the model after training # TODO # 3. Convert quantized model into a simplified protobuf graphdef protobuf_file = args.checkpoint_dir + "/compact_graph.pb" print("Exporting quantized model as a protobuf file:", protobuf_file) predictor_tensors = export_eval_protobuf_model(args.checkpoint_dir, model_name=args.arch, dataset=args.dataset, quant_type=args.quant, output_file=protobuf_file, batch_size=args.batch) inputs, outputs, input_shapes = predictor_tensors # 4. Convert the model into tflite format tflite_model_file = args.checkpoint_dir + "/quantized_model.tflite" print("Converting quantized model into a tflite file:", tflite_model_file) create_tflite_model(protobuf_file, inputs, outputs, input_shapes, tflite_model_file) if args.weight_clusters > 0: cluster_tflite_model_weights(tflite_model_file, args.weight_clusters) tflite_model_file = args.checkpoint_dir + "/clustered_quantized_model.tflite" evaluate_tflite_model(tflite_model_file, dataset=args.dataset)
def __init__(self, dir=None): self.dir = dir mkdir_p(self.dir) f = os.path.join(self.dir, 'synsets.txt') self.caffepb = None
def get_log_dir(option): threshold_idx = int(option.cam_threshold * 100) dirname = ospj('train_log', option.log_dir, 'result', str(threshold_idx)) if not os.path.isdir(dirname): mkdir_p(dirname) return dirname, threshold_idx