def upload_result_project(self, _): self.report_step_done(TaskStep.MAIN) self._read_verif_status() graph_pr_name = sly.get_res_project_name(self.info['graph']) no_image_files = not self.download_images if self.is_archive is False: pr_id = self.data_mgr.upload_project(self.dir_results, graph_pr_name, no_image_files=no_image_files) self.logger.info('PROJECT_CREATED', extra={ 'event_type': EventType.PROJECT_CREATED, 'project_id': pr_id }) else: # remove excess fields from json root_path, project_name = sly.ProjectFS.split_dir_project( self.dir_results) project_fs = sly.ProjectFS.from_disk(root_path, project_name, by_annotations=True) for item in project_fs: ann_path = item.ann_path ann = sly.json_load(ann_path) for exc_field in ann_special_fields(): ann.pop(exc_field, None) sly.json_dump(ann, ann_path) self.data_mgr.upload_archive(self.dir_results, graph_pr_name) self.report_step_done(TaskStep.UPLOAD) return {}
def run(self): try: self.init_logger() self.init_api() self.future_log = self.executor_log.submit( self.submit_log) # run log submitting except Exception as e: # unable to do something another if crashed print(e) sly.json_dump( e, osp.join(constants.AGENT_ROOT_DIR, 'logger_fail.json')) os._exit(1) # ok, documented log_extra = {'event_type': EventType.TASK_FINISHED} logger_fn = self.logger.info try: self.report_start() self.init_additional() self.run_and_wait(self.task_main_func) except StopTaskException: log_extra = { 'event_type': EventType.TASK_STOPPED, 'stopped': 'by_user' } except Exception: log_extra = { 'event_type': EventType.TASK_CRASHED, 'error': traceback.format_exc().split('\n') } logger_fn = self.logger.critical logger_fn('TASK_END', extra=log_extra) self.logger.info("WAIT_FOR_TASK_LOG") self.stop_log_thread()
def download_step(self): self.logger.info("DOWNLOAD_DATA") sly.json_dump(self.info['config'], self.config_path) pr_info = self.info['project'] project = api_proto.Project(id=pr_info['id'], title=pr_info['title']) datasets = [ api_proto.Dataset(id=ds['id'], title=ds['title']) for ds in pr_info['datasets'] ] self.data_mgr.download_project(self.dir_data, project, datasets) if self.info.get('nn_model', None) is not None: nn_id = self.info['nn_model']['id'] nn_hash = self.info['nn_model']['hash'] self.logger.info('DOWNLOAD_NN', extra={ 'nn_id': nn_id, 'nn_hash': nn_hash }) self.data_mgr.download_nn(nn_id, nn_hash, self.dir_model) else: self.logger.info('Initializing task without source NN.') self.report_step_done(TaskStep.DOWNLOAD)
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 _convert_sample(self, sample_info): image_name = sample_info.image_name ext = sample_info.ia_data['image_ext'] src_image_path = join(self.dataset_dir, 'images', image_name + ext) sly.copy_file(src_image_path, sample_info.img_path) ann = self._get_ann(self.dataset_dir, image_name + ext) packed_ann = ann.pack() sly.json_dump(packed_ann, sample_info.ann_path)
def _convert_sample(self, sample_info, masks_map): image_name = sample_info.image_name src_image_path = sample_info.ia_data['image_orig_path'] src_image = np.array(Image.open(src_image_path)) image_size_wh = src_image.shape[:2][::-1] cv2.imwrite(sample_info.img_path, src_image[:, :, ::-1]) ann = self._get_ann(image_name, masks_map, image_size_wh) packed_ann = ann.pack() sly.json_dump(packed_ann, sample_info.ann_path)
def on_verify(self, jlog): download_images = jlog.get('output', {}).get('download_images', None) is_archive = jlog.get('output', {}).get('is_archive', None) if download_images is None or is_archive is None: raise ValueError('VERIFY_IS_NONE') sly.json_dump( { 'download_images': download_images, 'is_archive': is_archive }, self.verif_status_path) return {}
def _convert_sample(self, sample_info): log_dct = sample_info._asdict() # ok, it's documented # logger.trace('Will process sample.', extra=log_dct) sample_data = sample_info.ia_data sly.copy_file(sample_data['src_img_path'], sample_info.img_path) # img is ready ann = self._get_ann(sample_data['segm_path'], sample_data.get('inst_path'), log_dct) packed_ann = ann.pack() sly.json_dump(packed_ann, sample_info.ann_path) # ann is ready
def convert(self): in_datasets = self._find_in_datasets() # map input structure to output out_pr = sly.ProjectStructure(self.settings['res_names']['project']) for ds_name, ds_path in in_datasets: img_fnames = sly.ImportImgLister.list_images(ds_path) for name_with_ext in img_fnames: img_name, img_ext = osp.splitext(name_with_ext) src_img_path = osp.join(ds_path, name_with_ext) dt = { 'src_img_path': src_img_path, 'image_ext': img_ext, } out_pr.add_item(ds_name, img_name, dt) logger.info( 'Found source dataset with raw images: "{}", {} sample(s).'. format(ds_name, len(img_fnames))) out_pr_fs = sly.ProjectFS(self.out_dir, out_pr) out_pr_fs.make_dirs() res_meta = sly.ProjectMeta() # empty res_meta.to_dir(out_pr_fs.project_path) progress = sly.progress_counter_import(out_pr.name, out_pr.image_cnt) for sample_info in out_pr_fs: sample_data = sample_info.ia_data src_img_path = sample_data['src_img_path'] sly.copy_file(src_img_path, sample_info.img_path) # img is ready image = Image.open(sample_info.img_path) exif_data = pyexiv2.metadata.ImageMetadata(sample_info.img_path) exif_data.read() if exif_data.get_orientation() != 1: logger.debug('Image with flip/rot EXIF', extra={ 'orientation': exif_data.get_orientation(), 'image_path': sample_info.img_path }) image = sly.image_transpose_exif(image) image.save(sample_info.img_path) exif_data['Exif.Image.Orientation'] = pyexiv2.ExifTag( 'Exif.Image.Orientation', 1) exif_data.modified = True exif_data.write() imsize_wh = image.size ann = sly.Annotation.new_with_objects(imsize_wh, []) sly.json_dump(ann.pack(), sample_info.ann_path) # ann is ready progress.iter_done_report()
def _convert_sample(self, sample_info): sample_data = sample_info.ia_data try: ann = self._load_citysc_annotation(sample_data['orig_ann_path']) ann['tags'].append(sample_data['tag_name']) packed_ann = ann.pack() except Exception: raise AnnConvException() # ok, may continue work with another sample self.tags.add(sample_data['tag_name']) sly.json_dump(packed_ann, sample_info.ann_path) # ann is ready sly.copy_file(sample_data['orig_img_path'], sample_info.img_path) # img is ready
def dump_schemas(output_path): output_path = join(output_path, 'schemas') shutil.rmtree(output_path) layers_output_path = join(output_path, 'layers') sly.mkdir(layers_output_path) global_schema = {'definitions': deepcopy(Layer.base_params['definitions'])} global_schema['definitions']['layers'] = dict() global_schema['items'] = {'anyOf': []} #global_schema['items']['minItems'] = 1 #global_schema['items']['maxItems'] = 1 for action, cls in Layer.actions_mapping.items(): layer_schema = deepcopy(cls.params) sly.json_dump(layer_schema, join(layers_output_path, '%s.json' % (action)), indent=4) del layer_schema['definitions'] global_schema['definitions']['layers'][action] = layer_schema global_schema['items']['anyOf'].append({'$ref': '#/definitions/layers/%s' % action}) sly.json_dump(global_schema, join(output_path, 'schema.json'), indent=4)
def download_step(self): if self.info.get('nn_model', None) is None: self.logger.critical('TASK_NN_EMPTY') raise ValueError('TASK_NN_EMPTY') nn_id = self.info['nn_model']['id'] nn_hash = self.info['nn_model']['hash'] self.logger.info('DOWNLOAD_NN', extra={'nn_id': nn_id, 'nn_hash': nn_hash}) self.data_mgr.download_nn(nn_id, nn_hash, self.dir_model) self.logger.info("DOWNLOAD_DATA") sly.json_dump(self.info['config'], self.config_path) pr_info = self.info['project'] project = api_proto.Project(id=pr_info['id'], title=pr_info['title']) datasets = [api_proto.Dataset(id=ds['id'], title=ds['title']) for ds in pr_info['datasets']] self.data_mgr.download_project(self.dir_data, project, datasets) self.report_step_done(TaskStep.DOWNLOAD)
def download_step(self): if self.info.get('nn_model', None) is None: self.logger.critical('TASK_NN_EMPTY') raise ValueError('TASK_NN_EMPTY') nn_id = self.info['nn_model']['id'] nn_hash = self.info['nn_model']['hash'] self.logger.info('DOWNLOAD_NN', extra={ 'nn_id': nn_id, 'nn_hash': nn_hash }) self.data_mgr.download_nn(nn_id, nn_hash, self.dir_model) out_cfg = { **self.info, 'connection': { 'server_address': constants.SERVER_ADDRESS, 'token': constants.TOKEN, 'task_id': str(self.info['task_id']), }, } sly.json_dump(out_cfg, self.config_path) self.report_step_done(TaskStep.DOWNLOAD)
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.')
def init_additional(self): super().init_additional() sly.mkdir(self.dir_data) sly.mkdir(self.dir_results) sly.json_dump(self.info['graph'], self.graph_path)
def download_step(self): self.logger.info("DOWNLOAD_DATA") sly.json_dump(self.human_config, self.config_path) self.data_mgr.download_import_files(self.info['task_id'], self.dir_data) self.report_step_done(TaskStep.DOWNLOAD)
def save(self, config): sly.json_dump(config, self.train_config_fpath)
def main(): logger.info('Hello world.') # It isn't necessary, but let's suppose that our data will be stored as for Supervisely task: # input in '/sly_task_data/data` and results in '/sly_task_data/results'. # So TaskPaths provides the paths. task_paths = sly.TaskPaths() in_pr_dir = task_paths.project_dir # the paths includes project name in_pr_meta = sly.ProjectMeta.from_dir(in_pr_dir) # Now we've read meta of input project. logger.info('Input project meta: {} class(es).'.format( len(in_pr_meta.classes))) in_pr_fs = sly.ProjectFS.from_disk( *sly.ProjectFS.split_dir_project(in_pr_dir)) # Now we've read project structure. logger.info( 'Input project: "{}" contains {} dataset(s) and {} image(s).'.format( in_pr_fs.pr_structure.name, len(in_pr_fs.pr_structure.datasets), in_pr_fs.image_cnt)) # It's convenient to create output project structure and store source file paths in ia_data. out_pr_structure = sly.ProjectStructure( 'my_new_project') # rename project... just for fun for item_descr in in_pr_fs: # iterate over input project new_ia_data = { 'src_ann_path': item_descr.ann_path, 'src_img_path': item_descr.img_path, **item_descr.ia_data # contains 'image_ext' which is required to write images } out_pr_structure.add_item(item_descr.ds_name, item_descr.image_name, new_ia_data) # ProjectFS will provide out file paths out_pr_fs = sly.ProjectFS(task_paths.results_dir, out_pr_structure) # We will add the rectangle to each annotation. new_class_title = 'new-region' rect_to_add = sly.Rect(left=20, top=20, right=50, bottom=100) # Ok, start processing. out_pr_fs.make_dirs() # create all directories required for writing for item_descr in out_pr_fs: # iterate over output project logger.info('Processing sample', extra={ 'dataset': item_descr.ds_name, 'image_name': item_descr.image_name }) # Copy image unchanged. sly.copy_file(item_descr.ia_data['src_img_path'], item_descr.img_path) # Read annotation. ann_packed = sly.json_load(item_descr.ia_data['src_ann_path']) ann = sly.Annotation.from_packed(ann_packed, in_pr_meta) # Add new figure to the annotation. # Method to construct figures returns iterable of new figures. # (e.g., line cropped with image bounds may produce some lines), but here we'll get not more than one figure # ...or no figures if image is less than 20x20. new_figures = sly.FigureRectangle.from_rect(new_class_title, ann.image_size_wh, rect_to_add) ann['objects'].extend(new_figures) # Save annotation. sly.json_dump(ann.pack(), item_descr.ann_path) # OK, and don't forget to create and save output project meta. # We'll save given data and add new class with shape "rectangle". out_pr_meta = deepcopy(in_pr_meta) out_pr_meta.classes.add({ 'title': new_class_title, 'shape': 'rectangle', 'color': '#FFFF00' }) # Then store the meta. out_pr_meta.to_dir(out_pr_fs.project_path) logger.info('Done.')
def download_step(self): self.logger.info("DOWNLOAD_DATA") sly.json_dump(self.human_config, self.config_path) copy_tree(constants.AGENT_IMPORT_DIR, self.dir_data) self.report_step_done(TaskStep.DOWNLOAD)