settings['res_names']['project']), sly.OpenMode.CREATE)
src_datasets = read_datasets(inst_dir)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name) #make train -> img, ann
progress = sly.Progress('Dataset: {!r}'.format(ds_name),
len(sample_names)) # for logger
imgs_dir_new = os.path.join(imgs_dir, ds_name)
inst_dir_new = os.path.join(inst_dir, ds_name)
for name in sample_names:
src_img_path = os.path.join(imgs_dir_new, name + '.jpg')
inst_path = os.path.join(inst_dir_new, name + '.png')
if all((os.path.isfile(x) or (x is None)
for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path, number_class,
pixel_color)
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('sceneparsing', main)
rimg_infos = []
for img_path, meta_json, hash in related_items:
rimg_infos.append({ApiField.ENTITY_ID: item_info.id,
ApiField.NAME: meta_json.get(ApiField.NAME, sly.fs.get_file_name_with_ext(img_path)),
ApiField.HASH: hash,
ApiField.META: meta_json.get(ApiField.META, {}) })
api.pointcloud.add_related_images(rimg_infos)
sly.fs.remove_dir(temp_dir)
pass
if project_info is not None:
sly.logger.info('PROJECT_CREATED', extra={'event_type': sly.EventType.PROJECT_CREATED, 'project_id': project_info.id})
else:
temp_str = "Project"
if append_to_existing_project is True:
temp_str = "Dataset"
raise RuntimeError("{} wasn't created: 0 files with supported formats were found. Supported formats: {!r}"
.format(temp_str, ALLOWED_POINTCLOUD_EXTENSIONS))
pass
def main():
add_pointclouds_to_project()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('POINTCLOUD_RAW_IMPORT', main)
init_fn = slim.assign_from_checkpoint_fn(
join(self.helper.paths.model_dir, 'model_weights',
'model.ckpt'),
variables_to_restore,
ignore_missing_vars=ignore_missing_vars)
init_fn(sess)
input_shape_hw = (self.input_size_wh[1], self.input_size_wh[0])
train(data_dicts=self.tf_data_dicts,
class_num=len(self.out_classes),
input_size=input_shape_hw,
lr=self.config['lr'],
n_epochs=self.config['epochs'],
num_clones=len(device_ids),
iters_cnt=self.iters_cnt,
val_every=self.config['val_every'],
model_init_fn=init_model_fn,
save_cback=dump_model)
def main():
cv2.setNumThreads(0)
x = DeepLabTrainer()
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly.add_default_logging_into_file(logger, sly.TaskPaths().debug_dir)
sly.main_wrapper('DEEPLAB_TRAIN', main)
res_meta = sly.ProjectMeta()
for class_name in self.classes:
res_meta.classes.add({
'title': class_name,
'shape': 'polygon',
'color': sly.gen_new_color()
})
res_meta.img_tags.update(self.tags)
res_meta.to_dir(out_pr_fs.project_path)
logger.info('Found classes.',
extra={
'cnt': len(self.classes),
'classes': sorted(list(self.classes))
})
logger.info('Created tags.',
extra={
'cnt': len(self.tags),
'tags': sorted(list(self.tags))
})
def main():
importer = ImporterCityscapes()
importer.convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('CITYSCAPES_IMPORT', main)
progress = sly.Progress('Creating users...', len(new_users), app_logger)
for user, user_data in new_users.items():
api.user.create(login=user_data[LOGIN_COL_NAME],
password=user_data[PASSWORD_COL_NAME],
is_restricted=False)
app_logger.info("User {!r} is created".format(
user_data[LOGIN_COL_NAME]))
progress.iter_done_report()
sly.fs.silent_remove(local_csv_path)
my_app.stop()
def main():
sly.logger.info("Script arguments",
extra={
"TEAM_ID": TEAM_ID,
"WORKSPACE_ID": WORKSPACE_ID,
"INPUT_FILE": INPUT_FILE
})
# Run application service
my_app.run(initial_events=[{"command": "create_user_from_csv"}])
if __name__ == "__main__":
sly.main_wrapper("main", main)
5: (255, 0, 0),
6: (0, 0, 255),
7: (127, 0, 217),
8: (248, 248, 248)
}
src_datasets = read_datasets(all_ann)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name)
progress = sly.Progress('Dataset: {!r}'.format(ds_name),
len(sample_names)) # for logger
for name in sample_names:
src_img_path = os.path.join(all_img, name + '.png')
inst_path = os.path.join(all_ann, name + '_mask' + '.png')
if all((os.path.isfile(x) or (x is None)
for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path, number_class,
pixel_color)
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('PennFudan', main)
'AGENT_HOST_DIR',
'SERVER_ADDRESS',
'ACCESS_TOKEN',
'DOCKER_LOGIN',
'DOCKER_PASSWORD',
'DOCKER_REGISTRY',
]}
args_opt = {x: os.getenv(x, def_val) for x, def_val in [
('WITH_LOCAL_STORAGE', 'true'),
('UPLOAD_RESULT_IMAGES', 'false'),
('PULL_ALWAYS', 'true'),
('DEFAULT_TIMEOUTS', 'true'),
('DELETE_TASK_DIR_ON_FINISH', 'true'),
('DELETE_TASK_DIR_ON_FAILURE', 'false'),
('CHECK_VERSION_COMPATIBILITY', 'false')
]}
args = {**args_opt, **args_req}
return args
def main(args):
sly.logger.info('ENVS', extra={**args, 'DOCKER_PASSWORD': '******'})
agent = Agent()
agent.inf_loop()
agent.wait_all()
if __name__ == '__main__':
sly.add_default_logging_into_file(sly.logger, constants.AGENT_LOG_DIR())
sly.main_wrapper('agent', main, parse_envs())
progress_dummy.iter_done_report()
def dump_model(saver, sess, is_best, opt_data):
self.saver = saver
self.sess = sess
self._save_model_snapshot(is_best, opt_data)
train(self.tf_data_dicts,
self.config['epochs'],
self.config['val_every'],
self.iters_cnt,
self.config['validate_with_model_eval'],
pipeline_config=self.tf_config,
num_clones=len(device_ids),
save_cback=dump_model,
is_transfer_learning=(
self.config['weights_init_type'] == 'transfer_learning'))
def main():
cv2.setNumThreads(0)
x = ObjectDetectionTrainer() # load model & prepare all
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly_logger.add_default_logging_into_file(logger,
sly.TaskPaths.DEBUG_DIR)
sly.main_wrapper('TF_OBJECT_DETECTION_TRAIN', main)
'connection': {
'server_address': None,
'token': None,
'task_id': None,
},
}
new_settings = sly.json_load(sly.TaskPaths(determine_in_project=False).settings_path)
logger.info('Input settings', extra={'settings': new_settings})
sly.update_recursively(settings, new_settings)
logger.info('Full settings', extra={'settings': settings})
def model_creator():
res = UnetV2FastApplier(settings={
'device_id': settings['device_id']
})
return res
image_cache = SimpleCache(settings['cache_limit'])
serv_instance = AgentRPCServicer(logger=logger,
model_creator=model_creator,
apply_cback=single_img_pipeline,
conn_settings=settings['connection'],
cache=image_cache)
serv_instance.run_inf_loop()
if __name__ == '__main__':
cv2.setNumThreads(0)
sly.main_wrapper('UNET_V2_SERVICE', serve)
exc_str),
exc_info=True,
extra={
'exc_str': exc_str,
'dataset_name': ds_name,
'image': src_img_path,
})
else:
sly.logger.warning(
"Processing '{}' skipped because no corresponding mask found."
.format(src_img_filename))
progress.iter_done_report()
sly.logger.info(
'Dataset "{}" samples processing is done.'.format(ds_name),
extra={})
out_meta = sly.ProjectMeta(obj_classes=self.obj_classes)
out_project.set_meta(out_meta)
sly.logger.info('Pascal VOC samples processing is done.', extra={})
def main():
importer = ImporterPascalVOCSegm()
importer.convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('PASCAL_VOC_IMPORT', main)
c_boxes,
data_dict['sample_cnt'],
vc_img_paths,
vc_num_gt_boxes,
vc_boxes,
vdata_dict['sample_cnt'],
int1D_to_p_int(device_ids),
len(device_ids),
self.config['data_workers']['train'],
self.config['epochs'],
train_steps,
self.config.get('checkpoint_every', 1),
self.layer_cutoff,
1 if self.config['enable_augmentations'] else 0, # with aug
int(self.config['print_every_iter']),
float(self.config['bn_momentum'])
)
def main():
x = YOLOTrainer()
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly_logger.add_default_logging_into_file(logger, sly.TaskPaths.DEBUG_DIR)
sly.main_wrapper('YOLO_V3_TRAIN', main)
imgs_dir = os.path.join(sly.TaskPaths.DATA_DIR, 'JPEGImages')
inst_dir_trainval = os.path.join(sly.TaskPaths.DATA_DIR, 'trainval')
labels_file_path = os.path.join(sly.TaskPaths.DATA_DIR, 'labels.txt')
number_class, pixel_color = read_colors(labels_file_path)
out_project = sly.Project(os.path.join(sly.TaskPaths.RESULTS_DIR, settings['res_names']['project']), sly.OpenMode.CREATE)
src_datasets = read_datasets(inst_dir_trainval)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name) #make train -> img, ann
progress = sly.Progress('Dataset: {!r}'.format(ds_name), len(sample_names)) # for logger
for name in sample_names:
src_img_path = os.path.join(imgs_dir, name + '.jpg')
inst_path = os.path.join(inst_dir_trainval, name + '.mat')
if all((os.path.isfile(x) or (x is None) for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path, number_class, pixel_color)
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('PASCAL_CONTEXT_IMPORT', main)
if len(related_items) != 0:
rimg_infos = []
for img_path, meta_json in related_items:
rimg_infos.append({
ApiField.ENTITY_ID:
pointcloud.id,
ApiField.NAME:
meta_json[ApiField.NAME],
ApiField.HASH:
path_info_map[img_path][ApiField.HASH],
ApiField.META:
meta_json[ApiField.META],
})
api.pointcloud.add_related_images(rimg_infos)
sly.logger.info('PROJECT_CREATED',
extra={
'event_type': sly.EventType.PROJECT_CREATED,
'project_id': project.id
})
pass
def main():
add_pointclouds_to_project()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('POINTCLOUD_SLY_IMPORT', main)
'connection': {
'server_address': None,
'token': None,
'task_id': None,
},
}
new_settings = sly.json_load(sly.TaskPaths(determine_in_project=False).settings_path)
logger.info('Input settings', extra={'settings': new_settings})
sly.update_recursively(settings, new_settings)
logger.info('Full settings', extra={'settings': settings})
def model_creator():
res = DeeplabFastApplier(settings={
'device_id': settings['device_id'],
})
return res
image_cache = SimpleCache(settings['cache_limit'])
serv_instance = AgentRPCServicer(logger=logger,
model_creator=model_creator,
apply_cback=single_img_pipeline,
conn_settings=settings['connection'],
cache=image_cache)
serv_instance.run_inf_loop()
if __name__ == '__main__':
cv2.setNumThreads(0)
sly.main_wrapper('DEEPLAB_SERVICE', serve)
full_mask_fp = join(ann_dir, mask_name)
labels = read_mask_labels(full_mask_fp, classes_mapping,
obj_class_collection)
ann = ann.add_labels(labels)
ds.add_item_file(image_name, full_img_fp, ann=ann)
except Exception as e:
exc_str = str(e)
sly.logger.warn(
'Input sample skipped due to error: {}'.format(exc_str),
exc_info=True,
extra={
'exc_str': exc_str,
'image': full_img_fp
})
progress.iter_done_report()
if len(masks_map) > 0:
masks_list = list(masks_map.values())
sly.logger.warning(
'Images for masks doesn\'t exist. Masks: {}'.format(masks_list))
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('BINARY_MASKS_IMPORT', main)
def dump_model(saver, sess, is_best, opt_data):
out_dir = self.helper.checkpoints_saver.get_dir_to_write()
TrainConfigRW(out_dir).save(self.out_config)
save_config(osp.join(out_dir, 'model.config'), self.tf_config)
model_fpath = os.path.join(out_dir, 'model_weights', 'model.ckpt')
saver.save(sess, model_fpath)
self.helper.checkpoints_saver.saved(is_best, opt_data)
train(self.tf_data_dicts,
self.config['epochs'],
self.config['val_every'],
self.iters_cnt,
self.config['validate_with_model_eval'],
pipeline_config=self.tf_config,
num_clones=len(device_ids),
save_cback=dump_model)
def main():
cv2.setNumThreads(0)
x = SSDTrainer() # load model & prepare all
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly.add_default_logging_into_file(logger, sly.TaskPaths().debug_dir)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
sly.main_wrapper('SSD_TRAIN', main)
import os
import supervisely_lib as sly
from supervisely_lib.metric.precision_recall_metric import PrecisionRecallMetric
from supervisely_lib.metric.iou_metric import IOU
from supervisely_lib.metric.common import check_class_mapping, CLASSES_MAPPING
from supervisely_lib.io.json import load_json_file
def main():
settings = load_json_file(sly.TaskPaths.SETTINGS_PATH)
sly.logger.info('Input settings:', extra={'config': settings})
if IOU not in settings:
raise RuntimeError(
'"{}" field is missing. Please set Intersection over Union threshold'
.format(IOU))
metric = PrecisionRecallMetric(settings[CLASSES_MAPPING], settings[IOU])
applier = sly.MetricProjectsApplier(metric, settings)
check_class_mapping(applier.project_gt, applier.project_pred,
settings[CLASSES_MAPPING])
applier.run_evaluation()
metric.log_total_metrics()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly.add_default_logging_into_file(sly.logger, sly.TaskPaths.DEBUG_DIR)
sly.main_wrapper('METRIC_EVALUATION', main)
sly.fs.silent_remove(path)
#sly.fs.clean_dir(sly.TaskPaths.RESULTS_DIR)
progress.iters_done_report(len(batch_names))
else:
api.image.upload_hashes(ds_info.id,
batch_names,
batch_hashes,
progress_cb=progress.iters_done_report)
if project_info is not None:
sly.logger.info('PROJECT_CREATED',
extra={
'event_type': sly.EventType.PROJECT_CREATED,
'project_id': project_info.id
})
else:
temp_str = "Project"
if append_to_existing_project is True:
temp_str = "Dataset"
raise RuntimeError("{} wasn't created: 0 files were added")
pass
def main():
add_images_to_project()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('IMPORT_IMAGES', main)
val_loss = metrics_values_val['loss']
model_is_best = val_loss < best_val_loss
if model_is_best:
best_val_loss = val_loss
sly.logger.info(
'It\'s been determined that current model is the best one for a while.'
)
self._save_model_snapshot(model_is_best,
opt_data={
'epoch':
self.epoch_flt,
'val_metrics':
metrics_values_val,
})
policy.reset_if_needed(val_loss, self.model)
sly.logger.info("Epoch was finished",
extra={'epoch': self.epoch_flt})
def main():
cv2.setNumThreads(0) # important for pytorch dataloaders
x = UnetV2Trainer() # load model & prepare all
x.train()
if __name__ == '__main__':
sly.main_wrapper('UNET_V2_TRAIN', main)
'link': line,
})
progress.iter_done_report()
def main():
global server_address, task_context, append_to_existing_project
with open('/sly_task_data/task_settings.json') as json_file:
task_settings = json.load(json_file)
server_address = task_settings['server_address']
headers['x-api-key'] = task_settings['api_token']
task_context = get_task_context(task_settings['task_id'])
append_to_existing_project = task_settings['append_to_existing_project']
project_id = create_project_api(task_settings['res_names']['project'])
data_dir = "/sly_task_data/data"
files = [f for f in os.listdir(data_dir) if f.endswith('.txt')]
for file in files:
file_path = os.path.join(data_dir, file)
process_dataset_links(project_id, file_path)
with open('/sly_task_data/results/project_info.json', 'w') as outfile:
json.dump({'project_id': project_id}, outfile)
if __name__ == '__main__':
sly.main_wrapper('IMAGES_ONLY_IMPORT', main)
# coding: utf-8
import cv2
import supervisely_lib as sly
from supervisely_lib.nn.hosted.deploy import ModelDeploy
from inference import DeeplabSingleImageApplier
def main():
model_deploy = ModelDeploy(model_applier_cls=DeeplabSingleImageApplier)
model_deploy.run()
if __name__ == '__main__':
cv2.setNumThreads(0)
sly.main_wrapper('DEEPLAB_SERVICE', main)
task_settings = json.load(open(sly.TaskPaths.SETTINGS_PATH, 'r'))
try:
project = sly.Project(sly.TaskPaths.DATA_DIR, sly.OpenMode.READ)
except FileNotFoundError:
possible_projects = sly.fs.get_subdirs(sly.TaskPaths.DATA_DIR)
if len(possible_projects) != 1:
raise RuntimeError(
'Wrong input project structure, or multiple projects are passed.'
)
project = sly.Project(
os.path.join(sly.TaskPaths.DATA_DIR, possible_projects[0]),
sly.OpenMode.READ)
except Exception as e:
raise e
sly.logger.info('Project info: {} dataset(s), {} images(s).'.format(
len(project.datasets), project.total_items))
project.validate()
project.copy_data(sly.TaskPaths.RESULTS_DIR,
task_settings['res_names']['project'])
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('SLY_FORMAT_IMPORT', main)
'image_name': dicom_filename,
})
skipped_count += 1
dataset_progress.iter_done_report()
sly.logger.info('Processed.',
extra={
'samples': samples_count,
'skipped': skipped_count
})
if out_project.total_items == 0:
raise RuntimeError(
'Result project is empty! All input DICOM files have unreadable format!'
)
out_meta = sly.ProjectMeta(tag_metas=tag_metas)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
#@TODO: for debug
#sly.fs.clean_dir(sly.TaskPaths.RESULTS_DIR)
sly.main_wrapper('DICOM_TO_IMAGES_IMPORT', main)
_ = api.video.upload_hash(ds_info.id, item_name, hash,
stream_index)
except Exception as e:
sly.logger.warning(
"File skipped {!r}: error occurred during processing {!r}".
format(original_path, str(e)))
if project_info is not None:
sly.logger.info('PROJECT_CREATED',
extra={
'event_type': sly.EventType.PROJECT_CREATED,
'project_id': project_info.id
})
else:
temp_str = "Project"
if append_to_existing_project is True:
temp_str = "Dataset"
raise RuntimeError(
"{} wasn't created: 0 files with supported codecs ({}) and containers ({}). It is a limitation for Community Edition (CE)."
.format(temp_str, _SUPPORTED_CODECS, _SUPPORTED_CONTAINERS))
pass
def main():
add_videos_to_project()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('VIDEO_ONLY_IMPORT', main)
def dump_model(saver, sess, is_best, opt_data):
out_dir = self.helper.checkpoints_saver.get_dir_to_write()
TrainConfigRW(out_dir).save(self.out_config)
save_config(osp.join(out_dir, 'model.config'), self.tf_config)
model_fpath = os.path.join(out_dir, 'model_weights', 'model.ckpt')
saver.save(sess, model_fpath)
self.helper.checkpoints_saver.saved(is_best, opt_data)
train(self.tf_data_dicts,
self.config['epochs'],
self.config['val_every'],
self.iters_cnt,
self.config['validate_with_model_eval'],
pipeline_config=self.tf_config,
num_clones=len(device_ids),
save_cback=dump_model)
def main():
cv2.setNumThreads(0)
x = MaskRCNNTrainer() # load model & prepare all
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly.add_default_logging_into_file(logger, sly.TaskPaths().debug_dir)
sly.main_wrapper('MASK_RCNN_TRAIN', main)
settings['res_names']['project']), sly.OpenMode.CREATE)
src_datasets = read_datasets(inst_dir)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name) #make train -> img, ann
progress = sly.Progress('Dataset: {!r}'.format(ds_name),
len(sample_names)) # for logger
imgs_dir_new = os.path.join(imgs_dir, ds_name)
inst_dir_new = os.path.join(inst_dir, ds_name)
for name in sample_names:
src_img_path = os.path.join(imgs_dir_new, name + '.jpg')
inst_path = os.path.join(inst_dir_new, name + '.png')
if all((os.path.isfile(x) or (x is None)
for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path, number_class,
pixel_color)
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('COCO_stuff', main)
img_name = name + '.jpg'
src_img_path = os.path.join(self._imgs_dir(ds_name), img_name)
inst_path = os.path.join(self._inst_dir(ds_name), name + '.png')
try:
ann = self._generate_annotation(src_img_path, inst_path)
ds.add_item_file(img_name, src_img_path, ann=ann)
except Exception as e:
exc_str = str(e)
sly.logger.warn('Input sample skipped due to error: {}'.format(exc_str), exc_info=True, extra={
'exc_str': exc_str,
'dataset_name': ds_name,
'image': src_img_path,
})
progress.iter_done_report()
sly.logger.info("Dataset '{}' samples processing is done.".format(ds_name), extra={})
out_meta = sly.ProjectMeta(obj_classes=sly.ObjClassCollection(self._class_id_to_object_class.values()))
out_project.set_meta(out_meta)
sly.logger.info("Mapillary samples processing is done.", extra={})
def main():
importer = ImporterMapillary()
importer.convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('MAPILLARY_IMPORT', main)
settings = load_json_file(sly.TaskPaths.TASK_CONFIG_PATH)
lists_dir = os.path.join(sly.TaskPaths.DATA_DIR, 'DAVIS/ImageSets')
imgs_dir = os.path.join(sly.TaskPaths.DATA_DIR, 'DAVIS/JPEGImages')
inst_dir = os.path.join(sly.TaskPaths.DATA_DIR, 'DAVIS/Annotations')
src_datasets = read_datasets(lists_dir)
out_project = sly.Project(os.path.join(sly.TaskPaths.RESULTS_DIR, settings['res_names']['project']),
sly.OpenMode.CREATE)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name) #make train -> img, ann
progress = sly.Progress('Dataset: {!r}'.format(ds_name), len(sample_names)) # for logger
for name in sample_names:
src_img_path = os.path.join(imgs_dir, name + '.jpg')
inst_path = os.path.join(inst_dir, name + '.png')
if all((os.path.isfile(x) or (x is None) for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path)
name = name.replace('/', '_')
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('DAVIS_2016', main)
sly.TaskPaths.DATA_DIR,
'graz50_facade_dataset/graz50_facade_dataset/labels_full')
out_project = sly.Project(
os.path.join(sly.TaskPaths.RESULTS_DIR,
settings['res_names']['project']), sly.OpenMode.CREATE)
src_datasets = read_datasets(all_ann)
for ds_name, sample_names in src_datasets.items():
ds = out_project.create_dataset(ds_name) #make train -> img, ann
progress = sly.Progress('Dataset: {!r}'.format(ds_name),
len(sample_names)) # for logger
for name in sample_names:
src_img_path = os.path.join(all_img, name + '.png')
inst_path = os.path.join(all_ann, name + '.png')
if all((os.path.isfile(x) or (x is None)
for x in [src_img_path, inst_path])):
ann = get_ann(src_img_path, inst_path, default_classes_colors)
ds.add_item_file(name, src_img_path, ann=ann)
progress.iter_done_report()
out_meta = sly.ProjectMeta(obj_classes=classes_dict)
out_project.set_meta(out_meta)
def main():
convert()
sly.report_import_finished()
if __name__ == '__main__':
sly.main_wrapper('ParisArt', main)
samples=samples_lst,
class_mapping=self.class_title_to_idx)
self.datasets[the_name] = the_ds
logger.info('Prepared dataset.',
extra={
'dataset_purpose': the_name,
'dataset_tag': the_tag,
'sample_cnt': len(samples_lst)
})
def train(self):
self.model.train(self.datasets['train'],
self.datasets['val'],
learning_rate=self.mask_rcnn_config.LEARNING_RATE,
epochs=self.config['epochs'],
layers=self.config['train_layers'],
out_config=self.out_config,
sly_checkpoints_saver=self.checkpoints_saver)
def main():
x = MaskRCNNTrainer() # load model & prepare all
x.train()
if __name__ == '__main__':
if os.getenv('DEBUG_LOG_TO_FILE', None):
sly.sly_logger.add_default_logging_into_file(logger,
sly.TaskPaths.DEBUG_DIR)
sly.main_wrapper('MASK_RCNN_MATTERPORT_TRAIN', main)
