def load_train_classifier(params, features, labels, feature_names, sizes, nb_holdout): logging.info('train classifier...') seg_clf.feature_scoring_selection(features, labels, feature_names, path_out=params['path_exp']) cv = seg_clf.CrossValidateGroups(sizes, nb_hold_out=nb_holdout) # feature norm & train classification fname_classif = seg_clf.TEMPLATE_NAME_CLF.format(params['classif']) path_classif = os.path.join(params['path_exp'], fname_classif) if os.path.isfile(path_classif) and not FORCE_RETRAIN_CLASSIF: logging.info('loading classifier: %s', path_classif) params_local = params.copy() dict_classif = seg_clf.load_classifier(path_classif) classif = dict_classif['clf_pipeline'] params = dict_classif['params'] params.update({k: params_local[k] for k in params_local if k.startswith('path_') or k.startswith('gc_')}) logging.debug('loaded PARAMETERS: %r', params) else: classif, path_classif = seg_clf.create_classif_search_train_export( params['classif'], features, labels, cross_val=cv, params=params, feature_names=feature_names, pca_coef=params['pca_coef'], eval_metric=params.get('classif_metric', 'f1'), nb_search_iter=params.get('nb_classif_search', 1), nb_workers=params['nb_workers'], path_out=params['path_exp']) params['path_classif'] = path_classif cv = seg_clf.CrossValidateGroups(sizes, nb_hold_out=nb_holdout) seg_clf.eval_classif_cross_val_scores(params['classif'], classif, features, labels, cross_val=cv, path_out=params['path_exp']) seg_clf.eval_classif_cross_val_roc(params['classif'], classif, features, labels, cross_val=cv, path_out=params['path_exp']) return params, classif, path_classif
def test_classif_pipeline(self): """ test the training of classif with expected F1 score close to one """ data_train, labels_train = generate_data() data_test, labels_test = generate_data() for n in CLASSIFIER_NAMES: logging.info('created classif.: %s', n) clf, _ = create_classif_search_train_export(n, data_train, labels_train, nb_search_iter=5) self.classif_eval(clf, data_train, labels_train, data_test, labels_test)
def main_train(params): """ PIPELINE for training 0) load triplets or create triplets from path to images, annotations 1) load precomputed data or compute them now 2) train classifier with hyper-parameters 3) perform Leave-One-Out experiment :param {str: any} params: """ params = prepare_experiment_folder(params, FOLDER_EXPERIMENT) tl_expt.set_experiment_logger(params['path_expt']) logging.info(tl_expt.string_dict(params, desc='PARAMETERS')) tl_expt.save_config_yaml( os.path.join(params['path_expt'], NAME_YAML_PARAMS), params) tl_expt.create_subfolders(params['path_expt'], LIST_SUBDIRS) df_paths, _ = load_df_paths(params) path_dump_data = os.path.join(params['path_expt'], NAME_DUMP_TRAIN_DATA) 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_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, ) else: (dict_imgs, dict_segms, dict_slics, dict_points, dict_centers, dict_features, dict_labels, feature_names) = load_dump_data(path_dump_data) 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_workers']) # concentrate features, labels features, labels, sizes = seg_clf.convert_set_features_labels_2_dataset( dict_features, dict_labels, drop_labels=[-1], balance_type=params['balance']) # remove all bad values from features space features[np.isnan(features)] = 0 features[np.isinf(features)] = -1 assert np.sum(sizes) == len(labels), \ 'not equal sizes (%d) and labels (%i)' \ % (int(np.sum(sizes)), len(labels)) # feature norm & train classification nb_holdout = int(np.ceil(len(sizes) * CROSS_VAL_LEAVE_OUT_SEARCH)) cv = seg_clf.CrossValidateGroups(sizes, nb_holdout) 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_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) seg_clf.eval_classif_cross_val_scores(params['classif'], classif, features, labels, cross_val=cv, path_out=params['path_expt']) seg_clf.eval_classif_cross_val_roc(params['classif'], classif, features, labels, cross_val=cv, path_out=params['path_expt']) if RUN_LEAVE_ONE_OUT: experiment_loo(classif, dict_imgs, dict_segms, dict_centers, dict_slics, dict_points, dict_features, feature_names, params)
def train_classif_color2d_slic_features(list_images, list_annots, dict_features, sp_size=30, sp_regul=0.2, clf_name=CLASSIF_NAME, label_purity=0.9, feature_balance='unique', pca_coef=None, nb_classif_search=1, nb_hold_out=CROSS_VAL_LEAVE_OUT, nb_workers=1): """ train classifier on list of annotated images :param [ndarray] list_images: :param [ndarray] list_annots: :param int sp_size: initial size of a superpixel(meaning edge lenght) :param float sp_regul: regularisation in range(0;1) where "0" gives elastic and "1" nearly square segments :param dict(list(str)) dict_features: list of features to be extracted :param str clf_name: selet udsed classifier :param float label_purity: set the sample-labels purity for training :param str feature_balance: set how to balance datasets :param float pca_coef: select PCA coef or None :param int nb_classif_search: number of tries for hyper-parameters seach :param int nb_hold_out: cross-val leave out :param int nb_workers: parallelism :return: """ logging.info('TRAIN Superpixels-Features-Classifier') assert len(list_images) == len(list_annots), \ 'size of images (%i) and annotations (%i) should match' \ % (len(list_images), len(list_annots)) list_slic, list_features, list_labels = list(), list(), list() _wrapper_compute = partial(wrapper_compute_color2d_slic_features_labels, sp_size=sp_size, sp_regul=sp_regul, dict_features=dict_features, label_purity=label_purity) list_imgs_annot = zip(list_images, list_annots) iterate = WrapExecuteSequence(_wrapper_compute, list_imgs_annot, desc='compute SLIC & features & labels', nb_workers=nb_workers) for slic, fts, lbs in iterate: list_slic.append(slic) list_features.append(fts) list_labels.append(lbs) logging.debug('concentrate features...') # concentrate features, labels features, labels, sizes = convert_set_features_labels_2_dataset( dict(zip(range(len(list_features)), list_features)), dict(zip(range(len(list_labels)), list_labels)), balance_type=feature_balance, drop_labels=[-1]) # drop do not care label whichare -1 features = np.nan_to_num(features) logging.debug('train classifier...') # clf_pipeline = seg_clf.create_clf_pipeline(clf_name, pca_coef) # clf_pipeline.fit(np.array(features), np.array(labels, dtype=int)) if len(sizes) > (nb_hold_out * 5): cv = CrossValidateGroups(sizes, nb_hold_out=nb_hold_out) # for small nuber of training images this does not make sence else: cv = 10 classif, _ = create_classif_search_train_export( clf_name, features, labels, pca_coef=pca_coef, cross_val=cv, nb_search_iter=nb_classif_search, nb_workers=nb_workers) return classif, list_slic, list_features, list_labels