def run(runner, cfg_path, commands, arg, splits):
"""Run commands within pipelines using runner named RUNNER."""
tmp_dir_obj = rv_config.get_tmp_dir()
tmp_dir = tmp_dir_obj.name
cfg_module = importlib.import_module(cfg_path)
args = dict(arg)
args = convert_bool_args(args)
cfgs = get_configs(cfg_module, runner, args)
runner = registry.get_runner(runner)()
for cfg in cfgs:
cfg.update()
cfg.rv_config = rv_config.get_config_dict(registry.rv_config_schema)
cfg.recursive_validate_config()
cfg_dict = cfg.dict()
cfg_json_uri = cfg.get_config_uri()
json_to_file(cfg_dict, cfg_json_uri)
pipeline = cfg.build(tmp_dir)
if not commands:
commands = pipeline.commands
runner.run(cfg_json_uri, pipeline, commands, num_splits=splits)
def __init__(self, cfg: LearnerConfig, tmp_dir, model_path=None):
self.cfg = cfg
self.tmp_dir = tmp_dir
torch_cache_dir = '/opt/data/torch-cache'
os.environ['TORCH_HOME'] = torch_cache_dir
self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
self.data_cache_dir = '/opt/data/data-cache'
make_dir(self.data_cache_dir)
self.model = self.build_model()
self.model.to(self.device)
if model_path is not None:
if isfile(model_path):
self.model.load_state_dict(
torch.load(model_path, map_location=self.device))
else:
raise Exception(
'Model could not be found at {}'.format(model_path))
self.model.eval()
else:
log.info(self.cfg)
self.train_ds = None
self.train_dl = None
self.valid_ds = None
self.valid_dl = None
self.test_ds = None
self.test_dl = None
if cfg.output_uri.startswith('s3://'):
self.output_dir = get_local_path(cfg.output_uri, tmp_dir)
make_dir(self.output_dir, force_empty=True)
if not cfg.overfit_mode:
self.sync_from_cloud()
else:
self.output_dir = cfg.output_uri
make_dir(self.output_dir)
self.last_model_path = join(self.output_dir, 'last-model.pth')
self.config_path = join(self.output_dir, 'config.json')
self.train_state_path = join(self.output_dir, 'train-state.json')
self.log_path = join(self.output_dir, 'log.csv')
model_bundle_fn = basename(cfg.get_model_bundle_uri())
self.model_bundle_path = join(self.output_dir, model_bundle_fn)
self.metric_names = self.build_metric_names()
json_to_file(self.cfg.dict(), self.config_path)
self.load_init_weights()
self.load_checkpoint()
self.opt = self.build_optimizer()
self.setup_data()
self.start_epoch = self.get_start_epoch()
self.steps_per_epoch = len(
self.train_ds) // self.cfg.solver.batch_sz
self.step_scheduler = self.build_step_scheduler()
self.epoch_scheduler = self.build_epoch_scheduler()
self.setup_tensorboard()
def eval_model(self, split):
log.info('Evaluating on {} set...'.format(split))
dl = self.get_dataloader(split)
metrics = self.validate_epoch(dl)
log.info('metrics: {}'.format(metrics))
json_to_file(metrics,
join(self.output_dir, '{}_metrics.json'.format(split)))
self.plot_predictions(split)
def save(self, labels):
"""Save labels to URI."""
boxes = labels.get_boxes()
class_ids = labels.get_class_ids().tolist()
scores = labels.get_scores().tolist()
geojson = boxes_to_geojson(
boxes,
class_ids,
self.crs_transformer,
self.class_config,
scores=scores)
json_to_file(geojson, self.uri)
def save(self, labels):
"""Save labels to URI if writable.
Note that if the grid is inferred from polygons, only the grid will be
written, not the original polygons.
"""
boxes = labels.get_cells()
class_ids = labels.get_class_ids()
scores = list(labels.get_scores())
geojson = boxes_to_geojson(boxes,
class_ids,
self.crs_transformer,
self.class_config,
scores=scores)
json_to_file(geojson, self.uri)
def compute_coco_eval(outputs, targets, num_class_ids):
"""Return mAP averaged over 0.5-0.95 using pycocotools eval.
Note: boxes are in (ymin, xmin, ymax, xmax) format with values ranging
from 0 to h or w.
Args:
outputs: (list) of length m containing dicts of form
{'boxes': <tensor with shape (n, 4)>,
'class_ids': <tensor with shape (n,)>,
'scores': <tensor with shape (n,)>}
targets: (list) of length m containing dicts of form
{'boxes': <tensor with shape (n, 4)>,
'class_ids': <tensor with shape (n,)>}
"""
with tempfile.TemporaryDirectory() as tmp_dir:
preds = get_coco_preds(outputs)
# ap is undefined when there are no predicted boxes
if len(preds) == 0:
return None
gt = get_coco_gt(targets, num_class_ids)
gt_path = join(tmp_dir, 'gt.json')
json_to_file(gt, gt_path)
coco_gt = COCO(gt_path)
pycocotools.coco.unicode = None
coco_preds = coco_gt.loadRes(preds)
ann_type = 'bbox'
coco_eval = COCOeval(coco_gt, coco_preds, ann_type)
coco_eval.evaluate()
coco_eval.accumulate()
coco_eval.summarize()
return coco_eval