def export(args): model = AttentionOCR() predcfg = PredictConfig( model=model, session_init=SmartInit(args.checkpoint_path), input_names=model.get_inferene_tensor_names()[0], output_names=model.get_inferene_tensor_names()[1]) ModelExporter(predcfg).export_compact(args.pb_path, optimize=False)
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 test_checkpoint(args): model = AttentionOCR() predcfg = PredictConfig(model=model, session_init=SmartInit(args.checkpoint_path), input_names=model.get_inferene_tensor_names()[0], output_names=model.get_inferene_tensor_names()[1]) predictor = OfflinePredictor(predcfg) list_dict = [] with open("result/model-500000-512.txt", "w") as f: ned = 0. count = 0 for filename in os.listdir(args.img_folder)[500:]: results = {} img_path = os.path.join(args.img_folder, filename) print("----> image path: ", img_path) name = filename.split('_')[0] image = cv2.imread(img_path) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) height, width = image.shape[:2] points = [[0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]] image = preprocess(image, points, cfg.image_size) before = time.time() preds, probs = predictor(np.expand_dims(image, axis=0), np.ones([1, cfg.seq_len + 1], np.int32), False, 1.) print(preds) print(probs) after = time.time() text, confidence = label2str(preds[0], probs[0], cfg.label_dict) print("Text: ", text) print("Label: ", name) print("confidence: ", confidence) print("cal_sim: ", cal_sim(text, name)) ned += cal_sim(text, name) count += 1 print("-------------------------------") f.write("Path: {}".format(img_path)) f.write("\n") f.write("Text: {}".format(text)) f.write("\n") f.write("Label: {}".format(name)) f.write("\n") f.write("Confidence: {}".format(confidence)) f.write("\n") f.write("1-N.E.D: {}".format(cal_sim(text, name))) f.write("\n") f.write("---------------------------------------------") f.write("\n") f.write("Total {} Images | Average NED: {}".format(count, ned / count))
def get_config(model): nr_tower = max(get_num_gpu(), 1) batch = args.batch // nr_tower logger.info("Running on {} towers. Batch size per tower: {}".format(nr_tower, batch)) callbacks = [ThroughputTracker(args.batch)] if args.fake: data = QueueInput(FakeData( [[batch, 224, 224, 3], [batch]], 1000, random=False, dtype='uint8')) else: data = QueueInput( get_imagenet_dataflow(args.data, 'train', batch), # use a larger queue queue=tf.FIFOQueue(200, [tf.uint8, tf.int32], [[batch, 224, 224, 3], [batch]]) ) BASE_LR = 30 SCALED_LR = BASE_LR * (args.batch / 256.0) callbacks.extend([ ModelSaver(), EstimatedTimeLeft(), ScheduledHyperParamSetter( 'learning_rate', [ (0, SCALED_LR), (60, SCALED_LR * 1e-1), (70, SCALED_LR * 1e-2), (80, SCALED_LR * 1e-3), (90, SCALED_LR * 1e-4), ]), ]) dataset_val = get_imagenet_dataflow(args.data, 'val', 64) infs = [ClassificationError('wrong-top1', 'val-error-top1'), ClassificationError('wrong-top5', 'val-error-top5')] if nr_tower == 1: callbacks.append(InferenceRunner(QueueInput(dataset_val), infs)) else: callbacks.append(DataParallelInferenceRunner( dataset_val, infs, list(range(nr_tower)))) if args.load.endswith(".npz"): # a released model in npz format init = SmartInit(args.load) else: # a pre-trained checkpoint init = SaverRestore(args.load, ignore=("learning_rate", "global_step")) return TrainConfig( model=model, data=data, callbacks=callbacks, steps_per_epoch=100 if args.fake else 1281167 // args.batch, session_init=init, max_epoch=100, )
def train(): roidb = get_roidb(cfg.dataset_name) train_dataflow = get_batch_train_dataflow(roidb, cfg.batch_size) logger.set_logger_dir(cfg.summary_path, 'd') # Compute the training schedule from the number of GPUs ... warmup_schedule = [(0, cfg.learning_rate), (cfg.warmup_steps, cfg.learning_rate)] # lr_schedule = [(int(cfg.warmup_steps/cfg.steps_per_epoch+0.5), cfg.learning_rate),(cfg.num_epochs-150, cfg.learning_rate/10),(cfg.num_epochs-50, cfg.learning_rate/100)] # Create callbacks ... callbacks = [ PeriodicCallback(ModelSaver(max_to_keep=10, keep_checkpoint_every_n_hours=0.5), every_k_epochs=10), # linear warmup ScheduledHyperParamSetter('learning_rate', warmup_schedule, interp='linear', step_based=True), # ScheduledHyperParamSetter('learning_rate', lr_schedule), GPUMemoryTracker(), HostMemoryTracker(), ThroughputTracker(samples_per_step=cfg.num_gpus), EstimatedTimeLeft(median=True), SessionRunTimeout(60000), # 1 minute timeout GPUUtilizationTracker() ] # session_init = SmartInit(cfg.pretrain_path, ignore_mismatch=True) if cfg.restore_path: session_init = SmartInit(cfg.restore_path) else: session_init = SaverRestoreRelaxed( cfg.pretrain_path, ignore=['global_step:0'] ) # if cfg.pretrain_path else SmartInit(cfg.restore_path, ignore_mismatch=True) model = AttentionOCR() traincfg = TrainConfig(model=model, data=QueueInput(train_dataflow), callbacks=callbacks, steps_per_epoch=cfg.steps_per_epoch, max_epoch=cfg.num_epochs, session_init=session_init, starting_epoch=cfg.starting_epoch) trainer = SyncMultiGPUTrainerReplicated(cfg.num_gpus, average=False, mode='nccl') launch_train_with_config(traincfg, trainer)
def init_predictor(): register_coco(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() finalize_configs(is_training=False) predcfg = PredictConfig( model=MODEL, #session_init=SmartInit("/home/jetson/Documents/trained_model/500000_17/checkpoint"), session_init=SmartInit( "/home/jetson/Documents/trained_model/255000_04.01/checkpoint"), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) return predictor
def inference(input_data, hps, predictor=None): # input data is numpy has shape: [M, T, D] # return softmax with C classes if predictor is None: M = ModelDesc(hps) pred_config = PredictConfig(session_init=SmartInit(hps.checkpoint_path), model=M, input_names=['x'], output_names=['predict/y_pred'] ) predictor = OfflinePredictor(pred_config) outputs = predictor(input_data) rs = softmax(outputs[0]) return rs
def evaluate_rcnn(model_name, paper_arxiv_id, cfg_list, model_file): evaluator = COCOEvaluator( root=COCO_ROOT, model_name=model_name, paper_arxiv_id=paper_arxiv_id ) category_id_to_coco_id = { v: k for k, v in COCODetection.COCO_id_to_category_id.items() } cfg.update_config_from_args(cfg_list) # TODO backup/restore config finalize_configs(False) MODEL = ResNetFPNModel() if cfg.MODE_FPN else ResNetC4Model() predcfg = PredictConfig( model=MODEL, session_init=SmartInit(model_file), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1], ) predictor = OfflinePredictor(predcfg) def xyxy_to_xywh(box): box[2] -= box[0] box[3] -= box[1] return box df = get_eval_dataflow("coco_val2017") df.reset_state() for img, img_id in tqdm.tqdm(df, total=len(df)): results = predict_image(img, predictor) res = [ { "image_id": img_id, "category_id": category_id_to_coco_id.get( int(r.class_id), int(r.class_id) ), "bbox": xyxy_to_xywh([round(float(x), 4) for x in r.box]), "score": round(float(r.score), 3), } for r in results ] evaluator.add(res) if evaluator.cache_exists: break evaluator.save()
def eval(args, filenames, polygons, labels, label_dict=cfg.label_dict): Normalized_ED = 0. total_num = 0 total_time = 0 model = AttentionOCR() predcfg = PredictConfig(model=model, session_init=SmartInit(args.checkpoint_path), input_names=model.get_inferene_tensor_names()[0], output_names=model.get_inferene_tensor_names()[1]) predictor = OfflinePredictor(predcfg) for filename, points, label in zip(filenames, polygons, labels): image = cv2.imread(filename) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = preprocess(image, points, cfg.image_size) before = time.time() preds, probs = predictor(np.expand_dims(image, axis=0), np.ones([1, cfg.seq_len + 1], np.int32), False, 1.) after = time.time() total_time += after - before preds, probs = label2str(preds[0], probs[0], label_dict) print(label) print(preds, probs) sim = cal_sim(preds, label) total_num += 1 Normalized_ED += sim print("total_num: %d, N.E.D: %.4f, average time: %.4f" % (total_num, Normalized_ED / total_num, total_time / total_num))
help='variants of resnet to use', default='resnet') args = parser.parse_args() if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu model = Model(args.depth, args.mode) model.data_format = args.data_format if args.weight_decay_norm: model.weight_decay_pattern = ".*/W|.*/gamma|.*/beta" if args.eval: batch = 128 # something that can run on one gpu ds = get_imagenet_dataflow(args.data, 'val', batch) eval_classification(model, SmartInit(args.load), ds) else: if args.fake: logger.set_logger_dir(os.path.join('train_log', 'tmp'), 'd') else: logger.set_logger_dir( os.path.join( '/data0/wangguangrun/tensorflow_log/train_log', 'imagenet-{}-d{}-batch{}'.format(args.mode, args.depth, args.batch))) config = get_config(model) config.session_init = SmartInit(args.load) trainer = SyncMultiGPUTrainerReplicated(max(get_num_gpu(), 1)) launch_train_with_config(config, trainer)
if not os.path.exists(save_path): os.makedirs(save_path) cv2.imwrite(save_path + img_name, viz) logger.info("Inference output for {} written to {}".format( input_file, save_path)) if __name__ == '__main__': register_coco(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() finalize_configs(is_training=False) predcfg = PredictConfig( model=MODEL, session_init=SmartInit("data/train_log/backup/checkpoint"), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) model_num = "4490" f1 = [] for (dirpath, dirnames, filenames) in walk("data/16_Dec"): f1.extend(filenames) break for img in f1: img = "data/16_Dec/" + img do_predict(predictor, img) print("Done!")
""" Sec 2.3: We keep the per-worker sample size n constant when we change the number of workers k. In this work, we use n = 32 which has performed well for a wide range of datasets and networks. """ parser.add_argument('--batch', help='per-GPU batch size', default=32, type=int) args = parser.parse_args() model = Model(args.depth, args.norm) model.accum_grad = args.accum_grad if args.weight_decay_norm: model.weight_decay_pattern = ".*/W|.*/gamma|.*/beta" if args.eval: batch = 128 # something that can run on one gpu ds = get_val_dataflow(args.data, batch, fbresnet_augmentor(False)) eval_classification(model, SmartInit(args.load), ds) sys.exit() logger.info("Training on {}".format(socket.gethostname())) # Print some information for sanity check. os.system("nvidia-smi") assert args.load is None hvd.init() if args.logdir is None: args.logdir = os.path.join('train_log', 'Horovod-{}GPUs-{}Batch'.format(hvd.size(), args.batch)) if hvd.rank() == 0: logger.set_logger_dir(args.logdir, 'd') logger.info("Rank={}, Local Rank={}, Size={}".format(hvd.rank(), hvd.local_rank(), hvd.size()))
if not os.path.exists(result_folder): os.makedirs(result_folder) cv2.imwrite(result_folder + img_name, viz) logger.info("Inference output for {} written to {}".format( input_file, result_folder)) if __name__ == '__main__': register_coco(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() finalize_configs(is_training=False) predcfg = PredictConfig( model=MODEL, session_init=SmartInit( "data/train_log_bam/27.01.2020_bam_old_backup/checkpoint"), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) source_folder = "data/forTest_BAM/old/" result_folder = source_folder + "../" + "result_old_50000/" f1 = [] for (dirpath, dirnames, filenames) in walk(source_folder): f1.extend(filenames) for img in f1: img = source_folder + img do_predict(predictor, img)
def restore_parameter(sess): file_path = "X101-DenoiseAll.npz" sessinit = SmartInit(file_path) sessinit.init(sess)
finalize_configs(is_training=False) if args.predict or args.visualize: cfg.TEST.RESULT_SCORE_THRESH = cfg.TEST.RESULT_SCORE_THRESH_VIS # let the output has the same path logic as checkpoint if args.predict_unlabeled: output_dir = args.predict_unlabeled predict_unlabeled(MODEL, args.load, output_dir=output_dir) if args.visualize: do_visualize(MODEL, args.load, output_dir=output_dir) else: predcfg = PredictConfig( model=MODEL, session_init=SmartInit(args.load), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) if args.output_pb: ModelExporter(predcfg).export_compact(args.output_pb, optimize=False) elif args.output_serving: ModelExporter(predcfg).export_serving(args.output_serving, optimize=False) if args.predict: predictor = OfflinePredictor(predcfg) for image_file in args.predict: do_predict(predictor, image_file) elif args.evaluate:
def do_train(model, image_size=224, buffer_size=2000): batch = args.batch total_batch = batch * hvd.size() if args.fake: data = FakeData([[batch, image_size, image_size, 3], [batch]], 1000, random=False, dtype=['uint8', 'int32']) data = StagingInput(QueueInput(data)) callbacks = [] steps_per_epoch = 50 else: logger.info("#Tower: {}; Batch size per tower: {}".format( hvd.size(), batch)) zmq_addr = 'ipc://@imagenet-train-b{}-p{}'.format(batch, args.port) if args.no_zmq_ops: dataflow = RemoteDataZMQ(zmq_addr, hwm=buffer_size, bind=False) data = QueueInput(dataflow) else: data = ZMQInput(zmq_addr, 30, bind=False) data = StagingInput(data) steps_per_epoch = int(np.round(1281167 / total_batch)) BASE_LR = 0.1 * (total_batch // 256) """ ImageNet in 1 Hour, Sec 2.1: Linear Scaling Rule: When the minibatch size is multiplied by k, multiply the learning rate by k. """ logger.info("Base LR: {}".format(BASE_LR)) callbacks = [ ModelSaver(max_to_keep=10), EstimatedTimeLeft(), ScheduledHyperParamSetter('learning_rate', [(0, BASE_LR), (35, BASE_LR * 1e-1), (70, BASE_LR * 1e-2), (95, BASE_LR * 1e-3)]) ] """ Feature Denoising, Sec 5: Our models are trained for a total of 110 epochs; we decrease the learning rate by 10× at the 35- th, 70-th, and 95-th epoch """ max_epoch = 110 if BASE_LR > 0.1: callbacks.append( ScheduledHyperParamSetter('learning_rate', [(0, 0.1), (5 * steps_per_epoch, BASE_LR)], interp='linear', step_based=True)) """ ImageNet in 1 Hour, Sec 2.2: we start from a learning rate of η and increment it by a constant amount at each iteration such that it reaches ηˆ = kη after 5 epochs """ if not args.fake: # add distributed evaluation, for various attackers that we care. def add_eval_callback(name, attacker, condition): cb = create_eval_callback( name, model.get_inference_func(attacker), # always eval in the last 2 epochs no matter what lambda epoch_num: condition(epoch_num) or epoch_num > max_epoch - 2, image_size=image_size) callbacks.append(cb) add_eval_callback('eval-clean', NoOpAttacker(), lambda e: True) add_eval_callback( 'eval-10step', PGDAttacker(10, args.attack_epsilon, args.attack_step_size), lambda e: True) add_eval_callback( 'eval-50step', PGDAttacker(50, args.attack_epsilon, args.attack_step_size), lambda e: e % 20 == 0) add_eval_callback( 'eval-100step', PGDAttacker(100, args.attack_epsilon, args.attack_step_size), lambda e: e % 10 == 0 or e > max_epoch - 5) for k in [20, 30, 40, 60, 70, 80, 90]: add_eval_callback( 'eval-{}step'.format(k), PGDAttacker(k, args.attack_epsilon, args.attack_step_size), lambda e: False) trainer = HorovodTrainer(average=True) trainer.setup_graph(model.get_input_signature(), data, model.build_graph, model.get_optimizer) trainer.train_with_defaults(callbacks=callbacks, steps_per_epoch=steps_per_epoch, session_init=SmartInit(args.load), max_epoch=max_epoch, starting_epoch=args.starting_epoch)
return rs if __name__ == "__main__": checkpoint_path = './train_log/train/checkpoint' hps = get_default_hparams() mongo_client = MongoClient('localhost', 27017) db = mongo_client.crypto_currency collection = db['ohlcv'] market = 'binance' symbol = 'BNB/BTC' timewindow = '1h' query = {'market': market, 'symbol': symbol, 'timewindow': timewindow} df_data = pd.DataFrame(list(collection.find(query)))[-hps.M - 100:] df_data = df_data[hps.attributes_normalize_mean] model = ModelDesc(hps) pred_config = PredictConfig(session_init=SmartInit(hps.checkpoint_path), model=model, input_names=['x'], output_names=['predict/y_pred'] ) predictor = OfflinePredictor(pred_config) # input_data = np.random.rand(hps.M, hps.T, hps.D) input_data = test_segment(df_data, hps) rs = inference(input_data[-hps.M:], hps=hps, predictor=predictor)
def train(args, cfg): out_dirs = gen_outdirs(args, "tp") output_dir, out_res_dir = out_dirs["output_dir"], out_dirs["out_res_dir"] df = PneuSegDF(args.mode, out_res_dir, args.train_dir, args.testset_dir, args.min_num_workers, cfg) num_gpu = max(get_num_gpu(), 1) ds = df.prepared(num_gpu, cfg.batch_size) # Avoid overwritting config file if os.path.exists(pj(output_dir, os.path.basename(args.config))): input( "Config file will NOT be overwritten. Press Enter to continue...") else: shutil.copy(args.config, output_dir) logger.set_logger_dir(pj(output_dir, "log")) callback_list = [ # PeriodicCallback overwritten the frequency of what's wrapped PeriodicCallback(ModelSaver(50, checkpoint_dir=output_dir), every_k_epochs=1), GPUUtilizationTracker(), MergeAllSummaries(1 if args.train_debug else 0), # ProgressBar(["Loss"]) ] if cfg.network["norm_layer"] == "BN_layers": callback_list.append(BN_layers_update()) if cfg.lr_schedule["type"] == "epoch_wise_constant": schedule = [(ep, lr / num_gpu) for ep, lr in zip( [0] + cfg.lr_schedule["epoch_to_drop_lr"], cfg.lr_schedule["lr"])] callback_list.append( ScheduledHyperParamSetter("learning_rate", schedule)) elif cfg.lr_schedule["type"] == "halved": schedule = [(0, cfg.lr_schedule["init_lr"])] for i in range(cfg.lr_schedule["first_epoch2drop"], cfg.max_epoch, cfg.lr_schedule["period"]): schedule.append( (i, schedule[int((i - cfg.lr_schedule["first_epoch2drop"]) / cfg.lr_schedule["period"])][1] / (cfg.lr_schedule["decay_rate"] * num_gpu))) print(schedule) callback_list.append( ScheduledHyperParamSetter("learning_rate", schedule)) steps_per_epoch = len(ds) // num_gpu + 1 train_cfg = TrainConfig( model=Tensorpack_model(cfg, steps_per_epoch), data=QueueInput(ds), steps_per_epoch=steps_per_epoch, callbacks=callback_list, monitors=[ # ScalarPrinter(True, whitelist=["Loss", "LR"]), ScalarPrinter(True), # ScalarPrinter(), TFEventWriter(), # JSONWriter() ], max_epoch=cfg.max_epoch, session_init=SmartInit(args.resume), starting_epoch=args.resume_epoch) launch_train_with_config( train_cfg, SyncMultiGPUTrainerReplicated(num_gpu) if num_gpu > 1 else SimpleTrainer())
if not os.path.exists(save_path): os.makedirs(save_path) cv2.imwrite(save_path + img_name, viz) logger.info("Inference output for {} written to {}".format( input_file, save_path)) if __name__ == '__main__': register_coco(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() finalize_configs(is_training=False) predcfg = PredictConfig( model=MODEL, session_init=SmartInit("/home/jetson/Documents/598000/checkpoint"), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) model_num = "507500" f1 = [] for (dirpath, dirnames, filenames) in walk("/home/jetson/Documents/16_Dec"): f1.extend(filenames) break for img in f1: img = "/home/jetson/Documents/16_Dec/" + img do_predict(predictor, img)
color=(100, 220, 80), thickness=5) viz = np.concatenate((img, final), axis=1) cv2.imwrite( "/home/jetson/tensorpack/examples/FasterRCNN/static/images/output.png", viz) logger.info("Inference output written to output.png") if __name__ == '__main__': register_coco(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() finalize_configs(is_training=False) predcfg = PredictConfig( model=MODEL, session_init=SmartInit( "/home/jetson/Documents/trained_model/500000_17/checkpoint"), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) do_predict( predictor, "/home/jetson/tensorpack/examples/FasterRCNN/static/images/original.jpg" ) # this line can be commented out, but the FIRST reference after service start will take longer #app.run(host='192.168.117.90', port=5000, debug=False) # port 80 needs sudo permission app.run(host='127.0.0.1', port=5000, debug=False)
# from tensorflow.python.framework import test_util # assert get_tf_version_tuple() >= (1, 7) and test_util.IsMklEnabled(), \ # "Inference requires either GPU support or MKL support!" assert args.load_ckpt or args.load_pb finalize_configs(is_training=False) if args.predict or args.visualize: cfg.TEST.RESULT_SCORE_THRESH = cfg.TEST.RESULT_SCORE_THRESH_VIS if args.visualize: do_visualize(MODEL, args.load) else: if args.load_ckpt: predcfg = PredictConfig( model=MODEL, session_init=SmartInit(args.load_ckpt), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) print('input_names: ', MODEL.get_inference_tensor_names()[0]) print('output_names: ', MODEL.get_inference_tensor_names()[1]) if args.output_pb: ModelExporter(predcfg).export_compact(args.output_pb, optimize=False) elif args.output_serving: ModelExporter(predcfg).export_serving(args.output_serving) if args.predict: # check existence of subfolder for (path, b, files) in os.walk(args.predict[0]): if path == args.predict[0]:
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...')
#gpu_options = tf.GPUOptions(allow_growth=True) #sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) register_coco(cfg.DATA.BASEDIR) # add COCO datasets to the registry register_balloon(cfg.DATA.BASEDIR) MODEL = ResNetFPNModel() if cfg.MODE_FPN else ResNetC4Model() if not tf.test.is_gpu_available(): from tensorflow.python.framework import test_util assert get_tf_version_tuple() >= (1, 7) and test_util.IsMklEnabled(), \ "Inference requires either GPU support or MKL support!" finalize_configs(is_training=False) cfg.TEST.RESULT_SCORE_THRESH = cfg.TEST.RESULT_SCORE_THRESH_VIS predcfg = PredictConfig( model=MODEL, session_init=SmartInit(load), input_names=MODEL.get_inference_tensor_names()[0], output_names=MODEL.get_inference_tensor_names()[1]) predictor = OfflinePredictor(predcfg) test_images = os.listdir('test_images') for input_file in test_images: #input_file = test_images[0] do_predict(predictor, input_file)