Calculer sklearn.roc_auc_score pour le multi-classe

Je voudrais calculer l'ASC, de la précision, de l'exactitude de mon classificateur.
Je suis en train de faire l'apprentissage supervisé:

Voici mon code de travail.
Ce code fonctionne très bien pour les binaires de la classe, mais pas pour le multi de classe.
Veuillez supposons que vous disposez d'un dataframe binaire classes:

sample_features_dataframe = self._get_sample_features_dataframe()
labeled_sample_features_dataframe = retrieve_labeled_sample_dataframe(sample_features_dataframe)
labeled_sample_features_dataframe, binary_class_series, multi_class_series = self._prepare_dataframe_for_learning(labeled_sample_features_dataframe)

k = 10
k_folds = StratifiedKFold(binary_class_series, k)
for train_indexes, test_indexes in k_folds:
    train_set_dataframe = labeled_sample_features_dataframe.loc[train_indexes.tolist()]
    test_set_dataframe = labeled_sample_features_dataframe.loc[test_indexes.tolist()]

    train_class = binary_class_series[train_indexes]
    test_class = binary_class_series[test_indexes]
    selected_classifier = RandomForestClassifier(n_estimators=100)
    selected_classifier.fit(train_set_dataframe, train_class)
    predictions = selected_classifier.predict(test_set_dataframe)
    predictions_proba = selected_classifier.predict_proba(test_set_dataframe)

    roc += roc_auc_score(test_class, predictions_proba[:,1])
    accuracy += accuracy_score(test_class, predictions)
    recall += recall_score(test_class, predictions)
    precision += precision_score(test_class, predictions)

À la fin, j'ai divisé les résultats en K de cours pour l'obtention de la moyenne de l'ASC, de la précision, etc.
Ce code fonctionne bien.
Cependant, je ne peut pas calculer de même pour le multi classe: 

    train_class = multi_class_series[train_indexes]
    test_class = multi_class_series[test_indexes]

    selected_classifier = RandomForestClassifier(n_estimators=100)
    selected_classifier.fit(train_set_dataframe, train_class)

    predictions = selected_classifier.predict(test_set_dataframe)
    predictions_proba = selected_classifier.predict_proba(test_set_dataframe)

J'ai trouvé que pour le multi de classe I d'ajouter le paramètre "pondérée" pour la moyenne.

    roc += roc_auc_score(test_class, predictions_proba[:,1], average="weighted")

J'ai une erreur: raise ValueError("{0} format n'est pas pris en charge".format(y_type))

ValueError: multiclass format n'est pas pris en charge

OriginalL'auteur Aviade | 2016-09-25

  1. 10

    La average option de roc_auc_score est définie uniquement pour les multilabel problèmes.

    Vous pouvez prendre un coup d'oeil à l'exemple suivant de la scikit-learn de la documentation pour vous définir de micro - ou de macro-moyenne des scores pour multiclass problèmes:

    http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html#multiclass-settings

    Modifier: il y a un problème sur le scikit-learn dispositif de suivi pour mettre en œuvre ROC de l'ASC pour les multiclass problèmes: https://github.com/scikit-learn/scikit-learn/issues/3298

    OriginalL'auteur ogrisel

  2. 6

    Vous ne pouvez pas utiliser roc_auc comme un simple résumé de la mesure de la multiclass modèles. Si vous le souhaitez, vous pouvez calculer par classe roc_auc, comme 

    roc = {label: [] for label in multi_class_series.unique()}
for label in multi_class_series.unique():
    selected_classifier.fit(train_set_dataframe, train_class == label)
    predictions_proba = selected_classifier.predict_proba(test_set_dataframe)
    roc[label] += roc_auc_score(test_class, predictions_proba[:,1])

    Mais il est plus habituel d'utiliser sklearn.metrics.confusion_matrix pour évaluer la performance d'un multiclass modèle.

    OriginalL'auteur maxymoo

  3. 4

    Comme mentionné ici, au meilleur de ma connaissance, il n'existe pas encore une façon de calculer facilement roc de l'asc pour les multiples paramètres de la classe de façon native dans sklearn.

    Toutefois, si vous êtes familier avec classification_report vous aimerez cette simple mise en œuvre qui renvoie le même résultat que classification_report comme un pandas.DataFrame que j'ai personnellement trouvé très pratique!:

    import pandas as pd
import numpy as np
from scipy import interp
from  sklearn.metrics import precision_recall_fscore_support
from sklearn.metrics import roc_curve, auc
from sklearn.preprocessing import LabelBinarizer
def class_report(y_true, y_pred, y_score=None, average='micro'):
if y_true.shape != y_pred.shape:
print("Error! y_true %s is not the same shape as y_pred %s" % (
y_true.shape,
y_pred.shape)
)
return
lb = LabelBinarizer()
if len(y_true.shape) == 1:
lb.fit(y_true)
#Value counts of predictions
labels, cnt = np.unique(
y_pred,
return_counts=True)
n_classes = len(labels)
pred_cnt = pd.Series(cnt, index=labels)
metrics_summary = precision_recall_fscore_support(
y_true=y_true,
y_pred=y_pred,
labels=labels)
avg = list(precision_recall_fscore_support(
y_true=y_true, 
y_pred=y_pred,
average='weighted'))
metrics_sum_index = ['precision', 'recall', 'f1-score', 'support']
class_report_df = pd.DataFrame(
list(metrics_summary),
index=metrics_sum_index,
columns=labels)
support = class_report_df.loc['support']
total = support.sum() 
class_report_df['avg /total'] = avg[:-1] + [total]
class_report_df = class_report_df.T
class_report_df['pred'] = pred_cnt
class_report_df['pred'].iloc[-1] = total
if not (y_score is None):
fpr = dict()
tpr = dict()
roc_auc = dict()
for label_it, label in enumerate(labels):
fpr[label], tpr[label], _ = roc_curve(
(y_true == label).astype(int), 
y_score[:, label_it])
roc_auc[label] = auc(fpr[label], tpr[label])
if average == 'micro':
if n_classes <= 2:
fpr["avg /total"], tpr["avg /total"], _ = roc_curve(
lb.transform(y_true).ravel(), 
y_score[:, 1].ravel())
else:
fpr["avg /total"], tpr["avg /total"], _ = roc_curve(
lb.transform(y_true).ravel(), 
y_score.ravel())
roc_auc["avg /total"] = auc(
fpr["avg /total"], 
tpr["avg /total"])
elif average == 'macro':
# First aggregate all false positive rates
all_fpr = np.unique(np.concatenate([
fpr[i] for i in labels]
))
# Then interpolate all ROC curves at this points
mean_tpr = np.zeros_like(all_fpr)
for i in labels:
mean_tpr += interp(all_fpr, fpr[i], tpr[i])
# Finally average it and compute AUC
mean_tpr /= n_classes
fpr["macro"] = all_fpr
tpr["macro"] = mean_tpr
roc_auc["avg /total"] = auc(fpr["macro"], tpr["macro"])
class_report_df['AUC'] = pd.Series(roc_auc)
return class_report_df

    Voici quelques exemple:

    from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=5000, n_features=10,
n_informative=5, n_redundant=0,
n_classes=10, random_state=0, 
shuffle=False)
X_train, X_test, y_train, y_test = train_test_split(X, y)
model = RandomForestClassifier(max_depth=2, random_state=0)
model.fit(X_train, y_train)

    Régulière classification_report:

    sk_report = classification_report(
digits=6,
y_true=y_test, 
y_pred=model.predict(X_test))
print(sk_report)

    :

                 precision    recall  f1-score   support
0   0.262774  0.553846  0.356436       130
1   0.405405  0.333333  0.365854       135
2   0.367347  0.150000  0.213018       120
3   0.350993  0.424000  0.384058       125
4   0.379310  0.447154  0.410448       123
5   0.525000  0.182609  0.270968       115
6   0.362573  0.488189  0.416107       127
7   0.330189  0.299145  0.313901       117
8   0.328571  0.407080  0.363636       113
9   0.571429  0.248276  0.346154       145
avg / total   0.390833  0.354400  0.345438      1250

    Personnalisé classification_report:

    report_with_auc = class_report(
y_true=y_test, 
y_pred=model.predict(X_test), 
y_score=model.predict_proba(X_test))
print(report_with_auc)

    :

                 precision    recall  f1-score  support    pred       AUC
0             0.262774  0.553846  0.356436    130.0   274.0  0.766477
1             0.405405  0.333333  0.365854    135.0   111.0  0.773974
2             0.367347  0.150000  0.213018    120.0    49.0  0.817341
3             0.350993  0.424000  0.384058    125.0   151.0  0.803364
4             0.379310  0.447154  0.410448    123.0   145.0  0.802436
5             0.525000  0.182609  0.270968    115.0    40.0  0.680870
6             0.362573  0.488189  0.416107    127.0   171.0  0.855768
7             0.330189  0.299145  0.313901    117.0   106.0  0.766526
8             0.328571  0.407080  0.363636    113.0   140.0  0.754812
9             0.571429  0.248276  0.346154    145.0    63.0  0.769100
avg / total   0.390833  0.354400  0.345438   1250.0  1250.0  0.776071
    J'aime le format facile à lire de la sortie générée. Merci

    OriginalL'auteur Raul

  4. 1

    Si vous êtes à la recherche de quelque chose de relativement simple qui prend dans le réel et prédit les listes et retourne un dictionnaire avec toutes les classes comme des clés et de ses roc_auc_score que les valeurs, vous pouvez utiliser la méthode suivante:

    from sklearn.metrics import roc_auc_score
def roc_auc_score_multiclass(actual_class, pred_class, average = "macro"):
#creating a set of all the unique classes using the actual class list
unique_class = set(actual_class)
roc_auc_dict = {}
for per_class in unique_class:
#creating a list of all the classes except the current class 
other_class = [x for x in unique_class if x != per_class]
#marking the current class as 1 and all other classes as 0
new_actual_class = [0 if x in other_class else 1 for x in actual_class]
new_pred_class = [0 if x in other_class else 1 for x in pred_class]
#using the sklearn metrics method to calculate the roc_auc_score
roc_auc = roc_auc_score(new_actual_class, new_pred_class, average = average)
roc_auc_dict[per_class] = roc_auc
return roc_auc_dict
print("\nLogistic Regression")
# assuming your already have a list of actual_class and predicted_class from the logistic regression classifier
lr_roc_auc_multiclass = roc_auc_score_multiclass(actual_class, predicted_class)
print(lr_roc_auc_multiclass)
# Sample output
# Logistic Regression
# {0: 0.5087457159427196, 1: 0.5, 2: 0.5, 3: 0.5114706737345112, 4: 0.5192307692307693}
# 0.5078894317816
    êtes-vous binarizing la sortie, puis à calculer le ROC pour chaque classe dans un vs ?
    Oui! C'est ce qui est fait après le commentaire #marking the current class as 1 and all other classes as 0

    OriginalL'auteur Afsan Abdulali Gujarati

  5. 0

    Mise à jour sur maxymoo de réponse.

    roc[label] += roc_auc_score(test_class, predictions_proba[:,label])

    ou reportez-vous à classifier.classes_ attribut de décider de la colonne de droite pour les intéressés étiquette.

    OriginalL'auteur Long