rename nb_jobs -> nb_workers

README.md

@@ -127,7 +127,7 @@ We introduce some useful tools for work with image annotation and segmentation.
     ```bash
     python handling_annotations/run_image_color_quantization.py \
         -imgs "./data_images/drosophila_ovary_slice/segm_rgb/*.png" \
-        -m position -thr 0.01 --nb_jobs 2
+        -m position -thr 0.01 --nb_workers 2
     ```
 * **Paint labels:** concerting image labels into colour space and other way around.
     ```bash
@@ -174,14 +174,14 @@ We utilize (un)supervised segmentation according to given training examples or s
     python experiments_segmentation/run_segm_slic_model_graphcut.py \
        -l ./data_images/langerhans_islets/list_lang-isl_imgs-annot.csv -i "" \
        --cdf experiments_segmentation/sample_config.json \
-       -o ./results -n langIsl --nb_classes 3 --visual --nb_jobs 2
+       -o ./results -n langIsl --nb_classes 3 --visual --nb_workers 2
     ```
     OR specified on particular path:
     ```bash
     python experiments_segmentation/run_segm_slic_model_graphcut.py \
        -l "" -i "./data_images/langerhans_islets/image/*.jpg" \
        -cfg ./experiments_segmentation/sample_config.json \
-       -o ./results -n langIsl --nb_classes 3 --visual --nb_jobs 2
+       -o ./results -n langIsl --nb_classes 3 --visual --nb_workers 2
     ```
     ![unsupervised](figures/imag-disk-20_gmm.jpg)
 * Perform **Supervised** segmentation with afterwards evaluation.
@@ -190,7 +190,7 @@ We utilize (un)supervised segmentation according to given training examples or s
         -l ./data_images/drosophila_ovary_slice/list_imgs-annot-struct.csv \
         -i "./data_images/drosophila_ovary_slice/image/*.jpg" \
         --path_config ./experiments_segmentation/sample_config.json \
-        -o ./results -n Ovary --img_type 2d_split --visual --nb_jobs 2
+        -o ./results -n Ovary --img_type 2d_split --visual --nb_workers 2
     ```
     ![supervised](figures/imag-disk-20_train.jpg)
 * For both experiment you can evaluate segmentation results.
@@ -301,7 +301,7 @@ pip install --user git+https://github.com/Borda/morph-snakes.git
     ```bash
     python experiments_ovary_detect/run_ovary_egg-segmentation.py  \
         -list ./data_images/drosophila_ovary_slice/list_imgs-segm-center-points.csv \
-        -out ./results -n ovary_image --nb_jobs 1 \
+        -out ./results -n ovary_image --nb_workers 1 \
         -m ellipse_moments \
            ellipse_ransac_mmt \
            ellipse_ransac_crit \

circle.yml

@@ -61,7 +61,7 @@ jobs:
 
   Py3:
       docker:
-        - image: circleci/python:3.5
+        - image: circleci/python:3.6
       steps: *steps
 
 workflows:

experiments_ovary_centres/run_center_candidate_training.py

@@ -148,7 +148,7 @@ def arg_parse_params(params):
                         help='name of the experiment', default='ovary')
     parser.add_argument('-cfg', '--path_config', type=str, required=False,
                         help='path to the configuration', default=None)
-    parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
+    parser.add_argument('--nb_workers', type=int, required=False, default=NB_THREADS,
                         help='number of processes in parallel')
     params.update(vars(parser.parse_args()))
     paths = {}
@@ -443,13 +443,13 @@ def wrapper_draw_export_slic_centers(args):
     return export_show_image_points_labels(*args)
 
 
-def dataset_load_images_segms_compute_features(params, df_paths, nb_jobs=NB_THREADS):
+def dataset_load_images_segms_compute_features(params, df_paths, nb_workers=NB_THREADS):
     """ create whole dataset composed from loading input data, computing features
     and label points by label whether its positive or negative center candidate
 
     :param {str: any} params: parameters
     :param DF df_paths: DataFrame
-    :param int nb_jobs: parallel
+    :param int nb_workers: parallel
     :return {str: ...}:
     """
     dict_imgs, dict_segms, dict_center = dict(), dict(), dict()
@@ -458,7 +458,7 @@ def dataset_load_images_segms_compute_features(params, df_paths, nb_jobs=NB_THRE
     _wrapper_load = partial(load_image_segm_center, path_out=path_show_in,
                             dict_relabel=params['dict_relabel'])
     iterate = tl_expt.WrapExecuteSequence(_wrapper_load, df_paths.iterrows(),
-                                          nb_jobs=nb_jobs,
+                                          nb_workers=nb_workers,
                                           desc='loading input data')
     for name, img, seg, center in iterate:
         dict_imgs[name] = img
@@ -473,7 +473,7 @@ def dataset_load_images_segms_compute_features(params, df_paths, nb_jobs=NB_THRE
                                     params=params)
     feature_names = None
     iterate = tl_expt.WrapExecuteSequence(_wrapper_pnt_features,
-                                          gene_name_img_seg, nb_jobs=nb_jobs,
+                                          gene_name_img_seg, nb_workers=nb_workers,
                                           desc='estimate candidates & features')
     for name, slic, points, features, feature_names in iterate:
         dict_slics[name] = slic
@@ -499,7 +499,7 @@ def dataset_load_images_segms_compute_features(params, df_paths, nb_jobs=NB_THRE
 
 
 def export_dataset_visual(path_output, dict_imgs, dict_segms, dict_slics,
-                          dict_points, dict_labels, nb_jobs=NB_THREADS):
+                          dict_points, dict_labels, nb_workers=NB_THREADS):
     """ visualise complete training dataset by marking labeld points
     over image and input segmentation
 
@@ -508,7 +508,7 @@ def export_dataset_visual(path_output, dict_imgs, dict_segms, dict_slics,
     :param {str: ndarray} dict_slics:
     :param {str: ndarray} dict_points:
     :param {str: ndarray} dict_labels:
-    :param int nb_jobs: number processing in parallel
+    :param int nb_workers: number processing in parallel
     """
     logging.info('export training visualisations')
 
@@ -517,7 +517,7 @@ def export_dataset_visual(path_output, dict_imgs, dict_segms, dict_slics,
                    dict_points[name], dict_labels[name], dict_slics[name],
                    None, '_train') for name in dict_imgs)
     iterate = tl_expt.WrapExecuteSequence(wrapper_draw_export_slic_centers,
-                                          gener_args, nb_jobs=nb_jobs,
+                                          gener_args, nb_workers=nb_workers,
                                           desc='exporting visualisations')
     list(iterate)
 
@@ -653,7 +653,7 @@ def experiment_loo(classif, dict_imgs, dict_segms, dict_centers, dict_slics,
                                  path_output=params['path_expt'])
     df_stat = pd.DataFrame()
     iterate = tl_expt.WrapExecuteSequence(_wrapper_detection,
-                                          gener_data, nb_jobs=params['nb_jobs'],
+                                          gener_data, nb_workers=params['nb_workers'],
                                           desc='detect center candidates')
     for dict_stat in iterate:
         df_stat = df_stat.append(dict_stat, ignore_index=True)
@@ -718,7 +718,7 @@ def main_train(params):
     if not os.path.isfile(path_dump_data) or FORCE_RECOMP_DATA:
         (dict_imgs, dict_segms, dict_slics, dict_points, dict_centers,
          dict_features, dict_labels, feature_names) = \
-            dataset_load_images_segms_compute_features(params, df_paths, params['nb_jobs'])
+            dataset_load_images_segms_compute_features(params, df_paths, params['nb_workers'])
         assert len(dict_imgs) > 0, 'missing images'
         save_dump_data(path_dump_data, dict_imgs, dict_segms, dict_slics, dict_points,
                        dict_centers, dict_features, dict_labels, feature_names)
@@ -728,7 +728,7 @@ def main_train(params):
 
     if is_drawing(params['path_expt']) and EXPORT_TRAINING_DATA:
         export_dataset_visual(params['path_expt'], dict_imgs, dict_segms, dict_slics,
-                              dict_points, dict_labels, params['nb_jobs'])
+                              dict_points, dict_labels, params['nb_workers'])
 
     # concentrate features, labels
     features, labels, sizes = seg_clf.convert_set_features_labels_2_dataset(
@@ -746,7 +746,7 @@ def main_train(params):
     classif, params['path_classif'] = seg_clf.create_classif_search_train_export(
         params['classif'], features, labels, cross_val=cv, params=params,
         feature_names=feature_names, nb_search_iter=params['nb_classif_search'],
-        pca_coef=params.get('pca_coef', None), nb_jobs=params['nb_jobs'],
+        pca_coef=params.get('pca_coef', None), nb_workers=params['nb_workers'],
         path_out=params['path_expt'])
     nb_holdout = int(np.ceil(len(sizes) * CROSS_VAL_LEAVE_OUT_EVAL))
     cv = seg_clf.CrossValidateGroups(sizes, nb_holdout)

experiments_ovary_centres/run_center_clustering.py

@@ -213,7 +213,7 @@ def main(params):
                                   path_out=params['path_expt'])
     rows = (dict(row) for idx, row in df_paths.iterrows())
     iterate = tl_expt.WrapExecuteSequence(_wrapper_clustering, rows,
-                                          nb_jobs=params['nb_jobs'])
+                                          nb_workers=params['nb_workers'])
     for dict_center in iterate:
         df_paths_new = df_paths_new.append(dict_center, ignore_index=True)
 

experiments_ovary_centres/run_center_evaluation.py

@@ -183,14 +183,14 @@ def load_center_evaluate(idx_row, df_annot, path_annot, path_visu=None,
     return dict_stat
 
 
-def evaluate_detection_stage(df_paths, stage, path_info, path_out, nb_jobs=1):
+def evaluate_detection_stage(df_paths, stage, path_info, path_out, nb_workers=1):
     """ evaluate center detection for particular list of stages
 
     :param df_paths:
     :param [int] stage:
     :param str path_info:
     :param str path_out:
-    :param int nb_jobs:
+    :param int nb_workers:
     :return DF:
     """
     logging.info('evaluate stages: %r', stage)
@@ -226,7 +226,7 @@ def evaluate_detection_stage(df_paths, stage, path_info, path_out, nb_jobs=1):
                                  col_prefix=stage_prefix)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_detection,
                                           df_paths.iterrows(),
-                                          nb_jobs=nb_jobs)
+                                          nb_workers=nb_workers)
     for dict_eval in iterate:
         df_eval = df_eval.append(dict_eval, ignore_index=True)
         df_eval.to_csv(os.path.join(path_out, NAME_CSV_TRIPLES_TEMP))
@@ -256,7 +256,7 @@ def main(params):
         df_eval = evaluate_detection_stage(df_eval, stage,
                                            params['path_infofile'],
                                            params['path_expt'],
-                                           params['nb_jobs'])
+                                           params['nb_workers'])
         if not df_eval.empty and 'image' in df_eval.columns:
             df_eval.set_index('image', inplace=True)
         df_eval.to_csv(os.path.join(params['path_expt'], NAME_CSV_TRIPLES_STAT))

experiments_ovary_centres/run_center_prediction.py

@@ -158,7 +158,7 @@ def main(params):
                                  path_classif=params['path_classif'],
                                  path_output=params['path_expt'])
     iterate = tl_expt.WrapExecuteSequence(_wrapper_detection, df_paths.iterrows(),
-                                          nb_jobs=params['nb_jobs'])
+                                          nb_workers=params['nb_workers'])
     for dict_center in iterate:
         df_stat = df_stat.append(dict_center, ignore_index=True)
         df_stat.to_csv(os.path.join(params['path_expt'], NAME_CSV_TRIPLES_TEMP))

experiments_ovary_centres/run_create_annotation.py

@@ -151,12 +151,12 @@ def create_annot_centers(path_img, path_out_seg, path_out_csv):
     df_center.to_csv(os.path.join(path_out_csv, name.replace('.png', '.csv')))
 
 
-def main(path_segs, path_out, nb_jobs):
+def main(path_segs, path_out, nb_workers):
     """ the main for creating annotations
 
     :param str path_segs: path with image pattern of images - obj segmentation
     :param str path_out:
-    :param int nb_jobs: number of processes in parallel
+    :param int nb_workers: number of processes in parallel
     """
     assert os.path.dirname(path_segs) != path_out, \
         'the output dir has to be different then the input object segmentation'
@@ -172,7 +172,7 @@ def main(path_segs, path_out, nb_jobs):
                                             path_out_seg=path_out,
                                             path_out_csv=path_out)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_create_annot_centers,
-                                          list_imgs, nb_jobs=nb_jobs,
+                                          list_imgs, nb_workers=nb_workers,
                                           desc='annotating images')
     list(iterate)
 
@@ -183,6 +183,6 @@ def main(path_segs, path_out, nb_jobs):
 
     params = run_train.arg_parse_params(PARAMS)
     path_out = os.path.join(params['path_output'], NAME_DIR)
-    main(params['path_segms'], path_out, params['nb_jobs'])
+    main(params['path_segms'], path_out, params['nb_workers'])
 
     logging.info('DONE')

experiments_ovary_detect/run_cut_segmented_objects.py

@@ -53,7 +53,7 @@ def arg_parse_params(dict_paths):
                         help='mask by the segmentation', default=1)
     parser.add_argument('-bg', '--background', type=int, required=False,
                         help='using background color', default=None, nargs='+')
-    parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
+    parser.add_argument('--nb_workers', type=int, required=False, default=NB_THREADS,
                         help='number of processes in parallel')
     args = vars(parser.parse_args())
     logging.info('ARG PARAMETERS: \n %r', args)
@@ -91,12 +91,12 @@ def export_cut_objects(df_row, path_out, padding, use_mask=True, bg_color=None):
 
 
 def main(dict_paths, padding=0, use_mask=False, bg_color=None,
-         nb_jobs=NB_THREADS):
+         nb_workers=NB_THREADS):
     """ the main executable
 
     :param dict_paths:
     :param int padding:
-    :param int nb_jobs:
+    :param int nb_workers:
     """
     if not os.path.isdir(dict_paths['output']):
         assert os.path.isdir(os.path.dirname(dict_paths['output'])), \
@@ -112,7 +112,7 @@ def main(dict_paths, padding=0, use_mask=False, bg_color=None,
                                padding=padding, use_mask=use_mask, bg_color=bg_color)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_cutting,
                                           (row for idx, row in df_paths.iterrows()),
-                                          nb_jobs=nb_jobs)
+                                          nb_workers=nb_workers)
     list(iterate)
 
 
@@ -122,6 +122,6 @@ def main(dict_paths, padding=0, use_mask=False, bg_color=None,
 
     dict_paths, args = arg_parse_params(PATHS)
     main(dict_paths, args['padding'], args['mask'],
-         args['background'], args['nb_jobs'])
+         args['background'], args['nb_workers'])
 
     logging.info('DONE')

experiments_ovary_detect/run_egg_swap_orientation.py

@@ -123,7 +123,7 @@ def main(params):
                               img_template=img_mean)
     dir_name = os.path.dirname(params['path_images'])
     iterate = tl_expt.WrapExecuteSequence(_wrapper_object, list_img_paths,
-                                          nb_jobs=params['nb_jobs'],
+                                          nb_workers=params['nb_workers'],
                                           desc=dir_name)
     list(iterate)
 

experiments_ovary_detect/run_ellipse_annot_match.py

@@ -60,7 +60,7 @@ def arg_parse_params(params):
     parser.add_argument('-out', '--path_output', type=str, required=False,
                         help='path to the output directory',
                         default=params.get('path_output', None))
-    parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
+    parser.add_argument('--nb_workers', type=int, required=False, default=NB_THREADS,
                         help='number of processes in parallel')
     arg_params = vars(parser.parse_args())
     params.update(arg_params)
@@ -157,7 +157,7 @@ def main(params):
     _wrapper_match = partial(select_optimal_ellipse,
                              path_dir_csv=path_dir_csv)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_match, df_info.iterrows(),
-                                          nb_jobs=params['nb_jobs'])
+                                          nb_workers=params['nb_workers'])
     for i, dict_row in enumerate(iterate):
         list_evals.append(dict_row)
         # every hundreds iteration do export

experiments_ovary_detect/run_ellipse_cut_scale.py

@@ -97,7 +97,7 @@ def perform_stage(df_group, stage, path_images, path_out):
                               path_out=path_out_stage, norm_size=norm_size)
     desc = 'stage %i - size %s' % (stage, norm_size)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_object, df_group.iterrows(),
-                                          nb_jobs=params['nb_jobs'],
+                                          nb_workers=params['nb_workers'],
                                           desc=desc)
     list(iterate)
 

experiments_ovary_detect/run_export_user-annot-segm.py

@@ -76,7 +76,7 @@ def arg_parse_params(params):
     parser.add_argument('-out', '--path_output', type=str, required=False,
                         help='path to the output directory',
                         default=params['path_output'])
-    parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
+    parser.add_argument('--nb_workers', type=int, required=False, default=NB_THREADS,
                         help='number of processes in parallel')
     arg_params = vars(parser.parse_args())
     params.update(arg_params)
@@ -215,7 +215,7 @@ def main(params):
     _wrapper_export = partial(export_figure, df_slices_info=df_slices_info,
                               path_out=params['path_output'])
     iterate = tl_expt.WrapExecuteSequence(_wrapper_export, df_paths.iterrows(),
-                                          nb_jobs=params['nb_jobs'])
+                                          nb_workers=params['nb_workers'])
     list(iterate)
 
 

experiments_ovary_detect/run_ovary_egg-segmentation.py

@@ -7,7 +7,7 @@
 SAMPLE run:
 >> python run_ovary_egg-segmentation.py \
     -list data_images/drosophila_ovary_slice/list_imgs-segm-center-points.csv \
-    -out results -n ovary_slices --nb_jobs 1 \
+    -out results -n ovary_slices --nb_workers 1 \
     -m ellipse_moments \
        ellipse_ransac_mmt \
        ellipse_ransac_crit \
@@ -141,7 +141,7 @@ def arg_parse_params(params):
                         help='name of the experiment', default='ovary')
     parser.add_argument('-cfg', '--path_config', type=str, required=False,
                         help='path to the configuration', default=None)
-    parser.add_argument('--nb_jobs', type=int, required=False, default=NB_THREADS,
+    parser.add_argument('--nb_workers', type=int, required=False, default=NB_THREADS,
                         help='number of processes in parallel')
     parser.add_argument('-m', '--methods', type=str, required=False, nargs='+',
                         help='list of segment. methods', default=None)
@@ -799,7 +799,7 @@ def main(params, debug_export=DEBUG_EXPORT):
 
     _wrapper_segment = partial(image_segmentation, params=params)
     iterate = tl_expt.WrapExecuteSequence(_wrapper_segment, df_paths.iterrows(),
-                                          nb_jobs=params['nb_jobs'])
+                                          nb_workers=params['nb_workers'])
     list(iterate)