Comprendre la classification

Ce que vous saurez faire

Transformez les faits d’un billet de soutien en score de 0 à 1, puis en signalement pour l’équipe expérimentée. Découvrez ensuite pourquoi la décision par défaut de scikit-learn ne signale presque aucun billet. Vous éviterez ainsi de livrer cette erreur.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter contient tout le code, les tâches et les vérifications de cette leçon, avec les consignes. Ses cellules de configuration installent pandas et scikit-learn et téléchargent les données d’exercice. Aucune configuration locale n’est donc nécessaire. Lisez les explications et les graphiques ici, puis exécutez le code dans le carnet.

Ouvrir dans ColabOuvrir dans KaggleVoir sur GitHub

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 60 minutes

Ce que vous devez savoir

• La régression linéaire, l’ordonnée à l’origine et le coefficient, fit (entraîner) et predict (prédire), dans Comprendre la régression.
• La classification et les étiquettes, dans L’apprentissage supervisé : caractéristiques et étiquettes.
• L’exactitude, la précision et le rappel, dans Les métriques de classification : la précision et le rappel.
• Les scores et les seuils, la précision moyenne et l’aire sous la courbe ROC, dans Le compromis entre précision et rappel.
• La cible escalated_72h, les références de base et l’objectif d’amélioration, dans Définir une référence de base. Sur les données de validation, « ne jamais transférer » atteint une exactitude de 0,845 et ne détecte rien. La règle « signaler la priorité 1 » signale 163 billets, avec une précision de 0,374 et un rappel de 0,333.

Ce qu’il vous faut sur votre ordinateur (uniquement pour travailler localement; le carnet n’en a pas besoin)

• Le dossier de projet ~/projects/ticket-model, avec son environnement .venv et les données dans data/. Vous les avez créés dans Définir une référence de base : préparer votre projet.
• data/train.csv (16 939 lignes) et data/valid.csv (1 179 lignes). S’ils manquent ou ont changé, exécutez python get_data.py --reset dans le dossier du projet. La dernière ligne doit être Ready: train 16939 rows (1983 escalated), valid 1179 (183), test 1002 (157). (prêt : nombres de lignes et de billets transférés pour chaque jeu).

Testé sur macOS avec Python 3.14.6, pandas 3.0.6 et scikit-learn 1.9.1. Les étapes pour Windows et Linux ne sont pas testées. Le carnet a été testé dans Jupyter.

Une prévision donne une probabilité, vous prenez la décision

Avant de quitter la maison, votre application météo annonce « 70 % de probabilité de pluie ». Elle ne dit pas « pluie » ou « pas de pluie ». Elle donne un nombre de 0 % à 100 %, et vous prenez la décision. Une personne prudente prend un parapluie dès 30 %. Une autre ne le prend qu’à 80 %. La prévision est la même pour les deux; seule la limite diffère.

Beaucoup de modèles de classification fonctionnent de la même façon. La question appelle une réponse oui ou non, une catégorie. Mais le modèle ne répond pas directement oui ou non. Il donne à chaque cas un score de 0 à 1. Plus le score est élevé, plus un « oui » est probable. Un seuil transforme ensuite le score en décision, comme dans Le compromis entre précision et rappel. Séparer les deux est utile, car la personne responsable de la décision peut choisir le seuil.

La question de Larkfield appelle un oui ou un non : ce billet sera-t-il transféré à un agent expérimenté dans les 72 heures? La cible escalated_72h vaut 1 ou 0. Grace, la responsable du soutien, veut un score pour chaque nouveau billet. Elle choisit ensuite un seuil adapté à la capacité de son équipe expérimentée. Celle-ci peut examiner au plus 1 billet sur 5. Si le score atteint au moins le seuil, le billet est signalé et envoyé à l’équipe expérimentée.

Il vous faut donc un modèle qui transforme les faits d’un billet en nombre entre 0 et 1. Vous connaissez déjà un modèle qui transforme des faits en nombre : la régression linéaire de la dernière leçon.

Pourquoi pas une droite?

Tomás, l’ingénieur en IA, propose un raccourci : « La cible vaut 0 ou 1. Ajustons une régression linéaire dessus et appelons sa prédiction la probabilité. » Priya essaie avec une variable, word_count, le nombre de mots dans le message du client. Elle fait des prédictions pour six longueurs de message :

import pandas as pd
from sklearn.linear_model import LinearRegression

TARGET = "escalated_72h"
train = pd.read_csv("data/train.csv")
line = LinearRegression().fit(train[["word_count"]], train[TARGET])
print(f"line: {line.intercept_:.4f} + {line.coef_[0]:.5f} x word_count")
words = pd.DataFrame({"word_count": [0, 100, 200, 500, 1000, 2000]})
words["line"] = line.predict(words[["word_count"]]).round(3)
print(words.to_string(index=False))

Le résultat :

Sortie

line: 0.0488 + 0.00064 x word_count
 word_count  line
          0 0.049
        100 0.113
        200 0.177
        500 0.370
       1000 0.692
       2000 1.335

Jusqu’à quelques centaines de mots, les nombres ressemblent à des probabilités. Mais chaque mot ajoute le même 0,00064, sans limite, comme la droite du taxi. Un message de 2 000 mots obtient 1,335 : une « probabilité » de 134 %. La droite dépasse 1 à 1 479 mots. Le plus long message d’entraînement compte 883 mots, mais rien n’empêche l’arrivée d’un message plus long demain.

La droite descend aussi sous 0. Dans le carnet, vous ajustez le même type de droite avec quatre variables. Alors, 570 billets d’entraînement obtiennent une valeur sous 0, une « probabilité » négative. L’un d’eux est un billet de priorité 3 sans mots, créé à 21 h : −0,038.

Le graphique montre un deuxième problème. Le taux réel de transfert n’augmente pas de la même quantité pour chaque mot. Il augmente vite pour les messages courts, puis plus lentement à partir d’environ 150 mots. Il bondit ensuite pour les quelques messages très longs. Une droite ne peut pas suivre cette forme.

• Taux de transfert dans les données d'entraînement, par nombre de mots
• Droite
• 0 et 1, les limites d'une probabilité

Une droite ajustée à une cible 0/1. Elle continue de monter et dépasse 1, la probabilité maximale, à 1 479 mots.

Description textuelle du graphique

L’axe horizontal représente le nombre de mots, de 0 à 2 000. Des lignes pointillées marquent 0 et 1, les limites d’une probabilité. Les points représentent les taux de transfert dans les données d’entraînement pour des groupes de billets. Ils valent 0,059 pour environ 37 mots, 0,096 pour 74, 0,138 pour 122 et 0,178 pour 172. Puis 0,191 pour 238, 0,214 pour 338 et 0,262 pour 461. Le dernier point vaut 0,600 pour environ 680 mots, à partir de seulement 15 billets. La droite commence à 0,049 pour 0 mot et monte régulièrement. Elle dépasse 1 à 1 479 mots et atteint 1,335 à 2 000 mots.

Une probabilité exige donc une autre forme : une courbe qui peut monter, sans jamais descendre sous 0 ni dépasser 1.

La courbe en S : la fonction logistique

La régression logistique garde la partie utile de la régression linéaire et change la forme. Elle produit le score en deux étapes :

1. Une somme pondérée, comme en régression linéaire : z = intercept + weight × feature (ordonnée à l’origine + poids × caractéristique). Avec plusieurs variables, elle ajoute un terme poids × variable pour chacune. Ce z peut être n’importe quel nombre, de très négatif à très positif.
2. La fonction logistique transforme z en nombre de 0 à 1. Le résultat prend la forme d’un S étiré.

Imaginez la courbe en S comme une traductrice prudente qui convertit z en probabilité. Quand z est très négatif, le score est proche de 0. Diminuer encore z ne change presque rien. Quand z est très positif, le score est proche de 1, sans jamais le dépasser. Au milieu, le score change le plus vite. Voici sept valeurs de z et leurs scores :

z	−4	−2	−1	0	1	2	4
score	0,018	0,119	0,269	0,500	0,731	0,881	0,982

z = 0 donne toujours 0,5. Un z négatif donne un score sous 0,5, et un z positif donne un score au-dessus. Le score s’approche de 0 et de 1, mais ne les atteint jamais. La formule est :

$$\text{score} = \frac{1}{1 + e^{-z}}$$

Vérifiez une valeur avec une calculatrice. Pour z = −1 : e¹ = 2,718. Le score vaut donc 1 ÷ (1 + 2,718) = 1 ÷ 3,718 = 0,269.

• Fonction logistique
• Seuil de 0,5

La fonction logistique, avec les trois priorités du modèle à une variable de Priya dans l'exemple détaillé ci-dessous. Les trois sont bien sous le seuil de 0,5.

Description textuelle du graphique

L’axe horizontal représente z, de −8 à 6. La courbe forme un S : proche de 0 à gauche, 0,5 à z = 0, puis proche de 1 à droite. Elle est la plus raide autour de z = 0. Une ligne pointillée marque le seuil de 0,5. Trois points montrent le modèle à une variable de l’exemple détaillé. La priorité 3 est à z = −2,718, avec un score de 0,062. La priorité 2 est à z = −1,854, avec 0,135. La priorité 1 est à z = −0,989, avec 0,271. Chaque billet a un z sous 0, donc aucun billet n’atteint 0,5.

Pourquoi l’appelle-t-on une régression alors qu’elle répond à une question de classification? Parce qu’à l’intérieur, elle ajuste une somme pondérée, comme la régression linéaire. « Logistique » est le nom de la courbe en S. Le nom décrit donc le fonctionnement du modèle, pas sa tâche.

Revenons aux longueurs des messages. Ajustez une régression logistique sur word_count. Sa courbe en S donne 0,070 pour 0 mot et 0,464 pour 500 mots. Elle donne 0,909 pour 1 000 mots et 0,999 pour 2 000 mots. Elle reste entre 0 et 1 pour chaque message :

• Taux de transfert dans les données d'entraînement, par nombre de mots
• Courbe en S (régression logistique)
• Droite
• 0 et 1

Les mêmes données avec la courbe en S d'une régression logistique. Elle se courbe vers 1 sans jamais le dépasser.

Description textuelle du graphique

Les axes et les points sont les mêmes que dans le graphique précédent. La droite pointillée monte de 0,049 à 1,335. La courbe en S commence à 0,070 pour 0 mot. Elle vaut 0,167 à 200 mots et 0,464 à 500 mots. Puis elle se courbe : 0,909 à 1 000 mots et 0,999 à 2 000 mots. Elle ne dépasse jamais 1. Jusqu’à environ 300 mots, la droite et la courbe en S sont proches l’une de l’autre et des points.

La courbe en S corrige les limites. Elle ne fait pas de word_count une bonne variable : le score augmente encore avec chaque mot ajouté. La variation indépendante ci-dessous montre l’effet de cette hausse.

Exemple détaillé : une variable, la priorité

Priya utilise maintenant une variable plus forte, priority (1 est la plus urgente, 3 la moins urgente). Elle charge les données d’entraînement et de validation. Les données de validation servent à vérifier les modèles pendant son travail, comme dans Données d’entraînement, de validation et de test :

valid = pd.read_csv("data/valid.csv")
print(len(train), "train tickets, escalation rate", round(train[TARGET].mean(), 3))
print(len(valid), "valid tickets, escalation rate", round(valid[TARGET].mean(), 3))

Le résultat :

Sortie

16939 train tickets, escalation rate 0.117
1179 valid tickets, escalation rate 0.155

Elle ajuste ensuite une régression logistique. Un estimateur est un objet scikit-learn qui apprend à partir des données : LinearRegression et LogisticRegression sont des estimateurs. fit apprend les nombres de l’estimateur (ici, l’ordonnée à l’origine et le poids) à partir des données d’entraînement. Après fit, l’estimateur est un modèle.

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(train[["priority"]], train[TARGET])
print("intercept:", model.intercept_.round(4))
print("weight of priority:", model.coef_.round(4))

Le résultat :

Sortie

intercept: [-0.1249]
weight of priority: [[-0.8644]]

Le poids est négatif : un numéro de priorité plus élevé (un billet moins urgent) donne un z plus bas. Le score est donc plus bas. Avant de poursuivre, calculez à la main le score d’un billet de priorité 1 : z = −0.1249 + (−0.8644 × 1).

import math


def logistic(z):
    """Bend any number into the range 0 to 1."""
    return 1 / (1 + math.exp(-z))


for priority in [1, 2, 3]:
    z = model.intercept_[0] + model.coef_[0][0] * priority
    rate = train.loc[train["priority"] == priority, TARGET].mean()
    print(f"priority {priority}: z = {z:.3f}, score {logistic(z):.3f}, train rate {rate:.3f}")

Le résultat :

Sortie

priority 1: z = -0.989, score 0.271, train rate 0.291
priority 2: z = -1.854, score 0.135, train rate 0.120
priority 3: z = -2.718, score 0.062, train rate 0.067

Les mêmes nombres dans un tableau :

Priorité	z = −0,1249 − 0,8644 × priorité	Score	Transférés dans les données d’entraînement
1	−0,989	0,271	29,1 %
2	−1,854	0,135	12,0 %
3	−2,718	0,062	6,7 %

Les scores sont proches des taux de transfert dans les données d’entraînement, mais pas égaux. Le modèle doit utiliser une seule droite pour z à travers les trois priorités. La courbe en S la transforme ensuite. Une droite ne peut pas correspondre exactement à trois taux. C’est le coût d’un modèle simple.

predict_proba et predict

Un estimateur de classification répond de deux façons :

• predict_proba (prédire les probabilités) donne les scores, avec une colonne par classe. La colonne 1 ([:, 1]) est le score pour « transféré ».
• predict donne une décision, 0 ou 1. Il signale un billet quand son score dépasse 0,5.

Le score le plus élevé de ce modèle est 0,271, pour la priorité 1. Faites une prédiction avant l’exécution : combien de billets de validation predict signalera-t-il?

scores = model.predict_proba(valid[["priority"]])[:, 1]
flags = model.predict(valid[["priority"]])
print("highest score:", round(scores.max(), 3))
print("flagged by predict:", flags.sum())
print("accuracy:", round((flags == valid[TARGET]).mean(), 3))

Le résultat :

Sortie

highest score: 0.271
flagged by predict: 0
accuracy: 0.845

Aucun score n’atteint 0,5, donc predict ne signale rien. Le résultat est la référence de base majoritaire de Définir une référence de base. Elle atteint 84,5 % d’exactitude, sans détecter aucun transfert. C’est le piège de l’exactitude présenté dans Les métriques de classification. Les scores conviennent : ils classent toujours les billets. Seul le seuil ne convient pas à Larkfield.

Avec un seuil de 0,2, le modèle signale chaque billet de priorité 1 (score de 0,271). Il ne signale aucun autre billet (0,135 et 0,062). C’est la règle « signaler la priorité 1 » : 163 billets, dont 61 transférés. Avec une seule variable, la régression logistique est la règle accompagnée d’un nombre. Plus de variables peuvent mieux classer les billets.

Plusieurs variables

Quatre colonnes ont une valeur pour chaque billet et contiennent déjà des nombres : priority, word_count, prior_tickets_90d et created_hour. Priya ajuste un modèle avec les quatre :

NUMBERS4 = ["priority", "word_count", "prior_tickets_90d", "created_hour"]
model4 = LogisticRegression().fit(train[NUMBERS4], train[TARGET])
print("intercept:", model4.intercept_.round(4))
print(pd.Series(model4.coef_[0], index=NUMBERS4).round(4))

Le résultat :

Sortie

intercept: [-0.7279]
priority            -0.8938
word_count           0.0052
prior_tickets_90d    0.0233
created_hour        -0.0096
dtype: float64

Maintenant, z = −0.7279 − 0.8938 × priority + 0.0052 × word_count + 0.0233 × prior_tickets_90d − 0.0096 × created_hour. Les poids ont des unités différentes : 0,0052 par mot, 0,0233 par billet antérieur. Un petit poids ne signifie donc pas un petit effet. Un billet de 300 mots ajoute 300 × 0,0052 = 1,56 à z, plus qu’un niveau de priorité. Prétraiter avec un pipeline met tous les nombres sur une même échelle.

Pour comparer les deux modèles, Priya utilise les deux métriques de classement du Le compromis entre précision et rappel. Elles mesurent la qualité du classement des billets par les scores, pour tous les seuils à la fois. L’La ROC AUC est la probabilité qu’un billet transféré choisi au hasard dépasse le score d’un autre billet choisi au hasard. Une valeur de 0,5 correspond au hasard. La La précision moyenne (AP) est plus élevée quand les billets transférés sont près du sommet du classement. Un score constant obtient le taux de transfert, soit 0,155.

from sklearn.metrics import average_precision_score, roc_auc_score

scores4 = model4.predict_proba(valid[NUMBERS4])[:, 1]
for name, s in [("priority only", scores), ("four numbers", scores4)]:
    auc = roc_auc_score(valid[TARGET], s)
    ap = average_precision_score(valid[TARGET], s)
    print(f"{name}: ROC AUC {auc:.3f}, AP {ap:.3f}, flagged at 0.5: {(s > 0.5).sum()}")

Le résultat :

Sortie

priority only: ROC AUC 0.658, AP 0.251, flagged at 0.5: 0
four numbers: ROC AUC 0.703, AP 0.312, flagged at 0.5: 6

Les mêmes résultats à côté de la référence de base :

Modèle (données de validation)	Aire sous la courbe ROC	AP	Signalés à 0,5
Score constant (référence de base)	0,5	0,155	—
priority seulement	0,658	0,251	0
Quatre nombres	0,703	0,312	6 sur 1 179

Le modèle à quatre variables classe mieux les billets. Mais à 0,5, il ne signale encore que 6 billets sur 1 179.

Seulement quatre variables, pour l’instant

Les dix variables du cours SQL et préparation des données pour l’IA comprennent quatre catégories textuelles (channel, team, segment, region). Elles comprennent aussi deux nombres avec des valeurs manquantes (order_value, customer_tenure_days). Une régression logistique exige des nombres sans valeurs manquantes. Elle ne peut donc pas encore utiliser ces six variables. La prochaine leçon montre chacun de ces problèmes sur de vrais billets, puis les résout tous avec un seul outil.

Quand utiliser la régression logistique

La régression logistique est habituellement le premier modèle pour une question oui ou non. Elle s’entraîne en une seconde, fonctionne avec peu de données et donne un score qui classe les cas. Chaque poids a une direction qu’une personne peut vérifier : ici, une priorité plus urgente augmente le score. Une banque, un hôpital ou l’équipe de Grace peut suivre la construction d’un score. C’est important quand les gens doivent lui faire confiance.

Ses limites viennent de la somme pondérée à l’intérieur. Chaque variable modifie z d’une quantité fixe par unité. Le modèle ne peut donc pas apprendre un effet qui monte puis descend, ou qui dépend d’une autre variable. Pour cela, vous devez ajouter des variables qui représentent ces effets. D’autres familles de modèles, comme les arbres de décision du module Essayer d’autres familles de modèles, peuvent apprendre ces régularités. Comme la régression linéaire, elle exige aussi des nombres sans valeurs manquantes, sur des échelles semblables. C’est le sujet de la prochaine leçon.

Exercice guidé : un seuil de 0,2

Le carnet de la leçon contient toutes les cellules de cette page. L’encadré en haut contient les liens Colab et Kaggle.

1. Ouvrez le carnet dans Colab ou Kaggle et exécutez les cellules de configuration. Vous devriez voir la ligne Ready: (prêt).
2. Dans la section 1, exécutez la droite sur word_count. Vous devriez voir 1.335 pour 2 000 mots. Exécutez ensuite la droite à quatre variables. Vous devriez voir 570 billets d’entraînement sous 0.
3. Dans la section 2, prédisez le score pour z = 0. Exécutez ensuite la cellule. Vous devriez voir z = 0 -> score 0.500 (z vaut 0, donc le score vaut 0,500).
4. Dans la section 3, calculez à la main le score de priorité 1 avant d’exécuter la cellule. Vous devriez voir score 0.271 (score de 0,271).
5. Dans la section 4, prédisez combien de billets predict signale. Vous devriez voir flagged by predict: 0 (signalés par predict : 0).
6. Faites la tâche Your turn (à vous) : comptez les billets dont le score atteint au moins 0,2, puis ceux qui ont été transférés.
7. Exécutez la cellule de vérification. Elle affiche Check passed (vérification réussie) quand les deux nombres sont corrects.

Afficher la réponse à l’étape 6

flags_02 = scores >= 0.2
flagged_02 = int(flags_02.sum())
caught_02 = int((flags_02 & (valid[TARGET] == 1)).sum())
print(flagged_02, caught_02)

Le résultat :

Sortie

163 61

163 billets signalés, dont 61 transférés : le même résultat que la règle « signaler la priorité 1 ». La précision vaut 61 ÷ 163 = 0,374, et le rappel vaut 61 ÷ 183 = 0,333.

Exécuter le carnet sur votre ordinateur

Téléchargez le carnet avec View on GitHub (voir sur GitHub), puis le bouton de téléchargement. Enregistrez-le dans ~/projects/ticket-model/notebooks/. Dans VS Code, ouvrez-le et sélectionnez Select Kernel › Python Environments › .venv (sélectionner le noyau › environnements Python › .venv). Le carnet crée son propre dossier ticket-model à côté de lui et y travaille. Il ne modifie donc jamais les fichiers de votre projet.

Variation autonome : word_count au lieu de priority

Changez une seule chose : entraînez le modèle à une variable avec word_count plutôt que priority. Avant de l’exécuter, prédisez : classera-t-il mieux ou moins bien qu’avec la priorité (aire sous la courbe ROC de 0,658)? Est-ce que predict signalera quelque chose? Dans le carnet Jupyter, la section 6 contient la tâche et une vérification.

Afficher la réponse

model_words = LogisticRegression()
model_words.fit(train[["word_count"]], train[TARGET])
scores_words = model_words.predict_proba(valid[["word_count"]])[:, 1]
auc_words = round(roc_auc_score(valid[TARGET], scores_words), 3)
flagged_words = int(model_words.predict(valid[["word_count"]]).sum())
print(auc_words, flagged_words)

La sortie :

Sortie

0.598 1

Avec word_count seulement, le classement est moins bon qu’avec la priorité : aire sous la courbe ROC de 0,598 contre 0,658. Les longs messages passent un peu plus souvent à l’équipe supérieure, mais le signal est faible. predict signale 1 billet, et ce billet n’a pas été transféré à l’équipe supérieure.

Pourquoi un seul? Le poids est de +0,0049 par mot et l’ordonnée à l’origine est de −2,5871. Donc, z atteint 0 à environ 529 mots. Un seul billet de validation est aussi long : 573 mots. La courbe en S garde le score sous 1. Mais le poids s’accumule avec chaque mot, donc quelques billets extrêmes obtiennent un score élevé. Le modèle signale le message le plus long, pas le problème le plus urgent.

Erreur courante

predict comme décision

Symptôme : Tomás présente les résultats du modèle à quatre variables avec predict. L’exactitude semble bonne :

flags4 = model4.predict(valid[NUMBERS4])
caught = int((flags4 & (valid[TARGET] == 1)).sum())
print("flagged:", flags4.sum(), "of", len(valid))
print("caught:", caught, "of", valid[TARGET].sum(), "escalations")
print("accuracy:", round((flags4 == valid[TARGET]).mean(), 3))

La sortie :

Sortie

flagged: 6 of 1179
caught: 2 of 183 escalations
accuracy: 0.843

84,3 % semble bon. Mais « ne jamais transférer à l’équipe supérieure » atteint 84,5 %, et le modèle détecte seulement 2 des 183 transferts.

Cause : predict utilise un seuil de 0,5. Ce seuil par défaut convient à deux classes de taille semblable. Ici, 15,5 % des billets passent à l’équipe supérieure, et très peu de scores atteignent 0,5. Même le modèle final de ce cours signale seulement 25 des 1 179 billets (2,1 %) à 0,5.

Solution : utilisez predict_proba et choisissez le seuil selon la décision à prendre. L’équipe expérimentée de Grace peut examiner au plus 1 billet sur 5 (20 %). À 0,2, ce modèle signale 192 billets (16,3 %) et détecte 73 transferts. Seuils et calibration choisit le seuil correctement, sur les données de validation.

Conséquence dans le travail en IA : predict ne produit aucune erreur et donne une exactitude élevée. Une équipe qui le déploie livre un modèle qui ne signale presque rien. Les clients ayant des problèmes graves attendent dans la file normale, et le rapport indique une exactitude de 84 %.

De bout en boutPrédire le défaut de paiement par carte de créditÉtude de cas

L’étude de cas sur le crédit crée un pipeline de régression logistique à partir de 30 000 clients réels.

Vérification des connaissances

Vérifiez votre compréhension

Tomás veut prédire le transfert à l'équipe supérieure avec une régression linéaire sur la cible 0/1. Donnez deux raisons, avec des nombres de cette leçon, pour lesquelles sa sortie n'est pas une probabilité.

Afficher la réponse

D’abord, une droite n’a pas de limites. Avec word_count, la droite donne 1,335 pour un message de 2 000 mots, soit une « probabilité » de 134 %. Avec quatre variables, 570 billets d’entraînement obtiennent une valeur inférieure à 0. Une probabilité doit rester entre 0 et 1. Ensuite, la droite monte de la même quantité pour chaque mot. Mais le taux réel de transfert augmente rapidement pour les messages courts, puis lentement après environ 150 mots. La régression logistique garde la somme pondérée, mais la transforme avec la courbe en S. Ainsi, chaque score reste entre 0 et 1.

Vérifiez votre compréhension

Un billet a z = 0,6. Quel score la fonction logistique donne-t-elle, et le billet est-il signalé au seuil par défaut?

Afficher la réponse

e^−0,6 = 0,549. Le score est donc 1 ÷ 1,549 = 0,646. Un z positif donne toujours un score supérieur à 0,5, donc predict signale ce billet. À un seuil de 0,7, il ne serait pas signalé.

Vérifiez votre compréhension

Prédisez et expliquez : Omar, le responsable de produit, dit : le modèle à quatre variables a une exactitude de 84,3 %, donc il est prêt. Que lui dites-vous?

Afficher la réponse

L’exactitude vient de predict, qui utilise 0,5. À 0,5, le modèle signale 6 des 1 179 billets et détecte 2 des 183 transferts à l’équipe supérieure. « Ne jamais transférer à l’équipe supérieure » a une exactitude plus élevée, 84,5 %, et ne détecte rien. L’exactitude est élevée parce que la plupart des billets ne passent pas à l’équipe supérieure. Elle ne mesure donc pas la décision. Les scores classent toutefois mieux que la règle (aire sous la courbe ROC de 0,703). Mais le modèle a besoin d’un seuil choisi pour la capacité de 20 %. Il faut aussi le comparer à la règle pour cette même charge de travail.

Récapitulatif

Vous pouvez maintenant expliquer comment la régression logistique transforme les données d’un billet en décision :

• Une droite ne peut pas donner une probabilité. Avec word_count, elle atteint 1,335 à 2 000 mots. Avec quatre variables, 570 billets d’entraînement obtiennent une valeur inférieure à 0.
• La régression logistique garde la somme pondérée z. Elle la transforme avec la fonction logistique, une courbe en S, en un score de 0 à 1. z = 0 donne 0,5. Pour la priorité 1, z = −0,989 et le score est de 0,271.
• predict_proba donne les scores. predict signale un billet quand son score dépasse 0,5.
• Avec les données de Larkfield, 0,5 ne signale presque rien : 0 billet avec la priorité seule, 6 avec quatre variables. À 0,2, le modèle basé sur la priorité correspond à la règle « signaler la priorité 1 ».
• Quatre variables classent mieux qu’une seule : aire sous la courbe ROC de 0,703 et AP de 0,312, contre 0,658 et 0,251.

Les catégories textuelles et les valeurs manquantes bloquent encore le modèle. La prochaine leçon montre chaque problème sur de vrais billets, puis les résout tous avec un pipeline.

Leçon suivante : Prétraiter avec un pipeline