Beispiel #1
0
def get_metrics(dict_test_features):
    metrics_matrix = []
    n = len(classes())
    m = 4
    for subset in itertools.combinations(classes(), 2):
        class_0 = subset[0]
        class_1 = subset[1]


        X_train_0 = dataloader.dict_train_features(class_0)
        X_train_1 = dataloader.dict_train_features(class_1)
        X_train = np.concatenate((X_train_0, X_train_1), axis=0)
        X_train = X_train[:, dataloader.columns_selected()]

        y_train_0 = np.zeros((X_train_0.shape[0],))
        y_train_1 = np.ones((X_train_1.shape[0],))
        y_train = np.concatenate((y_train_0, y_train_1), axis=0)

        X_test_0 = dict_test_features[class_0]
        X_test_1 = dict_test_features[class_1]
        X_test = np.concatenate((X_test_0, X_test_1), axis=0)
        X_test = X_test[:, dataloader.columns_selected()]

        y_test_0 = np.zeros((X_test_0.shape[0],))
        y_test_1 = np.ones((X_test_1.shape[0],))
        y_test = np.concatenate((y_test_0, y_test_1), axis=0)

        feat_max = np.max(X_train, axis=0)
        feat_min = np.min(X_train, axis=0)
        X_train_normalized = (X_train - feat_min) / (feat_max - feat_min)
        X_test_normalized = (X_test - feat_min) / (feat_max - feat_min)

        SVM_parameters = {
            'C': 1,
            'kernel': 'rbf',
        }

        clf = sklearn.svm.SVC(**SVM_parameters)

        clf.fit(X_train_normalized, y_train)
        y_test_predicted = clf.predict(X_test_normalized)

        print("{} // {}".format(class_0, class_1))
        metrics_couple = compute_metrics(y_test, y_test_predicted)
        metrics_matrix = np.append(metrics_matrix, metrics_couple)

    metrics_matrix = np.reshape(metrics_matrix, (n, 4))

    compute_overall_metrics(metrics_matrix)
def test():
    # begin compute and select features
    path = pathlib.Path(__file__).parent.absolute()
    classes = user_interface.classes()
    if user_interface.generate_datasets():
        dict_test_features = {'NoFX': [], 'Distortion': [], 'Tremolo': []}
        for c in classes:
            dict_test_features[c] = dataloader.dict_test_feats(c)
    else:
        dict_test_features = testloop.getdicttestfeatures(
            path)  # test features
    X_test = [dict_test_features[c] for c in user_interface.classes()]
    columns_selected = dataloader.columns_selected(
    )  # positions of selected features
    X_test_selected = [
        X_test[i][:, columns_selected]
        for i in np.arange(len(user_interface.classes()))
    ]  # selection
    y_test = [
        np.ones(X_test[i].shape[0], ) * i
        for i in np.arange(len(user_interface.classes()))
    ]  # keys
    y_test_mc = np.concatenate((y_test[0], y_test[1], y_test[2]), axis=0)
    X_test_normalized = [
        ((X_test_selected[c] - dataloader.featmin()[columns_selected]) /
         (dataloader.featmax()[columns_selected] -
          dataloader.featmin()[columns_selected]))
        for c in np.arange(len(user_interface.classes()))
    ]  # normalized matrix
    X_train_normalized_loaded = [
        (dataloader.dict_train_features(c) - dataloader.featmin()) /
        (dataloader.featmax() - dataloader.featmin())
        for c in user_interface.classes()
    ]  # train features
    X_train_normalized_loaded_selected = [
        X_train_normalized_loaded[i][:, columns_selected]
        for i in np.arange(len(user_interface.classes()))
    ]  # selection
    X_test_mc_normalized = np.concatenate(
        (X_test_normalized[0], X_test_normalized[1], X_test_normalized[2]),
        axis=0)
    y_train_selected = [
        np.ones(X_train_normalized_loaded_selected[i].shape[0], ) * i
        for i in np.arange(len(user_interface.classes()))
    ]
    # end compute and select features
    y_test_predicted_mv = supportvectormachines.getpredictions(
        X_train_normalized_loaded_selected, y_train_selected,
        X_test_mc_normalized)  # SVM
    print('\n\nMetrics:')
    metrics.get_metrics(dict_test_features)
    print('\n\nConfusion matrix:')
    confusionmatrix.compute_cm_multiclass(
        y_test_mc, y_test_predicted_mv)  # print confusion matrix
    return True
def train():
    path = pathlib.Path(__file__).parent.absolute()
    classes = user_interface.classes()
    if user_interface.generate_datasets():
        main_traintest.traintest(path)
        dict_train_features = {'NoFX': [], 'Distortion': [], 'Tremolo': []}
        for c in classes:
            dict_train_features[c] = dataloader.dict_train_features(c)
    else:
        dict_train_features = trainingloop.getdicttrainfeatures(
            path)  # compute train features
    X_train = [dict_train_features[c] for c in classes]
    y_train = [
        np.ones(X_train[i].shape[0], ) * i
        for i in np.arange(len(user_interface.classes()))
    ]  # keys
    feat_max = np.max(np.concatenate((X_train[0], X_train[1], X_train[2]),
                                     axis=0),
                      axis=0)
    feat_min = np.min(np.concatenate((X_train[0], X_train[1], X_train[2]),
                                     axis=0),
                      axis=0)
    X_train_normalized = [(X_train[c] - feat_min) / (feat_max - feat_min)
                          for c in np.arange(len(user_interface.classes()))
                          ]  # normalized matrix
    X_train_mc_normalized = np.concatenate(
        (X_train_normalized[0], X_train_normalized[1], X_train_normalized[2]),
        axis=0)
    y_train_mc = np.concatenate((y_train[0], y_train[1], y_train[2]), axis=0)

    featurelst = featureselection.getfeaturelist(
        X_train_mc_normalized, y_train_mc)  # feature selection
    if user_interface.do_plot():
        plotfeatures.plotfeats(X_train_normalized,
                               mask=np.arange(10) + 7)  # plot train features
    else:
        plotselected.plotsel(X_train_normalized, featurelst['selectedcolumns'])
    savetraindata.savedata(dict_train_features, featurelst, feat_max,
                           feat_min)  # save data
    print('All features')
    print(user_interface.featuresnames())
    print_feature_sel.print_features(featurelst)
    return True
import plotfeatures


def plotsel(features, colums_selected):
    plotfeatures.plotfeats(features, colums_selected)


if __name__ == "__main__":  # executable from terminal
    from environment.modules import dataloader
    from environment.modules.analysislab.user_interface import classes

    dict_tr = [(dataloader.dict_train_features(c) - dataloader.featmin()) /
               (dataloader.featmax() - dataloader.featmin())
               for c in classes()]
    plotsel(dict_tr, dataloader.colums_selected())