def predict(model_path, img_path, out_path, config):
train_param = detector_utils.get_config(config)
model = detector_utils.create_ssd_model(train_param)
serializers.load_npz(model_path, model)
hand_class = config["model_param"]["hand_class"].split(",")
hand_class = [k.strip() for k in hand_class]
save_images(img_path, model, out_path, hand_class)
def setup_npz(detector_path):
import chainer
try:
import detector.utils as detector_utils
except ImportError:
raise ImportError(
"Please install our `hand` package via \n `pip install -e ../../`")
logger.info("> use npz")
logger.info("> setup config")
config = configparser.ConfigParser()
logger.info("> load config {}".format(
os.path.join(detector_path, "detector", "config.ini")))
config.read(os.path.join(detector_path, "detector", "config.ini"))
detector_param = detector_utils.get_config(config)
logger.info("> setup model")
detector = detector_utils.create_ssd_model(detector_param)
chainer.serializers.load_npz(
os.path.join(detector_path, "detector", "bestmodel.npz"), detector)
hand_class = config["model_param"]["hand_class"].split(",")
hand_class = [k.strip() for k in hand_class]
detector_param = {
"hand_class": hand_class,
"insize": detector.insize,
"nms_thresh": detector.nms_thresh,
"score_thresh": detector.score_thresh,
"mean": detector.mean,
"grids": detector.grids,
"aspect_ratios": detector.multibox.aspect_ratios,
"steps": detector.steps,
"sizes": detector.sizes,
}
logger.info("> param {}".format(detector_param))
logger.info('> cuda enable {}'.format(chainer.backends.cuda.available))
logger.info('> ideep enable {}'.format(
chainer.backends.intel64.is_ideep_available()))
if chainer.backends.cuda.available:
logger.info('> use GPU mode')
detector.to_gpu()
elif chainer.backends.intel64.is_ideep_available():
logger.info('> Intel64 mode')
detector.to_intel64()
chainer.global_config.train = False
chainer.global_config.autotune = True
chainer.global_config.use_ideep = "auto"
chainer.global_config.enable_backprop = False
def model(x):
x = detector.xp.asarray(x)
# assume the layout of x is NCHW
mb_locs, mb_confs = detector(x)
mb_locs = chainer.backends.cuda.to_cpu(mb_locs.array)
mb_confs = chainer.backends.cuda.to_cpu(mb_confs.array)
return mb_locs, mb_confs
return model, detector_param
def setup_detector(detector_path):
logger.info("> setup config")
config = configparser.ConfigParser()
config.read(os.path.join(detector_path, "detector", "config.ini"))
detector_param = detector_utils.get_config(config)
logger.info("> setup model")
model = detector_utils.create_ssd_model(detector_param)
chainer.serializers.load_npz(
os.path.join(detector_path, "detector", "bestmodel.npz"), model)
hand_class = config["model_param"]["hand_class"].split(",")
hand_class = [k.strip() for k in hand_class]
return model, hand_class
def setup_detector(args):
logger.info("> setup config")
detector_path = args.detector
config = configparser.ConfigParser()
config.read(os.path.join(detector_path, "detector", "config.ini"))
detector_param = detector_utils.get_config(config)
logger.info("> setup model")
model = detector_utils.create_ssd_model(detector_param)
chainer.serializers.load_npz(
os.path.join(detector_path, "detector", "bestmodel.npz"), model)
hand_class = config["model_param"]["hand_class"].split(",")
hand_class = [k.strip() for k in hand_class]
detector_param = {
"hand_class": hand_class,
"inH": config.getint("model_param", "input_size"),
"inW": config.getint("model_param", "input_size"),
}
model = to_device(model)
return model, detector_param
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--config_path", type=str, default="config.ini")
parser.add_argument("--resume")
args = parser.parse_args()
config = configparser.ConfigParser()
config.read(args.config_path, "UTF-8")
train_param = utils.get_config(config)
chainer.global_config.autotune = True
chainer.cuda.set_max_workspace_size(11388608)
chainer.config.cudnn_fast_batch_normalization = True
logger.info("> set up devices")
if chainer.backends.cuda.available:
devices = utils.setup_devices(train_param["gpus"])
else:
# cpu run
devices = {"main": -1}
logger.info("> set devices {}".format(devices))
utils.set_random_seed(devices, train_param["seed"])
# get dataset
logger.info("> get dataset")
train, test = select_dataset(config, return_data=["train_set", "val_set"])
logger.info("> size of train {}".format(len(train)))
logger.info("> size of test {}".format(len(test)))
# create result dir and copy file
result = config["output_path"]["result_dir"]
logger.info("> store file to result dir {}".format(result))
utils.create_result_dir(result)
destination = os.path.join(result, "detector")
logger.info("> store config.ini to {}".format(
os.path.join(destination, "config.ini")))
if not os.path.exists(destination):
os.makedirs(destination)
shutil.copy(args.config_path, os.path.join(destination, "config.ini"))
# load model
logger.info("> load model")
model = utils.create_ssd_model(train_param)
model.use_preset("evaluate")
train_chain = MultiboxTrainChain(model, beta=4)
logger.info("> transform dataset")
train = TransformDataset(
train, Transform(model.coder, model.insize, model.mean, train=True))
train_iter = chainer.iterators.MultiprocessIterator(
train,
train_param["batchsize"],
n_processes=train_param["num_process"])
test = TransformDataset(
test, Transform(model.coder, model.insize, model.mean, train=False))
test_iter = chainer.iterators.MultiprocessIterator(
test,
train_param["batchsize"],
repeat=False,
shuffle=False,
n_processes=4)
# initial lr is set to 1e-3 by ExponentialShift
logger.info("> set up optimizer")
optimizer = chainer.optimizers.MomentumSGD(lr=train_param["learning_rate"])
# optimizer = chainer.optimizers.RMSprop(lr=train_param["learning_rate"])
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == "b":
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.ParallelUpdater(train_iter, optimizer, devices=devices)
trainer = training.Trainer(
updater,
(train_param["train_iter"], "iteration"),
destination,
)
trainer.extend(
extensions.ExponentialShift("lr",
0.1,
init=train_param["learning_rate"]),
trigger=triggers.ManualScheduleTrigger(train_param["schedule"],
"iteration"))
# set current device to devices["main"]
# with chainer.cuda.Device(devices["main"]):
eval_interval = 500, "iteration"
logger.info("setup evaluator {}".format(train_param["hand_class"]))
trainer.extend(
DetectionCOCOEvaluator(
test_iter,
model,
device=devices["main"],
label_names=train_param["hand_class"],
),
trigger=eval_interval,
)
log_interval = 100, "iteration"
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
"epoch",
"iteration",
"lr",
"main/loss",
"main/loss/loc",
"main/loss/conf",
"validation/main/map",
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=100))
trainer.extend(extensions.snapshot(filename="best_snapshot"),
trigger=MaxValueTrigger("validation/main/map",
trigger=eval_interval))
trainer.extend(extensions.snapshot_object(model, filename="bestmodel.npz"),
trigger=MaxValueTrigger("validation/main/map",
trigger=eval_interval))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(["main/loss", "validation/main/loss"],
x_key="iteration",
file_name="loss.png"))
trainer.extend(
extensions.PlotReport(["main/accuracy/map", "validation/main/map"],
x_key="iteration",
file_name="accuracy.png"))
if args.resume:
serializers.load_npz(args.resume, trainer)
logger.info("> run trainer")
trainer.run()