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)
