def run_inference(self): out_project_fs = copy(self.in_project_fs) out_project_fs.root_path = self.helper.paths.results_dir out_project_fs.make_dirs() inf_feeder = sly.InferenceFeederFactory.create(self.config, self.helper.in_project_meta, self.train_classes) out_pr_meta = inf_feeder.out_meta out_pr_meta.to_dir(out_project_fs.project_path) ia_cnt = out_project_fs.pr_structure.image_cnt progress = sly.progress_counter_inference(cnt_imgs=ia_cnt) for sample in self.in_project_fs: logger.info('Will process image', extra={'dataset_name': sample.ds_name, 'image_name': sample.image_name}) ann_packed = sly.json_load(sample.ann_path) ann = sly.Annotation.from_packed(ann_packed, self.helper.in_project_meta) img = cv2.imread(sample.img_path)[:, :, ::-1] res_ann = inf_feeder.feed(img, ann, self._infer_on_img) out_ann_fpath = out_project_fs.ann_path(sample.ds_name, sample.image_name) res_ann_packed = res_ann.pack() sly.json_dump(res_ann_packed, out_ann_fpath) if self.debug_copy_images: out_img_fpath = out_project_fs.img_path(sample.ds_name, sample.image_name) sly.ensure_base_path(out_img_fpath) shutil.copy(sample.img_path, out_img_fpath) progress.iter_done_report() sly.report_inference_finished()
def main(): # Please note that auxiliary methods from sly (supervisely_lib) use supervisely_lib.logger to format output. # So don't replace formatters or handlers of the logger. # One may use other loggers or simple prints for other output, but it's recommended to use supervisely_lib.logger. logger.info('Hello ML world') print('Glad to see u') # TaskHelperTrain contains almost all needed to run inference as Supervisely task, # including task settings and paths to data and model. task_helper = sly.TaskHelperInference() # All settings and parameters are passed to task in json file. # Content of the file is entirely dependent on model implementation. inference_settings = task_helper.task_settings logger.info('Task settings are read', extra={'task_settings': inference_settings}) # Let's imitate loading training model weights. Task acquires directory with the weights. # And content of the directory is entirely dependent on model implementation. model_dir = task_helper.paths.model_dir model = load_fake_model(model_dir) logger.info('Model weights are loaded', extra={'model_dir': model_dir}) # We are going to read input project with data for inference. project_meta = task_helper.in_project_meta # Project meta contains list of project classes. project_dir = task_helper.paths.project_dir project_fs = sly.ProjectFS.from_disk_dir_project(project_dir) # ProjectFS enlists all samples (image/annotation pairs) in input project. # We are to write inference results as sly project with same structure into provided results dir. # There is no need to save images, only annotations and project meta are required. results_dir = task_helper.paths.results_dir out_project_fs = sly.ProjectFS(results_dir, project_fs.pr_structure) # It's necessary to write project meta (with list of classes) for output project. out_meta = sly.ProjectMeta([{ 'title': 'hat', 'shape': 'point', 'color': '#FF0000' }]) # create meta out_meta.to_dir(out_project_fs.project_path) # and save # We are to report progress of task over sly.ProgressCounter if we want to observe the progress in web panel. # In fact one task may report progress for some sequential (not nested) subtasks, # but here we will report inference progress only. ia_cnt = out_project_fs.pr_structure.image_cnt progress = sly.progress_counter_inference(cnt_imgs=ia_cnt) # Iterating over samples (image/annotation pairs) in input project. for item_descr in project_fs: logger.info('Processing input sample', extra={ 'dataset': item_descr.ds_name, 'image_name': item_descr.image_name }) # Open some image... img = cv2.imread(item_descr.img_path) logger.info('Read image from input project', extra={ 'width': img.shape[1], 'height': img.shape[0] }) # And read corresponding annotation... ann_packed = sly.json_load(item_descr.ann_path) ann = sly.Annotation.from_packed(ann_packed, project_meta) logger.info('Read annotation from input project', extra={'tags': ann['tags']}) logger.info('Some forward pass...') time.sleep(1) # Let's imitate inference output. # We are to save results as sly Figures in annotation. ann['objects'] = [sly.FigurePoint.from_pt('hat', (800, 800)) ] # imagine that our model found the point out_ann_path = out_project_fs.ann_path(item_descr.ds_name, item_descr.image_name) sly.ensure_base_path(out_ann_path) # create intermediate directories sly.json_dump(ann.pack(), out_ann_path) # and save annotation # Note that there is no need to save image. progress.iter_done_report( ) # call it after every iteration to report progress # It's necessary to report that the inference task is finished. sly.report_inference_finished() # Thank you for your patience. logger.info('Applying finished.')