Apprentissage automatique Python – AUC
Sur cette page, Infodewi.com collabore avec
Académie des sciences des données de NYCpour délivrer des contenus de formation numériques à nos étudiants.
ASC – Courbe ROC
Dans la classification, il existe de nombreuses mesures d’évaluation différentes. Le plus populaire est précision, qui mesure la fréquence à laquelle le modèle est correct. Il s’agit d’une excellente mesure car elle est facile à comprendre et il est souvent souhaitable d’obtenir les suppositions les plus correctes. Dans certains cas, vous pouvez envisager d’utiliser une autre métrique d’évaluation.
Une autre mesure courante est ASCzone sous la caractéristique de fonctionnement du récepteur (ROC) courbe. La courbe caractéristique de fonctionnement du récepteur trace le vrai positif (TP) taux par rapport aux faux positifs (PF) taux à différents seuils de classification. Les seuils sont des seuils de probabilité différents qui séparent les deux classes dans la classification binaire. Il utilise la probabilité pour nous dire dans quelle mesure un modèle sépare les classes.
Données déséquilibrées
Supposons que nous ayons un ensemble de données déséquilibré où la majorité de nos données est d’une valeur. Nous pouvons obtenir une grande précision pour le modèle en prédisant la classe majoritaire.
Exemple
importer numpy en tant que np
depuis sklearn.metrics importez precision_score, confusion_matrix, roc_auc_score, roc_curve
n=10000
rapport = .95
n_0 = int((1-ratio) * n)
n_1 = int(rapport * n)
y = np.tableau([0] * n_0 + [1] *n_1)
# ci-dessous les probabilités obtenues à partir d’un modèle hypothétique qui prédit toujours la classe majoritaire
# la probabilité de prédire la classe 1 va être de 100 %
y_proba = np.array([1]*n)
y_pred = y_proba > .5
print(f’score de précision : {accuracy_score(y, y_pred)}’)
cf_mat = confusion_matrix(y, y_pred)
print(‘Matrice de confusion’)
impression(cf_mat)
print(précision f’classe 0 : {cf_mat[0][0]/n_0}’)
print(précision f’classe 1 : {cf_mat[1][1]/n_1}’)
Exemple d’exécution »
PUBLICITÉ
Bien que nous obtenions une très grande précision, le modèle n’a fourni aucune information sur les données, il n’est donc pas utile. Nous prédisons avec précision la classe 1 100 % du temps, tandis que nous prédisons de manière inexacte la classe 0 0 % du temps. Au détriment de la précision, il serait peut-être préférable d’avoir un modèle qui peut quelque peu séparer les deux classes.
Exemple
# ci-dessous sont les probabilités obtenues à partir d’un modèle hypothétique qui ne prédit pas toujours le mode
y_proba_2 = np.array(
np.random.uniform(0, .7, n_0).tolist() +
np.random.uniform(.3, 1, n_1).tolist()
)
y_pred_2 = y_proba_2 > .5
print(f’score de précision : {accuracy_score(y, y_pred_2)}’)
cf_mat = confusion_matrix(y, y_pred_2)
print(‘Matrice de confusion’)
impression(cf_mat)
print(précision f’classe 0 : {cf_mat[0][0]/n_0}’)
print(précision f’classe 1 : {cf_mat[1][1]/n_1}’)
Exemple d’exécution »
Pour le deuxième ensemble de prédictions, nous n’avons pas un score de précision aussi élevé que le premier, mais la précision pour chaque classe est plus équilibrée. En utilisant la précision comme mesure d’évaluation, nous évaluerions le premier modèle plus haut que le second, même s’il ne nous dit rien sur les données.
Dans de tels cas, il serait préférable d’utiliser une autre métrique d’évaluation telle que l’AUC.
import matplotlib.pyplot as plt
def plot_roc_curve(true_y, y_prob):
« » »
trace la courbe roc en fonction des probabilités
« » »
fpr, tpr, seuils = roc_curve(true_y, y_prob)
plt.plot(fpr, tpr)
plt.xlabel(‘Taux de faux positifs’)
plt.ylabel(‘Taux positif réel’)
Exemple
Modèle 1 :
plot_roc_curve(y, y_proba)
print(f’score AUC du modèle 1 : {roc_auc_score(y, y_proba)}’)
Résultat
score ASC du modèle 1 : 0,5
Exemple d’exécution »
Exemple
Modèle 2 :
plot_roc_curve(y, y_proba_2)
print(f’score AUC du modèle 2 : {roc_auc_score(y, y_proba_2)}’)
Résultat
Score AUC du modèle 2 : 0,8270551578947367
Exemple d’exécution »
Un score AUC d’environ 0,5 signifierait que le modèle est incapable de faire la distinction entre les deux classes et la courbe ressemblerait à une ligne avec une pente de 1. Un score AUC plus proche de 1 signifie que le modèle a la capacité de séparer les deux classes et la courbe se rapprocherait du coin supérieur gauche du graphique.
Probabilités
Étant donné que l’AUC est une métrique qui utilise les probabilités des prédictions de classe, nous pouvons être plus confiants dans un modèle qui a un score AUC plus élevé qu’un modèle avec un score inférieur, même s’ils ont des précisions similaires.
Dans les données ci-dessous, nous avons deux ensembles de probabilités issus de modèles hypothétiques. Le premier a des probabilités qui ne sont pas aussi « confiantes » lors de la prédiction des deux classes (les probabilités sont proches de 0,5). La seconde a des probabilités plus « sûres » lors de la prédiction des deux classes (les probabilités sont proches des extrêmes de 0 ou 1).
Exemple
importer numpy en tant que np
n=10000
y = np.tableau([0] *n+ [1] *n)
#
y_prob_1 = np.array(
np.random.uniform(.25, .5, n//2).tolist() +
np.random.uniform(.3, .7, n).tolist() +
np.random.uniform(.5, .75, n//2).tolist()
)
y_prob_2 = np.array(
np.random.uniform(0, .4, n//2).tolist() +
np.random.uniform(.3, .7, n).tolist() +
np.random.uniform(.6, 1, n//2).tolist()
)
print(f’score de précision du modèle 1 : {accuracy_score(y, y_prob_1>.5)}’)
print(f’score de précision du modèle 2 : {accuracy_score(y, y_prob_2>.5)}’)
print(f’score AUC du modèle 1 : {roc_auc_score(y, y_prob_1)}’)
print(f’score AUC du modèle 2 : {roc_auc_score(y, y_prob_2)}’)
Exemple d’exécution »
Exemple
Modèle de parcelle 1 :
plot_roc_curve(y, y_prob_1)
Résultat
Exemple d’exécution »
Exemple
Modèle de tracé 2 :
fpr, tpr, seuils = roc_curve(y, y_prob_2)
plt.plot(fpr, tpr)
Résultat
Exemple d’exécution »
Même si les précisions des deux modèles sont similaires, le modèle avec le score AUC le plus élevé sera plus fiable car il prend en compte la probabilité prédite. Il est plus susceptible de vous donner une plus grande précision lors de la prévision des données futures.
#Apprentissage #automatique #Python #AUC
