How to compute precision, recall, accuracy and f1-score for the multiclass case with scikit learn?

I'm working in a sentiment analysis problem the data looks like this:

    label instances
        5    1190
        4     838
        3     239
        1     204
        2     127

So my data is unbalanced since 1190 instances are labeled with 5. For the classification Im using scikit's SVC. The problem is I do not know how to balance my data in the right way in order to compute accurately the precision, recall, accuracy and f1-score for the multiclass case. So I tried the following approaches:

First:

        wclf = SVC(kernel='linear', C= 1, class_weight={1: 10})
        wclf.fit(X, y)
        weighted_prediction = wclf.predict(X_test)

    print 'Accuracy:', accuracy_score(y_test, weighted_prediction)
    print 'F1 score:', f1_score(y_test, weighted_prediction,average='weighted')
    print 'Recall:', recall_score(y_test, weighted_prediction,
                                  average='weighted')
    print 'Precision:', precision_score(y_test, weighted_prediction,
                                        average='weighted')
    print '\n clasification report:\n', classification_report(y_test, weighted_prediction)
    print '\n confussion matrix:\n',confusion_matrix(y_test, weighted_prediction)

Second:

    auto_wclf = SVC(kernel='linear', C= 1, class_weight='auto')
    auto_wclf.fit(X, y)
    auto_weighted_prediction = auto_wclf.predict(X_test)

    print 'Accuracy:', accuracy_score(y_test, auto_weighted_prediction)

    print 'F1 score:', f1_score(y_test, auto_weighted_prediction,
                                average='weighted')

    print 'Recall:', recall_score(y_test, auto_weighted_prediction,
                                  average='weighted')

    print 'Precision:', precision_score(y_test, auto_weighted_prediction,
                                        average='weighted')

    print '\n clasification report:\n', classification_report(y_test,auto_weighted_prediction)

    print '\n confussion matrix:\n',confusion_matrix(y_test, auto_weighted_prediction)

Third:

    clf = SVC(kernel='linear', C= 1)
    clf.fit(X, y)
    prediction = clf.predict(X_test)


    from sklearn.metrics import precision_score, \
        recall_score, confusion_matrix, classification_report, \
        accuracy_score, f1_score

    print 'Accuracy:', accuracy_score(y_test, prediction)
    print 'F1 score:', f1_score(y_test, prediction)
    print 'Recall:', recall_score(y_test, prediction)
    print 'Precision:', precision_score(y_test, prediction)
    print '\n clasification report:\n', classification_report(y_test,prediction)
    print '\n confussion matrix:\n',confusion_matrix(y_test, prediction)


    F1 score:/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:676: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, 'micro', 'macro', 'weighted', 'samples'). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".
      sample_weight=sample_weight)
    /usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1172: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, 'micro', 'macro', 'weighted', 'samples'). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".
      sample_weight=sample_weight)
    /usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1082: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, 'micro', 'macro', 'weighted', 'samples'). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".
      sample_weight=sample_weight)
     0.930416613529

However, Im getting warnings like this:

    /usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1172:
    DeprecationWarning: The default `weighted` averaging is deprecated,
    and from version 0.18, use of precision, recall or F-score with 
    multiclass or multilabel data or pos_label=None will result in an 
    exception. Please set an explicit value for `average`, one of (None, 
    'micro', 'macro', 'weighted', 'samples'). In cross validation use, for 
    instance, scoring="f1_weighted" instead of scoring="f1"

How can I deal correctly with my unbalanced data in order to compute in the right way classifier's metrics?

I think there is a lot of confusion about which weights are used for what. I am not sure I know precisely what bothers you so I am going to cover different topics, bear with me ;).

Class weights

The weights from the class_weight parameter are used to train the classifier. They are not used in the calculation of any of the metrics you are using : with different class weights, the numbers will be different simply because the classifier is different.

Basically in every scikit-learn classifier, the class weights are used to tell your model how important a class is. That means that during the training, the classifier will make extra efforts to classify properly the classes with high weights.
How they do that is algorithm-specific. If you want details about how it works for SVC and the doc does not make sense to you, feel free to mention it.

The metrics

Once you have a classifier, you want to know how well it is performing. Here you can use the metrics you mentioned: accuracy, recall_score, f1_score...

Usually when the class distribution is unbalanced, accuracy is considered a poor choice as it gives high scores to models which just predict the most frequent class.

I will not detail all these metrics but note that, with the exception of accuracy, they are naturally applied at the class level: as you can see in this print of a classification report they are defined for each class. They rely on concepts such as true positives or false negative that require defining which class is the positive one.

                 precision    recall  f1-score   support

              0       0.65      1.00      0.79        17
              1       0.57      0.75      0.65        16
              2       0.33      0.06      0.10        17
    avg / total       0.52      0.60      0.51        50

The warning

    F1 score:/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:676: DeprecationWarning: The 
    default `weighted` averaging is deprecated, and from version 0.18, 
    use of precision, recall or F-score with multiclass or multilabel data  
    or pos_label=None will result in an exception. Please set an explicit 
    value for `average`, one of (None, 'micro', 'macro', 'weighted', 
    'samples'). In cross validation use, for instance, 
    scoring="f1_weighted" instead of scoring="f1".

You get this warning because you are using the f1-score, recall and precision without defining how they should be computed! The question could be rephrased: from the above classification report, how do you output one global number for the f1-score? You could:

  1. Take the average of the f1-score for each class: that's the avg / total result above. It's also called macro averaging.
  2. Compute the f1-score using the global count of true positives / false negatives, etc. (you sum the number of true positives / false negatives for each class). Aka micro averaging.
  3. Compute a weighted average of the f1-score. Using 'weighted' in scikit-learn will weigh the f1-score by the support of the class: the more elements a class has, the more important the f1-score for this class in the computation.

These are 3 of the options in scikit-learn, the warning is there to say you have to pick one. So you have to specify an average argument for the score method.

Which one you choose is up to how you want to measure the performance of the classifier: for instance macro-averaging does not take class imbalance into account and the f1-score of class 1 will be just as important as the f1-score of class 5. If you use weighted averaging however you'll get more importance for the class 5.

The whole argument specification in these metrics is not super-clear in scikit-learn right now, it will get better in version 0.18 according to the docs. They are removing some non-obvious standard behavior and they are issuing warnings so that developers notice it.

Computing scores

Last thing I want to mention (feel free to skip it if you're aware of it) is that scores are only meaningful if they are computed on data that the classifier has never seen. This is extremely important as any score you get on data that was used in fitting the classifier is completely irrelevant.

Here's a way to do it using StratifiedShuffleSplit, which gives you a random splits of your data (after shuffling) that preserve the label distribution.

    from sklearn.datasets import make_classification
    from sklearn.cross_validation import StratifiedShuffleSplit
    from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix

    # We use a utility to generate artificial classification data.
    X, y = make_classification(n_samples=100, n_informative=10, n_classes=3)
    sss = StratifiedShuffleSplit(y, n_iter=1, test_size=0.5, random_state=0)
    for train_idx, test_idx in sss:
        X_train, X_test, y_train, y_test = X[train_idx], X[test_idx], y[train_idx], y[test_idx]
        svc.fit(X_train, y_train)
        y_pred = svc.predict(X_test)
        print(f1_score(y_test, y_pred, average="macro"))
        print(precision_score(y_test, y_pred, average="macro"))
        print(recall_score(y_test, y_pred, average="macro"))

Hope this helps.

From: stackoverflow.com/q/31421413